pub trait Visit<'ast, T: AstInfo, > {
    fn visit_abbreviated_grant_or_revoke_statement(&mut self, node: &'ast AbbreviatedGrantOrRevokeStatement<T>) {
        visit_abbreviated_grant_or_revoke_statement(self, node)
    }
    fn visit_abbreviated_grant_statement(&mut self, node: &'ast AbbreviatedGrantStatement<T>) {
        visit_abbreviated_grant_statement(self, node)
    }
    fn visit_abbreviated_revoke_statement(&mut self, node: &'ast AbbreviatedRevokeStatement<T>) {
        visit_abbreviated_revoke_statement(self, node)
    }
    fn visit_alter_cluster_action(&mut self, node: &'ast AlterClusterAction<T>) {
        visit_alter_cluster_action(self, node)
    }
    fn visit_alter_cluster_statement(&mut self, node: &'ast AlterClusterStatement<T>) {
        visit_alter_cluster_statement(self, node)
    }
    fn visit_alter_connection_action(&mut self, node: &'ast AlterConnectionAction<T>) {
        visit_alter_connection_action(self, node)
    }
    fn visit_alter_connection_option(&mut self, node: &'ast AlterConnectionOption<T>) {
        visit_alter_connection_option(self, node)
    }
    fn visit_alter_connection_option_name(&mut self, node: &'ast AlterConnectionOptionName) {
        visit_alter_connection_option_name(self, node)
    }
    fn visit_alter_connection_statement(&mut self, node: &'ast AlterConnectionStatement<T>) {
        visit_alter_connection_statement(self, node)
    }
    fn visit_alter_default_privileges_statement(&mut self, node: &'ast AlterDefaultPrivilegesStatement<T>) {
        visit_alter_default_privileges_statement(self, node)
    }
    fn visit_alter_index_action(&mut self, node: &'ast AlterIndexAction<T>) {
        visit_alter_index_action(self, node)
    }
    fn visit_alter_index_statement(&mut self, node: &'ast AlterIndexStatement<T>) {
        visit_alter_index_statement(self, node)
    }
    fn visit_alter_object_rename_statement(&mut self, node: &'ast AlterObjectRenameStatement) {
        visit_alter_object_rename_statement(self, node)
    }
    fn visit_alter_object_swap_statement(&mut self, node: &'ast AlterObjectSwapStatement) {
        visit_alter_object_swap_statement(self, node)
    }
    fn visit_alter_owner_statement(&mut self, node: &'ast AlterOwnerStatement<T>) {
        visit_alter_owner_statement(self, node)
    }
    fn visit_alter_retain_history_statement(&mut self, node: &'ast AlterRetainHistoryStatement<T>) {
        visit_alter_retain_history_statement(self, node)
    }
    fn visit_alter_role_option(&mut self, node: &'ast AlterRoleOption) {
        visit_alter_role_option(self, node)
    }
    fn visit_alter_role_statement(&mut self, node: &'ast AlterRoleStatement<T>) {
        visit_alter_role_statement(self, node)
    }
    fn visit_alter_secret_statement(&mut self, node: &'ast AlterSecretStatement<T>) {
        visit_alter_secret_statement(self, node)
    }
    fn visit_alter_set_cluster_statement(&mut self, node: &'ast AlterSetClusterStatement<T>) {
        visit_alter_set_cluster_statement(self, node)
    }
    fn visit_alter_sink_action(&mut self, node: &'ast AlterSinkAction<T>) {
        visit_alter_sink_action(self, node)
    }
    fn visit_alter_sink_statement(&mut self, node: &'ast AlterSinkStatement<T>) {
        visit_alter_sink_statement(self, node)
    }
    fn visit_alter_source_action(&mut self, node: &'ast AlterSourceAction<T>) {
        visit_alter_source_action(self, node)
    }
    fn visit_alter_source_add_subsource_option(&mut self, node: &'ast AlterSourceAddSubsourceOption<T>) {
        visit_alter_source_add_subsource_option(self, node)
    }
    fn visit_alter_source_add_subsource_option_name(&mut self, node: &'ast AlterSourceAddSubsourceOptionName) {
        visit_alter_source_add_subsource_option_name(self, node)
    }
    fn visit_alter_source_statement(&mut self, node: &'ast AlterSourceStatement<T>) {
        visit_alter_source_statement(self, node)
    }
    fn visit_alter_system_reset_all_statement(&mut self, node: &'ast AlterSystemResetAllStatement) {
        visit_alter_system_reset_all_statement(self, node)
    }
    fn visit_alter_system_reset_statement(&mut self, node: &'ast AlterSystemResetStatement) {
        visit_alter_system_reset_statement(self, node)
    }
    fn visit_alter_system_set_statement(&mut self, node: &'ast AlterSystemSetStatement) {
        visit_alter_system_set_statement(self, node)
    }
    fn visit_alter_table_add_column_statement(&mut self, node: &'ast AlterTableAddColumnStatement<T>) {
        visit_alter_table_add_column_statement(self, node)
    }
    fn visit_as_of(&mut self, node: &'ast AsOf<T>) {
        visit_as_of(self, node)
    }
    fn visit_assignment(&mut self, node: &'ast Assignment<T>) {
        visit_assignment(self, node)
    }
    fn visit_avro_doc_on(&mut self, node: &'ast AvroDocOn<T>) {
        visit_avro_doc_on(self, node)
    }
    fn visit_avro_schema(&mut self, node: &'ast AvroSchema<T>) {
        visit_avro_schema(self, node)
    }
    fn visit_avro_schema_option(&mut self, node: &'ast AvroSchemaOption<T>) {
        visit_avro_schema_option(self, node)
    }
    fn visit_avro_schema_option_name(&mut self, node: &'ast AvroSchemaOptionName) {
        visit_avro_schema_option_name(self, node)
    }
    fn visit_catalog_name(&mut self, node: &'ast CatalogName) {
        visit_catalog_name(self, node)
    }
    fn visit_close_statement(&mut self, node: &'ast CloseStatement) {
        visit_close_statement(self, node)
    }
    fn visit_cluster_alter_option(&mut self, node: &'ast ClusterAlterOption<T>) {
        visit_cluster_alter_option(self, node)
    }
    fn visit_cluster_alter_option_name(&mut self, node: &'ast ClusterAlterOptionName) {
        visit_cluster_alter_option_name(self, node)
    }
    fn visit_cluster_alter_option_value(&mut self, node: &'ast ClusterAlterOptionValue) {
        visit_cluster_alter_option_value(self, node)
    }
    fn visit_cluster_feature(&mut self, node: &'ast ClusterFeature<T>) {
        visit_cluster_feature(self, node)
    }
    fn visit_cluster_feature_name(&mut self, node: &'ast ClusterFeatureName) {
        visit_cluster_feature_name(self, node)
    }
    fn visit_cluster_option(&mut self, node: &'ast ClusterOption<T>) {
        visit_cluster_option(self, node)
    }
    fn visit_cluster_option_name(&mut self, node: &'ast ClusterOptionName) {
        visit_cluster_option_name(self, node)
    }
    fn visit_cluster_schedule_option_value(&mut self, node: &'ast ClusterScheduleOptionValue) {
        visit_cluster_schedule_option_value(self, node)
    }
    fn visit_column_def(&mut self, node: &'ast ColumnDef<T>) {
        visit_column_def(self, node)
    }
    fn visit_column_name(&mut self, node: &'ast ColumnName<T>) {
        visit_column_name(self, node)
    }
    fn visit_column_option(&mut self, node: &'ast ColumnOption<T>) {
        visit_column_option(self, node)
    }
    fn visit_column_option_def(&mut self, node: &'ast ColumnOptionDef<T>) {
        visit_column_option_def(self, node)
    }
    fn visit_comment_object_type(&mut self, node: &'ast CommentObjectType<T>) {
        visit_comment_object_type(self, node)
    }
    fn visit_comment_statement(&mut self, node: &'ast CommentStatement<T>) {
        visit_comment_statement(self, node)
    }
    fn visit_commit_statement(&mut self, node: &'ast CommitStatement) {
        visit_commit_statement(self, node)
    }
    fn visit_connection_default_aws_privatelink(&mut self, node: &'ast ConnectionDefaultAwsPrivatelink<T>) {
        visit_connection_default_aws_privatelink(self, node)
    }
    fn visit_connection_option(&mut self, node: &'ast ConnectionOption<T>) {
        visit_connection_option(self, node)
    }
    fn visit_connection_option_name(&mut self, node: &'ast ConnectionOptionName) {
        visit_connection_option_name(self, node)
    }
    fn visit_copy_direction(&mut self, node: &'ast CopyDirection) {
        visit_copy_direction(self, node)
    }
    fn visit_copy_option(&mut self, node: &'ast CopyOption<T>) {
        visit_copy_option(self, node)
    }
    fn visit_copy_option_name(&mut self, node: &'ast CopyOptionName) {
        visit_copy_option_name(self, node)
    }
    fn visit_copy_relation(&mut self, node: &'ast CopyRelation<T>) {
        visit_copy_relation(self, node)
    }
    fn visit_copy_statement(&mut self, node: &'ast CopyStatement<T>) {
        visit_copy_statement(self, node)
    }
    fn visit_copy_target(&mut self, node: &'ast CopyTarget<T>) {
        visit_copy_target(self, node)
    }
    fn visit_create_cluster_replica_statement(&mut self, node: &'ast CreateClusterReplicaStatement<T>) {
        visit_create_cluster_replica_statement(self, node)
    }
    fn visit_create_cluster_statement(&mut self, node: &'ast CreateClusterStatement<T>) {
        visit_create_cluster_statement(self, node)
    }
    fn visit_create_connection_option(&mut self, node: &'ast CreateConnectionOption<T>) {
        visit_create_connection_option(self, node)
    }
    fn visit_create_connection_option_name(&mut self, node: &'ast CreateConnectionOptionName) {
        visit_create_connection_option_name(self, node)
    }
    fn visit_create_connection_statement(&mut self, node: &'ast CreateConnectionStatement<T>) {
        visit_create_connection_statement(self, node)
    }
    fn visit_create_connection_type(&mut self, node: &'ast CreateConnectionType) {
        visit_create_connection_type(self, node)
    }
    fn visit_create_database_statement(&mut self, node: &'ast CreateDatabaseStatement) {
        visit_create_database_statement(self, node)
    }
    fn visit_create_index_statement(&mut self, node: &'ast CreateIndexStatement<T>) {
        visit_create_index_statement(self, node)
    }
    fn visit_create_materialized_view_statement(&mut self, node: &'ast CreateMaterializedViewStatement<T>) {
        visit_create_materialized_view_statement(self, node)
    }
    fn visit_create_role_statement(&mut self, node: &'ast CreateRoleStatement) {
        visit_create_role_statement(self, node)
    }
    fn visit_create_schema_statement(&mut self, node: &'ast CreateSchemaStatement) {
        visit_create_schema_statement(self, node)
    }
    fn visit_create_secret_statement(&mut self, node: &'ast CreateSecretStatement<T>) {
        visit_create_secret_statement(self, node)
    }
    fn visit_create_sink_connection(&mut self, node: &'ast CreateSinkConnection<T>) {
        visit_create_sink_connection(self, node)
    }
    fn visit_create_sink_option(&mut self, node: &'ast CreateSinkOption<T>) {
        visit_create_sink_option(self, node)
    }
    fn visit_create_sink_option_name(&mut self, node: &'ast CreateSinkOptionName) {
        visit_create_sink_option_name(self, node)
    }
    fn visit_create_sink_statement(&mut self, node: &'ast CreateSinkStatement<T>) {
        visit_create_sink_statement(self, node)
    }
    fn visit_create_source_connection(&mut self, node: &'ast CreateSourceConnection<T>) {
        visit_create_source_connection(self, node)
    }
    fn visit_create_source_option(&mut self, node: &'ast CreateSourceOption<T>) {
        visit_create_source_option(self, node)
    }
    fn visit_create_source_option_name(&mut self, node: &'ast CreateSourceOptionName) {
        visit_create_source_option_name(self, node)
    }
    fn visit_create_source_statement(&mut self, node: &'ast CreateSourceStatement<T>) {
        visit_create_source_statement(self, node)
    }
    fn visit_create_subsource_option(&mut self, node: &'ast CreateSubsourceOption<T>) {
        visit_create_subsource_option(self, node)
    }
    fn visit_create_subsource_option_name(&mut self, node: &'ast CreateSubsourceOptionName) {
        visit_create_subsource_option_name(self, node)
    }
    fn visit_create_subsource_statement(&mut self, node: &'ast CreateSubsourceStatement<T>) {
        visit_create_subsource_statement(self, node)
    }
    fn visit_create_table_from_source_statement(&mut self, node: &'ast CreateTableFromSourceStatement<T>) {
        visit_create_table_from_source_statement(self, node)
    }
    fn visit_create_table_statement(&mut self, node: &'ast CreateTableStatement<T>) {
        visit_create_table_statement(self, node)
    }
    fn visit_create_type_as(&mut self, node: &'ast CreateTypeAs<T>) {
        visit_create_type_as(self, node)
    }
    fn visit_create_type_list_option(&mut self, node: &'ast CreateTypeListOption<T>) {
        visit_create_type_list_option(self, node)
    }
    fn visit_create_type_list_option_name(&mut self, node: &'ast CreateTypeListOptionName) {
        visit_create_type_list_option_name(self, node)
    }
    fn visit_create_type_map_option(&mut self, node: &'ast CreateTypeMapOption<T>) {
        visit_create_type_map_option(self, node)
    }
    fn visit_create_type_map_option_name(&mut self, node: &'ast CreateTypeMapOptionName) {
        visit_create_type_map_option_name(self, node)
    }
    fn visit_create_type_statement(&mut self, node: &'ast CreateTypeStatement<T>) {
        visit_create_type_statement(self, node)
    }
    fn visit_create_view_statement(&mut self, node: &'ast CreateViewStatement<T>) {
        visit_create_view_statement(self, node)
    }
    fn visit_create_webhook_source_body(&mut self, node: &'ast CreateWebhookSourceBody) {
        visit_create_webhook_source_body(self, node)
    }
    fn visit_create_webhook_source_check(&mut self, node: &'ast CreateWebhookSourceCheck<T>) {
        visit_create_webhook_source_check(self, node)
    }
    fn visit_create_webhook_source_check_options(&mut self, node: &'ast CreateWebhookSourceCheckOptions<T>) {
        visit_create_webhook_source_check_options(self, node)
    }
    fn visit_create_webhook_source_filter_header(&mut self, node: &'ast CreateWebhookSourceFilterHeader) {
        visit_create_webhook_source_filter_header(self, node)
    }
    fn visit_create_webhook_source_header(&mut self, node: &'ast CreateWebhookSourceHeader) {
        visit_create_webhook_source_header(self, node)
    }
    fn visit_create_webhook_source_include_headers(&mut self, node: &'ast CreateWebhookSourceIncludeHeaders) {
        visit_create_webhook_source_include_headers(self, node)
    }
    fn visit_create_webhook_source_map_header(&mut self, node: &'ast CreateWebhookSourceMapHeader) {
        visit_create_webhook_source_map_header(self, node)
    }
    fn visit_create_webhook_source_secret(&mut self, node: &'ast CreateWebhookSourceSecret<T>) {
        visit_create_webhook_source_secret(self, node)
    }
    fn visit_create_webhook_source_statement(&mut self, node: &'ast CreateWebhookSourceStatement<T>) {
        visit_create_webhook_source_statement(self, node)
    }
    fn visit_csr_config_option(&mut self, node: &'ast CsrConfigOption<T>) {
        visit_csr_config_option(self, node)
    }
    fn visit_csr_config_option_name(&mut self, node: &'ast CsrConfigOptionName<T>) {
        visit_csr_config_option_name(self, node)
    }
    fn visit_csr_connection(&mut self, node: &'ast CsrConnection<T>) {
        visit_csr_connection(self, node)
    }
    fn visit_csr_connection_avro(&mut self, node: &'ast CsrConnectionAvro<T>) {
        visit_csr_connection_avro(self, node)
    }
    fn visit_csr_connection_protobuf(&mut self, node: &'ast CsrConnectionProtobuf<T>) {
        visit_csr_connection_protobuf(self, node)
    }
    fn visit_csr_seed_avro(&mut self, node: &'ast CsrSeedAvro) {
        visit_csr_seed_avro(self, node)
    }
    fn visit_csr_seed_protobuf(&mut self, node: &'ast CsrSeedProtobuf) {
        visit_csr_seed_protobuf(self, node)
    }
    fn visit_csr_seed_protobuf_schema(&mut self, node: &'ast CsrSeedProtobufSchema) {
        visit_csr_seed_protobuf_schema(self, node)
    }
    fn visit_csv_columns(&mut self, node: &'ast CsvColumns) {
        visit_csv_columns(self, node)
    }
    fn visit_cte(&mut self, node: &'ast Cte<T>) {
        visit_cte(self, node)
    }
    fn visit_cte_block(&mut self, node: &'ast CteBlock<T>) {
        visit_cte_block(self, node)
    }
    fn visit_cte_mut_rec(&mut self, node: &'ast CteMutRec<T>) {
        visit_cte_mut_rec(self, node)
    }
    fn visit_cte_mut_rec_column_def(&mut self, node: &'ast CteMutRecColumnDef<T>) {
        visit_cte_mut_rec_column_def(self, node)
    }
    fn visit_date_time_field(&mut self, node: &'ast DateTimeField) {
        visit_date_time_field(self, node)
    }
    fn visit_deallocate_statement(&mut self, node: &'ast DeallocateStatement) {
        visit_deallocate_statement(self, node)
    }
    fn visit_declare_statement(&mut self, node: &'ast DeclareStatement<T>) {
        visit_declare_statement(self, node)
    }
    fn visit_deferred_item_name(&mut self, node: &'ast DeferredItemName<T>) {
        visit_deferred_item_name(self, node)
    }
    fn visit_delete_statement(&mut self, node: &'ast DeleteStatement<T>) {
        visit_delete_statement(self, node)
    }
    fn visit_discard_statement(&mut self, node: &'ast DiscardStatement) {
        visit_discard_statement(self, node)
    }
    fn visit_discard_target(&mut self, node: &'ast DiscardTarget) {
        visit_discard_target(self, node)
    }
    fn visit_distinct(&mut self, node: &'ast Distinct<T>) {
        visit_distinct(self, node)
    }
    fn visit_doc_on_identifier(&mut self, node: &'ast DocOnIdentifier<T>) {
        visit_doc_on_identifier(self, node)
    }
    fn visit_doc_on_schema(&mut self, node: &'ast DocOnSchema) {
        visit_doc_on_schema(self, node)
    }
    fn visit_drop_objects_statement(&mut self, node: &'ast DropObjectsStatement) {
        visit_drop_objects_statement(self, node)
    }
    fn visit_drop_owned_statement(&mut self, node: &'ast DropOwnedStatement<T>) {
        visit_drop_owned_statement(self, node)
    }
    fn visit_execute_statement(&mut self, node: &'ast ExecuteStatement<T>) {
        visit_execute_statement(self, node)
    }
    fn visit_explain_format(&mut self, node: &'ast ExplainFormat) {
        visit_explain_format(self, node)
    }
    fn visit_explain_plan_option(&mut self, node: &'ast ExplainPlanOption<T>) {
        visit_explain_plan_option(self, node)
    }
    fn visit_explain_plan_option_name(&mut self, node: &'ast ExplainPlanOptionName) {
        visit_explain_plan_option_name(self, node)
    }
    fn visit_explain_plan_statement(&mut self, node: &'ast ExplainPlanStatement<T>) {
        visit_explain_plan_statement(self, node)
    }
    fn visit_explain_pushdown_statement(&mut self, node: &'ast ExplainPushdownStatement<T>) {
        visit_explain_pushdown_statement(self, node)
    }
    fn visit_explain_sink_schema_for(&mut self, node: &'ast ExplainSinkSchemaFor) {
        visit_explain_sink_schema_for(self, node)
    }
    fn visit_explain_sink_schema_statement(&mut self, node: &'ast ExplainSinkSchemaStatement<T>) {
        visit_explain_sink_schema_statement(self, node)
    }
    fn visit_explain_stage(&mut self, node: &'ast ExplainStage) {
        visit_explain_stage(self, node)
    }
    fn visit_explain_timestamp_statement(&mut self, node: &'ast ExplainTimestampStatement<T>) {
        visit_explain_timestamp_statement(self, node)
    }
    fn visit_explainee(&mut self, node: &'ast Explainee<T>) {
        visit_explainee(self, node)
    }
    fn visit_expr(&mut self, node: &'ast Expr<T>) {
        visit_expr(self, node)
    }
    fn visit_external_reference_export(&mut self, node: &'ast ExternalReferenceExport) {
        visit_external_reference_export(self, node)
    }
    fn visit_external_references(&mut self, node: &'ast ExternalReferences) {
        visit_external_references(self, node)
    }
    fn visit_fetch_direction(&mut self, node: &'ast FetchDirection) {
        visit_fetch_direction(self, node)
    }
    fn visit_fetch_option(&mut self, node: &'ast FetchOption<T>) {
        visit_fetch_option(self, node)
    }
    fn visit_fetch_option_name(&mut self, node: &'ast FetchOptionName) {
        visit_fetch_option_name(self, node)
    }
    fn visit_fetch_statement(&mut self, node: &'ast FetchStatement<T>) {
        visit_fetch_statement(self, node)
    }
    fn visit_format(&mut self, node: &'ast Format<T>) {
        visit_format(self, node)
    }
    fn visit_format_specifier(&mut self, node: &'ast FormatSpecifier<T>) {
        visit_format_specifier(self, node)
    }
    fn visit_function(&mut self, node: &'ast Function<T>) {
        visit_function(self, node)
    }
    fn visit_function_args(&mut self, node: &'ast FunctionArgs<T>) {
        visit_function_args(self, node)
    }
    fn visit_grant_privileges_statement(&mut self, node: &'ast GrantPrivilegesStatement<T>) {
        visit_grant_privileges_statement(self, node)
    }
    fn visit_grant_role_statement(&mut self, node: &'ast GrantRoleStatement<T>) {
        visit_grant_role_statement(self, node)
    }
    fn visit_grant_target_all_specification(&mut self, node: &'ast GrantTargetAllSpecification<T>) {
        visit_grant_target_all_specification(self, node)
    }
    fn visit_grant_target_specification(&mut self, node: &'ast GrantTargetSpecification<T>) {
        visit_grant_target_specification(self, node)
    }
    fn visit_grant_target_specification_inner(&mut self, node: &'ast GrantTargetSpecificationInner<T>) {
        visit_grant_target_specification_inner(self, node)
    }
    fn visit_homogenizing_function(&mut self, node: &'ast HomogenizingFunction) {
        visit_homogenizing_function(self, node)
    }
    fn visit_ident(&mut self, node: &'ast Ident) {
        visit_ident(self, node)
    }
    fn visit_ident_error(&mut self, node: &'ast IdentError) {
        visit_ident_error(self, node)
    }
    fn visit_if_exists_behavior(&mut self, node: &'ast IfExistsBehavior) {
        visit_if_exists_behavior(self, node)
    }
    fn visit_index_option(&mut self, node: &'ast IndexOption<T>) {
        visit_index_option(self, node)
    }
    fn visit_index_option_name(&mut self, node: &'ast IndexOptionName) {
        visit_index_option_name(self, node)
    }
    fn visit_insert_source(&mut self, node: &'ast InsertSource<T>) {
        visit_insert_source(self, node)
    }
    fn visit_insert_statement(&mut self, node: &'ast InsertStatement<T>) {
        visit_insert_statement(self, node)
    }
    fn visit_inspect_shard_statement(&mut self, node: &'ast InspectShardStatement) {
        visit_inspect_shard_statement(self, node)
    }
    fn visit_interval_value(&mut self, node: &'ast IntervalValue) {
        visit_interval_value(self, node)
    }
    fn visit_is_expr_construct(&mut self, node: &'ast IsExprConstruct<T>) {
        visit_is_expr_construct(self, node)
    }
    fn visit_join(&mut self, node: &'ast Join<T>) {
        visit_join(self, node)
    }
    fn visit_join_constraint(&mut self, node: &'ast JoinConstraint<T>) {
        visit_join_constraint(self, node)
    }
    fn visit_join_operator(&mut self, node: &'ast JoinOperator<T>) {
        visit_join_operator(self, node)
    }
    fn visit_kafka_broker(&mut self, node: &'ast KafkaBroker<T>) {
        visit_kafka_broker(self, node)
    }
    fn visit_kafka_broker_aws_privatelink(&mut self, node: &'ast KafkaBrokerAwsPrivatelink<T>) {
        visit_kafka_broker_aws_privatelink(self, node)
    }
    fn visit_kafka_broker_aws_privatelink_option(&mut self, node: &'ast KafkaBrokerAwsPrivatelinkOption<T>) {
        visit_kafka_broker_aws_privatelink_option(self, node)
    }
    fn visit_kafka_broker_aws_privatelink_option_name(&mut self, node: &'ast KafkaBrokerAwsPrivatelinkOptionName) {
        visit_kafka_broker_aws_privatelink_option_name(self, node)
    }
    fn visit_kafka_broker_tunnel(&mut self, node: &'ast KafkaBrokerTunnel<T>) {
        visit_kafka_broker_tunnel(self, node)
    }
    fn visit_kafka_sink_config_option(&mut self, node: &'ast KafkaSinkConfigOption<T>) {
        visit_kafka_sink_config_option(self, node)
    }
    fn visit_kafka_sink_config_option_name(&mut self, node: &'ast KafkaSinkConfigOptionName) {
        visit_kafka_sink_config_option_name(self, node)
    }
    fn visit_kafka_sink_key(&mut self, node: &'ast KafkaSinkKey) {
        visit_kafka_sink_key(self, node)
    }
    fn visit_kafka_source_config_option(&mut self, node: &'ast KafkaSourceConfigOption<T>) {
        visit_kafka_source_config_option(self, node)
    }
    fn visit_kafka_source_config_option_name(&mut self, node: &'ast KafkaSourceConfigOptionName) {
        visit_kafka_source_config_option_name(self, node)
    }
    fn visit_key_constraint(&mut self, node: &'ast KeyConstraint) {
        visit_key_constraint(self, node)
    }
    fn visit_limit(&mut self, node: &'ast Limit<T>) {
        visit_limit(self, node)
    }
    fn visit_load_generator(&mut self, node: &'ast LoadGenerator) {
        visit_load_generator(self, node)
    }
    fn visit_load_generator_option(&mut self, node: &'ast LoadGeneratorOption<T>) {
        visit_load_generator_option(self, node)
    }
    fn visit_load_generator_option_name(&mut self, node: &'ast LoadGeneratorOptionName) {
        visit_load_generator_option_name(self, node)
    }
    fn visit_map_entry(&mut self, node: &'ast MapEntry<T>) {
        visit_map_entry(self, node)
    }
    fn visit_materialized_view_option(&mut self, node: &'ast MaterializedViewOption<T>) {
        visit_materialized_view_option(self, node)
    }
    fn visit_materialized_view_option_name(&mut self, node: &'ast MaterializedViewOptionName) {
        visit_materialized_view_option_name(self, node)
    }
    fn visit_mut_rec_block(&mut self, node: &'ast MutRecBlock<T>) {
        visit_mut_rec_block(self, node)
    }
    fn visit_mut_rec_block_option(&mut self, node: &'ast MutRecBlockOption<T>) {
        visit_mut_rec_block_option(self, node)
    }
    fn visit_mut_rec_block_option_name(&mut self, node: &'ast MutRecBlockOptionName) {
        visit_mut_rec_block_option_name(self, node)
    }
    fn visit_my_sql_config_option(&mut self, node: &'ast MySqlConfigOption<T>) {
        visit_my_sql_config_option(self, node)
    }
    fn visit_my_sql_config_option_name(&mut self, node: &'ast MySqlConfigOptionName) {
        visit_my_sql_config_option_name(self, node)
    }
    fn visit_named_plan(&mut self, node: &'ast NamedPlan) {
        visit_named_plan(self, node)
    }
    fn visit_notice_severity(&mut self, node: &'ast NoticeSeverity) {
        visit_notice_severity(self, node)
    }
    fn visit_object_type(&mut self, node: &'ast ObjectType) {
        visit_object_type(self, node)
    }
    fn visit_op(&mut self, node: &'ast Op) {
        visit_op(self, node)
    }
    fn visit_order_by_expr(&mut self, node: &'ast OrderByExpr<T>) {
        visit_order_by_expr(self, node)
    }
    fn visit_pg_config_option(&mut self, node: &'ast PgConfigOption<T>) {
        visit_pg_config_option(self, node)
    }
    fn visit_pg_config_option_name(&mut self, node: &'ast PgConfigOptionName) {
        visit_pg_config_option_name(self, node)
    }
    fn visit_prepare_statement(&mut self, node: &'ast PrepareStatement<T>) {
        visit_prepare_statement(self, node)
    }
    fn visit_privilege(&mut self, node: &'ast Privilege) {
        visit_privilege(self, node)
    }
    fn visit_privilege_specification(&mut self, node: &'ast PrivilegeSpecification) {
        visit_privilege_specification(self, node)
    }
    fn visit_protobuf_schema(&mut self, node: &'ast ProtobufSchema<T>) {
        visit_protobuf_schema(self, node)
    }
    fn visit_qualified_replica(&mut self, node: &'ast QualifiedReplica) {
        visit_qualified_replica(self, node)
    }
    fn visit_query(&mut self, node: &'ast Query<T>) {
        visit_query(self, node)
    }
    fn visit_raise_statement(&mut self, node: &'ast RaiseStatement) {
        visit_raise_statement(self, node)
    }
    fn visit_reader_schema_selection_strategy(&mut self, node: &'ast ReaderSchemaSelectionStrategy) {
        visit_reader_schema_selection_strategy(self, node)
    }
    fn visit_reassign_owned_statement(&mut self, node: &'ast ReassignOwnedStatement<T>) {
        visit_reassign_owned_statement(self, node)
    }
    fn visit_refresh_at_option_value(&mut self, node: &'ast RefreshAtOptionValue<T>) {
        visit_refresh_at_option_value(self, node)
    }
    fn visit_refresh_every_option_value(&mut self, node: &'ast RefreshEveryOptionValue<T>) {
        visit_refresh_every_option_value(self, node)
    }
    fn visit_refresh_option_value(&mut self, node: &'ast RefreshOptionValue<T>) {
        visit_refresh_option_value(self, node)
    }
    fn visit_replica_definition(&mut self, node: &'ast ReplicaDefinition<T>) {
        visit_replica_definition(self, node)
    }
    fn visit_replica_option(&mut self, node: &'ast ReplicaOption<T>) {
        visit_replica_option(self, node)
    }
    fn visit_replica_option_name(&mut self, node: &'ast ReplicaOptionName) {
        visit_replica_option_name(self, node)
    }
    fn visit_reset_variable_statement(&mut self, node: &'ast ResetVariableStatement) {
        visit_reset_variable_statement(self, node)
    }
    fn visit_revoke_privileges_statement(&mut self, node: &'ast RevokePrivilegesStatement<T>) {
        visit_revoke_privileges_statement(self, node)
    }
    fn visit_revoke_role_statement(&mut self, node: &'ast RevokeRoleStatement<T>) {
        visit_revoke_role_statement(self, node)
    }
    fn visit_role_attribute(&mut self, node: &'ast RoleAttribute) {
        visit_role_attribute(self, node)
    }
    fn visit_rollback_statement(&mut self, node: &'ast RollbackStatement) {
        visit_rollback_statement(self, node)
    }
    fn visit_schema(&mut self, node: &'ast Schema) {
        visit_schema(self, node)
    }
    fn visit_select(&mut self, node: &'ast Select<T>) {
        visit_select(self, node)
    }
    fn visit_select_item(&mut self, node: &'ast SelectItem<T>) {
        visit_select_item(self, node)
    }
    fn visit_select_option(&mut self, node: &'ast SelectOption<T>) {
        visit_select_option(self, node)
    }
    fn visit_select_option_name(&mut self, node: &'ast SelectOptionName) {
        visit_select_option_name(self, node)
    }
    fn visit_select_statement(&mut self, node: &'ast SelectStatement<T>) {
        visit_select_statement(self, node)
    }
    fn visit_set_expr(&mut self, node: &'ast SetExpr<T>) {
        visit_set_expr(self, node)
    }
    fn visit_set_operator(&mut self, node: &'ast SetOperator) {
        visit_set_operator(self, node)
    }
    fn visit_set_role_var(&mut self, node: &'ast SetRoleVar) {
        visit_set_role_var(self, node)
    }
    fn visit_set_transaction_statement(&mut self, node: &'ast SetTransactionStatement) {
        visit_set_transaction_statement(self, node)
    }
    fn visit_set_variable_statement(&mut self, node: &'ast SetVariableStatement) {
        visit_set_variable_statement(self, node)
    }
    fn visit_set_variable_to(&mut self, node: &'ast SetVariableTo) {
        visit_set_variable_to(self, node)
    }
    fn visit_set_variable_value(&mut self, node: &'ast SetVariableValue) {
        visit_set_variable_value(self, node)
    }
    fn visit_show_columns_statement(&mut self, node: &'ast ShowColumnsStatement<T>) {
        visit_show_columns_statement(self, node)
    }
    fn visit_show_create_cluster_statement(&mut self, node: &'ast ShowCreateClusterStatement<T>) {
        visit_show_create_cluster_statement(self, node)
    }
    fn visit_show_create_connection_statement(&mut self, node: &'ast ShowCreateConnectionStatement<T>) {
        visit_show_create_connection_statement(self, node)
    }
    fn visit_show_create_index_statement(&mut self, node: &'ast ShowCreateIndexStatement<T>) {
        visit_show_create_index_statement(self, node)
    }
    fn visit_show_create_materialized_view_statement(&mut self, node: &'ast ShowCreateMaterializedViewStatement<T>) {
        visit_show_create_materialized_view_statement(self, node)
    }
    fn visit_show_create_sink_statement(&mut self, node: &'ast ShowCreateSinkStatement<T>) {
        visit_show_create_sink_statement(self, node)
    }
    fn visit_show_create_source_statement(&mut self, node: &'ast ShowCreateSourceStatement<T>) {
        visit_show_create_source_statement(self, node)
    }
    fn visit_show_create_table_statement(&mut self, node: &'ast ShowCreateTableStatement<T>) {
        visit_show_create_table_statement(self, node)
    }
    fn visit_show_create_view_statement(&mut self, node: &'ast ShowCreateViewStatement<T>) {
        visit_show_create_view_statement(self, node)
    }
    fn visit_show_object_type(&mut self, node: &'ast ShowObjectType<T>) {
        visit_show_object_type(self, node)
    }
    fn visit_show_objects_statement(&mut self, node: &'ast ShowObjectsStatement<T>) {
        visit_show_objects_statement(self, node)
    }
    fn visit_show_statement(&mut self, node: &'ast ShowStatement<T>) {
        visit_show_statement(self, node)
    }
    fn visit_show_statement_filter(&mut self, node: &'ast ShowStatementFilter<T>) {
        visit_show_statement_filter(self, node)
    }
    fn visit_show_variable_statement(&mut self, node: &'ast ShowVariableStatement) {
        visit_show_variable_statement(self, node)
    }
    fn visit_sink_envelope(&mut self, node: &'ast SinkEnvelope) {
        visit_sink_envelope(self, node)
    }
    fn visit_source_envelope(&mut self, node: &'ast SourceEnvelope) {
        visit_source_envelope(self, node)
    }
    fn visit_source_error_policy(&mut self, node: &'ast SourceErrorPolicy) {
        visit_source_error_policy(self, node)
    }
    fn visit_source_include_metadata(&mut self, node: &'ast SourceIncludeMetadata) {
        visit_source_include_metadata(self, node)
    }
    fn visit_start_transaction_statement(&mut self, node: &'ast StartTransactionStatement) {
        visit_start_transaction_statement(self, node)
    }
    fn visit_statement(&mut self, node: &'ast Statement<T>) {
        visit_statement(self, node)
    }
    fn visit_subscribe_option(&mut self, node: &'ast SubscribeOption<T>) {
        visit_subscribe_option(self, node)
    }
    fn visit_subscribe_option_name(&mut self, node: &'ast SubscribeOptionName) {
        visit_subscribe_option_name(self, node)
    }
    fn visit_subscribe_output(&mut self, node: &'ast SubscribeOutput<T>) {
        visit_subscribe_output(self, node)
    }
    fn visit_subscribe_relation(&mut self, node: &'ast SubscribeRelation<T>) {
        visit_subscribe_relation(self, node)
    }
    fn visit_subscribe_statement(&mut self, node: &'ast SubscribeStatement<T>) {
        visit_subscribe_statement(self, node)
    }
    fn visit_subscript_position(&mut self, node: &'ast SubscriptPosition<T>) {
        visit_subscript_position(self, node)
    }
    fn visit_system_object_type(&mut self, node: &'ast SystemObjectType) {
        visit_system_object_type(self, node)
    }
    fn visit_cluster_name(&mut self, node: &'ast T::ClusterName) {
        visit_cluster_name(self, node)
    }
    fn visit_column_reference(&mut self, node: &'ast T::ColumnReference) {
        visit_column_reference(self, node)
    }
    fn visit_cte_id(&mut self, node: &'ast T::CteId) {
        visit_cte_id(self, node)
    }
    fn visit_data_type(&mut self, node: &'ast T::DataType) {
        visit_data_type(self, node)
    }
    fn visit_database_name(&mut self, node: &'ast T::DatabaseName) {
        visit_database_name(self, node)
    }
    fn visit_item_name(&mut self, node: &'ast T::ItemName) {
        visit_item_name(self, node)
    }
    fn visit_nested_statement(&mut self, node: &'ast T::NestedStatement) {
        visit_nested_statement(self, node)
    }
    fn visit_object_name(&mut self, node: &'ast T::ObjectName) {
        visit_object_name(self, node)
    }
    fn visit_role_name(&mut self, node: &'ast T::RoleName) {
        visit_role_name(self, node)
    }
    fn visit_schema_name(&mut self, node: &'ast T::SchemaName) {
        visit_schema_name(self, node)
    }
    fn visit_table_alias(&mut self, node: &'ast TableAlias) {
        visit_table_alias(self, node)
    }
    fn visit_table_constraint(&mut self, node: &'ast TableConstraint<T>) {
        visit_table_constraint(self, node)
    }
    fn visit_table_factor(&mut self, node: &'ast TableFactor<T>) {
        visit_table_factor(self, node)
    }
    fn visit_table_option(&mut self, node: &'ast TableOption<T>) {
        visit_table_option(self, node)
    }
    fn visit_table_option_name(&mut self, node: &'ast TableOptionName) {
        visit_table_option_name(self, node)
    }
    fn visit_table_with_joins(&mut self, node: &'ast TableWithJoins<T>) {
        visit_table_with_joins(self, node)
    }
    fn visit_target_role_specification(&mut self, node: &'ast TargetRoleSpecification<T>) {
        visit_target_role_specification(self, node)
    }
    fn visit_transaction_access_mode(&mut self, node: &'ast TransactionAccessMode) {
        visit_transaction_access_mode(self, node)
    }
    fn visit_transaction_isolation_level(&mut self, node: &'ast TransactionIsolationLevel) {
        visit_transaction_isolation_level(self, node)
    }
    fn visit_transaction_mode(&mut self, node: &'ast TransactionMode) {
        visit_transaction_mode(self, node)
    }
    fn visit_unresolved_database_name(&mut self, node: &'ast UnresolvedDatabaseName) {
        visit_unresolved_database_name(self, node)
    }
    fn visit_unresolved_item_name(&mut self, node: &'ast UnresolvedItemName) {
        visit_unresolved_item_name(self, node)
    }
    fn visit_unresolved_object_name(&mut self, node: &'ast UnresolvedObjectName) {
        visit_unresolved_object_name(self, node)
    }
    fn visit_unresolved_schema_name(&mut self, node: &'ast UnresolvedSchemaName) {
        visit_unresolved_schema_name(self, node)
    }
    fn visit_update_statement(&mut self, node: &'ast UpdateStatement<T>) {
        visit_update_statement(self, node)
    }
    fn visit_validate_connection_statement(&mut self, node: &'ast ValidateConnectionStatement<T>) {
        visit_validate_connection_statement(self, node)
    }
    fn visit_value(&mut self, node: &'ast Value) {
        visit_value(self, node)
    }
    fn visit_value_error(&mut self, node: &'ast ValueError) {
        visit_value_error(self, node)
    }
    fn visit_values(&mut self, node: &'ast Values<T>) {
        visit_values(self, node)
    }
    fn visit_view_definition(&mut self, node: &'ast ViewDefinition<T>) {
        visit_view_definition(self, node)
    }
    fn visit_window_frame(&mut self, node: &'ast WindowFrame) {
        visit_window_frame(self, node)
    }
    fn visit_window_frame_bound(&mut self, node: &'ast WindowFrameBound) {
        visit_window_frame_bound(self, node)
    }
    fn visit_window_frame_units(&mut self, node: &'ast WindowFrameUnits) {
        visit_window_frame_units(self, node)
    }
    fn visit_window_spec(&mut self, node: &'ast WindowSpec<T>) {
        visit_window_spec(self, node)
    }
    fn visit_with_option_value(&mut self, node: &'ast WithOptionValue<T>) {
        visit_with_option_value(self, node)
    }
}
pub trait VisitNode<'ast, T: AstInfo, > {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V);
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for AbbreviatedGrantOrRevokeStatement<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_abbreviated_grant_or_revoke_statement(self)
    }
}
pub fn visit_abbreviated_grant_or_revoke_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast AbbreviatedGrantOrRevokeStatement<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        AbbreviatedGrantOrRevokeStatement::Grant {
            0: binding0,
        } => {
            visitor.visit_abbreviated_grant_statement(binding0);
        }
        AbbreviatedGrantOrRevokeStatement::Revoke {
            0: binding0,
        } => {
            visitor.visit_abbreviated_revoke_statement(binding0);
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for AbbreviatedGrantStatement<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_abbreviated_grant_statement(self)
    }
}
pub fn visit_abbreviated_grant_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast AbbreviatedGrantStatement<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_privilege_specification(&node.privileges);
    visitor.visit_object_type(&node.object_type);
    for v in &node.grantees {
        visitor.visit_role_name(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for AbbreviatedRevokeStatement<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_abbreviated_revoke_statement(self)
    }
}
pub fn visit_abbreviated_revoke_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast AbbreviatedRevokeStatement<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_privilege_specification(&node.privileges);
    visitor.visit_object_type(&node.object_type);
    for v in &node.revokees {
        visitor.visit_role_name(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for AlterClusterAction<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_alter_cluster_action(self)
    }
}
pub fn visit_alter_cluster_action<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast AlterClusterAction<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        AlterClusterAction::SetOptions {
            options: binding0,
            with_options: binding1,
        } => {
            for v in binding0 {
                visitor.visit_cluster_option(v);
            }
            for v in binding1 {
                visitor.visit_cluster_alter_option(v);
            }
        }
        AlterClusterAction::ResetOptions {
            0: binding0,
        } => {
            for v in binding0 {
                visitor.visit_cluster_option_name(v);
            }
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for AlterClusterStatement<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_alter_cluster_statement(self)
    }
}
pub fn visit_alter_cluster_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast AlterClusterStatement<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_ident(&node.name);
    visitor.visit_alter_cluster_action(&node.action);
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for AlterConnectionAction<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_alter_connection_action(self)
    }
}
pub fn visit_alter_connection_action<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast AlterConnectionAction<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        AlterConnectionAction::RotateKeys {
        } => {
        }
        AlterConnectionAction::SetOption {
            0: binding0,
        } => {
            visitor.visit_connection_option(binding0);
        }
        AlterConnectionAction::DropOption {
            0: binding0,
        } => {
            visitor.visit_connection_option_name(binding0);
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for AlterConnectionOption<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_alter_connection_option(self)
    }
}
pub fn visit_alter_connection_option<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast AlterConnectionOption<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_alter_connection_option_name(&node.name);
    if let Some(v) = &node.value {
        visitor.visit_with_option_value(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for AlterConnectionOptionName {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_alter_connection_option_name(self)
    }
}
pub fn visit_alter_connection_option_name<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast AlterConnectionOptionName)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        AlterConnectionOptionName::Validate {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for AlterConnectionStatement<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_alter_connection_statement(self)
    }
}
pub fn visit_alter_connection_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast AlterConnectionStatement<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_unresolved_item_name(&node.name);
    for v in &node.actions {
        visitor.visit_alter_connection_action(v);
    }
    for v in &node.with_options {
        visitor.visit_alter_connection_option(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for AlterDefaultPrivilegesStatement<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_alter_default_privileges_statement(self)
    }
}
pub fn visit_alter_default_privileges_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast AlterDefaultPrivilegesStatement<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_target_role_specification(&node.target_roles);
    visitor.visit_grant_target_all_specification(&node.target_objects);
    visitor.visit_abbreviated_grant_or_revoke_statement(&node.grant_or_revoke);
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for AlterIndexAction<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_alter_index_action(self)
    }
}
pub fn visit_alter_index_action<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast AlterIndexAction<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        AlterIndexAction::SetOptions {
            0: binding0,
        } => {
            for v in binding0 {
                visitor.visit_index_option(v);
            }
        }
        AlterIndexAction::ResetOptions {
            0: binding0,
        } => {
            for v in binding0 {
                visitor.visit_index_option_name(v);
            }
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for AlterIndexStatement<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_alter_index_statement(self)
    }
}
pub fn visit_alter_index_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast AlterIndexStatement<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_unresolved_item_name(&node.index_name);
    visitor.visit_alter_index_action(&node.action);
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for AlterObjectRenameStatement {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_alter_object_rename_statement(self)
    }
}
pub fn visit_alter_object_rename_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast AlterObjectRenameStatement)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_object_type(&node.object_type);
    visitor.visit_unresolved_object_name(&node.name);
    visitor.visit_ident(&node.to_item_name);
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for AlterObjectSwapStatement {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_alter_object_swap_statement(self)
    }
}
pub fn visit_alter_object_swap_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast AlterObjectSwapStatement)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_object_type(&node.object_type);
    visitor.visit_unresolved_object_name(&node.name_a);
    visitor.visit_ident(&node.name_b);
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for AlterOwnerStatement<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_alter_owner_statement(self)
    }
}
pub fn visit_alter_owner_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast AlterOwnerStatement<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_object_type(&node.object_type);
    visitor.visit_unresolved_object_name(&node.name);
    visitor.visit_role_name(&node.new_owner);
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for AlterRetainHistoryStatement<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_alter_retain_history_statement(self)
    }
}
pub fn visit_alter_retain_history_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast AlterRetainHistoryStatement<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_object_type(&node.object_type);
    visitor.visit_unresolved_object_name(&node.name);
    if let Some(v) = &node.history {
        visitor.visit_with_option_value(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for AlterRoleOption {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_alter_role_option(self)
    }
}
pub fn visit_alter_role_option<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast AlterRoleOption)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        AlterRoleOption::Attributes {
            0: binding0,
        } => {
            for v in binding0 {
                visitor.visit_role_attribute(v);
            }
        }
        AlterRoleOption::Variable {
            0: binding0,
        } => {
            visitor.visit_set_role_var(binding0);
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for AlterRoleStatement<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_alter_role_statement(self)
    }
}
pub fn visit_alter_role_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast AlterRoleStatement<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_role_name(&node.name);
    visitor.visit_alter_role_option(&node.option);
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for AlterSecretStatement<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_alter_secret_statement(self)
    }
}
pub fn visit_alter_secret_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast AlterSecretStatement<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_unresolved_item_name(&node.name);
    visitor.visit_expr(&node.value);
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for AlterSetClusterStatement<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_alter_set_cluster_statement(self)
    }
}
pub fn visit_alter_set_cluster_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast AlterSetClusterStatement<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_unresolved_item_name(&node.name);
    visitor.visit_object_type(&node.object_type);
    visitor.visit_cluster_name(&node.set_cluster);
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for AlterSinkAction<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_alter_sink_action(self)
    }
}
pub fn visit_alter_sink_action<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast AlterSinkAction<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        AlterSinkAction::SetOptions {
            0: binding0,
        } => {
            for v in binding0 {
                visitor.visit_create_sink_option(v);
            }
        }
        AlterSinkAction::ResetOptions {
            0: binding0,
        } => {
            for v in binding0 {
                visitor.visit_create_sink_option_name(v);
            }
        }
        AlterSinkAction::ChangeRelation {
            0: binding0,
        } => {
            visitor.visit_item_name(binding0);
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for AlterSinkStatement<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_alter_sink_statement(self)
    }
}
pub fn visit_alter_sink_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast AlterSinkStatement<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_unresolved_item_name(&node.sink_name);
    visitor.visit_alter_sink_action(&node.action);
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for AlterSourceAction<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_alter_source_action(self)
    }
}
pub fn visit_alter_source_action<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast AlterSourceAction<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        AlterSourceAction::SetOptions {
            0: binding0,
        } => {
            for v in binding0 {
                visitor.visit_create_source_option(v);
            }
        }
        AlterSourceAction::ResetOptions {
            0: binding0,
        } => {
            for v in binding0 {
                visitor.visit_create_source_option_name(v);
            }
        }
        AlterSourceAction::AddSubsources {
            external_references: binding0,
            options: binding1,
        } => {
            for v in binding0 {
                visitor.visit_external_reference_export(v);
            }
            for v in binding1 {
                visitor.visit_alter_source_add_subsource_option(v);
            }
        }
        AlterSourceAction::DropSubsources {
            if_exists: binding0,
            cascade: binding1,
            names: binding2,
        } => {
            for v in binding2 {
                visitor.visit_unresolved_item_name(v);
            }
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for AlterSourceAddSubsourceOption<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_alter_source_add_subsource_option(self)
    }
}
pub fn visit_alter_source_add_subsource_option<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast AlterSourceAddSubsourceOption<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_alter_source_add_subsource_option_name(&node.name);
    if let Some(v) = &node.value {
        visitor.visit_with_option_value(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for AlterSourceAddSubsourceOptionName {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_alter_source_add_subsource_option_name(self)
    }
}
pub fn visit_alter_source_add_subsource_option_name<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast AlterSourceAddSubsourceOptionName)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        AlterSourceAddSubsourceOptionName::TextColumns {
        } => {
        }
        AlterSourceAddSubsourceOptionName::IgnoreColumns {
        } => {
        }
        AlterSourceAddSubsourceOptionName::Details {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for AlterSourceStatement<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_alter_source_statement(self)
    }
}
pub fn visit_alter_source_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast AlterSourceStatement<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_unresolved_item_name(&node.source_name);
    visitor.visit_alter_source_action(&node.action);
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for AlterSystemResetAllStatement {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_alter_system_reset_all_statement(self)
    }
}
pub fn visit_alter_system_reset_all_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast AlterSystemResetAllStatement)
where
    V: Visit<'ast, T, > + ?Sized,
{
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for AlterSystemResetStatement {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_alter_system_reset_statement(self)
    }
}
pub fn visit_alter_system_reset_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast AlterSystemResetStatement)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_ident(&node.name);
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for AlterSystemSetStatement {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_alter_system_set_statement(self)
    }
}
pub fn visit_alter_system_set_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast AlterSystemSetStatement)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_ident(&node.name);
    visitor.visit_set_variable_to(&node.to);
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for AlterTableAddColumnStatement<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_alter_table_add_column_statement(self)
    }
}
pub fn visit_alter_table_add_column_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast AlterTableAddColumnStatement<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_unresolved_item_name(&node.name);
    visitor.visit_ident(&node.column_name);
    visitor.visit_data_type(&node.data_type);
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for AsOf<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_as_of(self)
    }
}
pub fn visit_as_of<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast AsOf<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        AsOf::At {
            0: binding0,
        } => {
            visitor.visit_expr(binding0);
        }
        AsOf::AtLeast {
            0: binding0,
        } => {
            visitor.visit_expr(binding0);
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for Assignment<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_assignment(self)
    }
}
pub fn visit_assignment<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast Assignment<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_ident(&node.id);
    visitor.visit_expr(&node.value);
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for AvroDocOn<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_avro_doc_on(self)
    }
}
pub fn visit_avro_doc_on<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast AvroDocOn<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_doc_on_identifier(&node.identifier);
    visitor.visit_doc_on_schema(&node.for_schema);
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for AvroSchema<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_avro_schema(self)
    }
}
pub fn visit_avro_schema<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast AvroSchema<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        AvroSchema::Csr {
            csr_connection: binding0,
        } => {
            visitor.visit_csr_connection_avro(binding0);
        }
        AvroSchema::InlineSchema {
            schema: binding0,
            with_options: binding1,
        } => {
            visitor.visit_schema(binding0);
            for v in binding1 {
                visitor.visit_avro_schema_option(v);
            }
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for AvroSchemaOption<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_avro_schema_option(self)
    }
}
pub fn visit_avro_schema_option<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast AvroSchemaOption<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_avro_schema_option_name(&node.name);
    if let Some(v) = &node.value {
        visitor.visit_with_option_value(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for AvroSchemaOptionName {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_avro_schema_option_name(self)
    }
}
pub fn visit_avro_schema_option_name<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast AvroSchemaOptionName)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        AvroSchemaOptionName::ConfluentWireFormat {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for CatalogName {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_catalog_name(self)
    }
}
pub fn visit_catalog_name<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast CatalogName)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        CatalogName::ItemName {
            0: binding0,
        } => {
            for v in binding0 {
                visitor.visit_ident(v);
            }
        }
        CatalogName::FuncName {
            0: binding0,
        } => {
            for v in binding0 {
                visitor.visit_ident(v);
            }
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for CloseStatement {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_close_statement(self)
    }
}
pub fn visit_close_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast CloseStatement)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_ident(&node.name);
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for ClusterAlterOption<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_cluster_alter_option(self)
    }
}
pub fn visit_cluster_alter_option<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast ClusterAlterOption<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_cluster_alter_option_name(&node.name);
    if let Some(v) = &node.value {
        visitor.visit_with_option_value(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for ClusterAlterOptionName {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_cluster_alter_option_name(self)
    }
}
pub fn visit_cluster_alter_option_name<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast ClusterAlterOptionName)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        ClusterAlterOptionName::Wait {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for ClusterAlterOptionValue {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_cluster_alter_option_value(self)
    }
}
pub fn visit_cluster_alter_option_value<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast ClusterAlterOptionValue)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        ClusterAlterOptionValue::For {
            0: binding0,
        } => {
            visitor.visit_value(binding0);
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for ClusterFeature<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_cluster_feature(self)
    }
}
pub fn visit_cluster_feature<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast ClusterFeature<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_cluster_feature_name(&node.name);
    if let Some(v) = &node.value {
        visitor.visit_with_option_value(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for ClusterFeatureName {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_cluster_feature_name(self)
    }
}
pub fn visit_cluster_feature_name<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast ClusterFeatureName)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        ClusterFeatureName::ReoptimizeImportedViews {
        } => {
        }
        ClusterFeatureName::EnableNewOuterJoinLowering {
        } => {
        }
        ClusterFeatureName::EnableEagerDeltaJoins {
        } => {
        }
        ClusterFeatureName::EnableVariadicLeftJoinLowering {
        } => {
        }
        ClusterFeatureName::EnableLetrecFixpointAnalysis {
        } => {
        }
        ClusterFeatureName::EnableOuterJoinNullFilter {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for ClusterOption<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_cluster_option(self)
    }
}
pub fn visit_cluster_option<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast ClusterOption<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_cluster_option_name(&node.name);
    if let Some(v) = &node.value {
        visitor.visit_with_option_value(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for ClusterOptionName {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_cluster_option_name(self)
    }
}
pub fn visit_cluster_option_name<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast ClusterOptionName)
where
    V: Visit<'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, > VisitNode<'ast, T, > for ClusterScheduleOptionValue {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_cluster_schedule_option_value(self)
    }
}
pub fn visit_cluster_schedule_option_value<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast ClusterScheduleOptionValue)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        ClusterScheduleOptionValue::Manual {
        } => {
        }
        ClusterScheduleOptionValue::Refresh {
            hydration_time_estimate: binding0,
        } => {
            if let Some(v) = binding0 {
                visitor.visit_interval_value(v);
            }
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for ColumnDef<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_column_def(self)
    }
}
pub fn visit_column_def<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast ColumnDef<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_ident(&node.name);
    visitor.visit_data_type(&node.data_type);
    if let Some(v) = &node.collation {
        visitor.visit_unresolved_item_name(v);
    }
    for v in &node.options {
        visitor.visit_column_option_def(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for ColumnName<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_column_name(self)
    }
}
pub fn visit_column_name<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast ColumnName<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_item_name(&node.relation);
    visitor.visit_column_reference(&node.column);
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for ColumnOption<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_column_option(self)
    }
}
pub fn visit_column_option<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast ColumnOption<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        ColumnOption::Null {
        } => {
        }
        ColumnOption::NotNull {
        } => {
        }
        ColumnOption::Default {
            0: binding0,
        } => {
            visitor.visit_expr(binding0);
        }
        ColumnOption::Unique {
            is_primary: binding0,
        } => {
        }
        ColumnOption::ForeignKey {
            foreign_table: binding0,
            referred_columns: binding1,
        } => {
            visitor.visit_unresolved_item_name(binding0);
            for v in binding1 {
                visitor.visit_ident(v);
            }
        }
        ColumnOption::Check {
            0: binding0,
        } => {
            visitor.visit_expr(binding0);
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for ColumnOptionDef<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_column_option_def(self)
    }
}
pub fn visit_column_option_def<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast ColumnOptionDef<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    if let Some(v) = &node.name {
        visitor.visit_ident(v);
    }
    visitor.visit_column_option(&node.option);
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for CommentObjectType<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_comment_object_type(self)
    }
}
pub fn visit_comment_object_type<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast CommentObjectType<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        CommentObjectType::Table {
            name: binding0,
        } => {
            visitor.visit_item_name(binding0);
        }
        CommentObjectType::View {
            name: binding0,
        } => {
            visitor.visit_item_name(binding0);
        }
        CommentObjectType::Column {
            name: binding0,
        } => {
            visitor.visit_column_name(binding0);
        }
        CommentObjectType::MaterializedView {
            name: binding0,
        } => {
            visitor.visit_item_name(binding0);
        }
        CommentObjectType::Source {
            name: binding0,
        } => {
            visitor.visit_item_name(binding0);
        }
        CommentObjectType::Sink {
            name: binding0,
        } => {
            visitor.visit_item_name(binding0);
        }
        CommentObjectType::Index {
            name: binding0,
        } => {
            visitor.visit_item_name(binding0);
        }
        CommentObjectType::Func {
            name: binding0,
        } => {
            visitor.visit_item_name(binding0);
        }
        CommentObjectType::Connection {
            name: binding0,
        } => {
            visitor.visit_item_name(binding0);
        }
        CommentObjectType::Type {
            ty: binding0,
        } => {
            visitor.visit_data_type(binding0);
        }
        CommentObjectType::Secret {
            name: binding0,
        } => {
            visitor.visit_item_name(binding0);
        }
        CommentObjectType::Role {
            name: binding0,
        } => {
            visitor.visit_role_name(binding0);
        }
        CommentObjectType::Database {
            name: binding0,
        } => {
            visitor.visit_database_name(binding0);
        }
        CommentObjectType::Schema {
            name: binding0,
        } => {
            visitor.visit_schema_name(binding0);
        }
        CommentObjectType::Cluster {
            name: binding0,
        } => {
            visitor.visit_cluster_name(binding0);
        }
        CommentObjectType::ClusterReplica {
            name: binding0,
        } => {
            visitor.visit_qualified_replica(binding0);
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for CommentStatement<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_comment_statement(self)
    }
}
pub fn visit_comment_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast CommentStatement<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_comment_object_type(&node.object);
    if let Some(v) = &node.comment {
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for CommitStatement {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_commit_statement(self)
    }
}
pub fn visit_commit_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast CommitStatement)
where
    V: Visit<'ast, T, > + ?Sized,
{
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for ConnectionDefaultAwsPrivatelink<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_connection_default_aws_privatelink(self)
    }
}
pub fn visit_connection_default_aws_privatelink<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast ConnectionDefaultAwsPrivatelink<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_item_name(&node.connection);
    if let Some(v) = &node.port {
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for ConnectionOption<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_connection_option(self)
    }
}
pub fn visit_connection_option<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast ConnectionOption<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_connection_option_name(&node.name);
    if let Some(v) = &node.value {
        visitor.visit_with_option_value(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for ConnectionOptionName {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_connection_option_name(self)
    }
}
pub fn visit_connection_option_name<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast ConnectionOptionName)
where
    V: Visit<'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::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, > VisitNode<'ast, T, > for CopyDirection {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_copy_direction(self)
    }
}
pub fn visit_copy_direction<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast CopyDirection)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        CopyDirection::To {
        } => {
        }
        CopyDirection::From {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for CopyOption<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_copy_option(self)
    }
}
pub fn visit_copy_option<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast CopyOption<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_copy_option_name(&node.name);
    if let Some(v) = &node.value {
        visitor.visit_with_option_value(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for CopyOptionName {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_copy_option_name(self)
    }
}
pub fn visit_copy_option_name<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast CopyOptionName)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        CopyOptionName::Format {
        } => {
        }
        CopyOptionName::Delimiter {
        } => {
        }
        CopyOptionName::Null {
        } => {
        }
        CopyOptionName::Escape {
        } => {
        }
        CopyOptionName::Quote {
        } => {
        }
        CopyOptionName::Header {
        } => {
        }
        CopyOptionName::AwsConnection {
        } => {
        }
        CopyOptionName::MaxFileSize {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for CopyRelation<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_copy_relation(self)
    }
}
pub fn visit_copy_relation<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast CopyRelation<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        CopyRelation::Named {
            name: binding0,
            columns: binding1,
        } => {
            visitor.visit_item_name(binding0);
            for v in binding1 {
                visitor.visit_ident(v);
            }
        }
        CopyRelation::Select {
            0: binding0,
        } => {
            visitor.visit_select_statement(binding0);
        }
        CopyRelation::Subscribe {
            0: binding0,
        } => {
            visitor.visit_subscribe_statement(binding0);
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for CopyStatement<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_copy_statement(self)
    }
}
pub fn visit_copy_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast CopyStatement<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_copy_relation(&node.relation);
    visitor.visit_copy_direction(&node.direction);
    visitor.visit_copy_target(&node.target);
    for v in &node.options {
        visitor.visit_copy_option(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for CopyTarget<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_copy_target(self)
    }
}
pub fn visit_copy_target<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast CopyTarget<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        CopyTarget::Stdin {
        } => {
        }
        CopyTarget::Stdout {
        } => {
        }
        CopyTarget::Expr {
            0: binding0,
        } => {
            visitor.visit_expr(binding0);
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for CreateClusterReplicaStatement<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_create_cluster_replica_statement(self)
    }
}
pub fn visit_create_cluster_replica_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast CreateClusterReplicaStatement<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_ident(&node.of_cluster);
    visitor.visit_replica_definition(&node.definition);
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for CreateClusterStatement<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_create_cluster_statement(self)
    }
}
pub fn visit_create_cluster_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast CreateClusterStatement<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_ident(&node.name);
    for v in &node.options {
        visitor.visit_cluster_option(v);
    }
    for v in &node.features {
        visitor.visit_cluster_feature(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for CreateConnectionOption<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_create_connection_option(self)
    }
}
pub fn visit_create_connection_option<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast CreateConnectionOption<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_create_connection_option_name(&node.name);
    if let Some(v) = &node.value {
        visitor.visit_with_option_value(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for CreateConnectionOptionName {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_create_connection_option_name(self)
    }
}
pub fn visit_create_connection_option_name<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast CreateConnectionOptionName)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        CreateConnectionOptionName::Validate {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for CreateConnectionStatement<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_create_connection_statement(self)
    }
}
pub fn visit_create_connection_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast CreateConnectionStatement<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_unresolved_item_name(&node.name);
    visitor.visit_create_connection_type(&node.connection_type);
    for v in &node.values {
        visitor.visit_connection_option(v);
    }
    for v in &node.with_options {
        visitor.visit_create_connection_option(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for CreateConnectionType {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_create_connection_type(self)
    }
}
pub fn visit_create_connection_type<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast CreateConnectionType)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        CreateConnectionType::Aws {
        } => {
        }
        CreateConnectionType::AwsPrivatelink {
        } => {
        }
        CreateConnectionType::Kafka {
        } => {
        }
        CreateConnectionType::Csr {
        } => {
        }
        CreateConnectionType::Postgres {
        } => {
        }
        CreateConnectionType::Ssh {
        } => {
        }
        CreateConnectionType::MySql {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for CreateDatabaseStatement {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_create_database_statement(self)
    }
}
pub fn visit_create_database_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast CreateDatabaseStatement)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_unresolved_database_name(&node.name);
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for CreateIndexStatement<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_create_index_statement(self)
    }
}
pub fn visit_create_index_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast CreateIndexStatement<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    if let Some(v) = &node.name {
        visitor.visit_ident(v);
    }
    if let Some(v) = &node.in_cluster {
        visitor.visit_cluster_name(v);
    }
    visitor.visit_item_name(&node.on_name);
    if let Some(v) = &node.key_parts {
        for v in v {
            visitor.visit_expr(v);
        }
    }
    for v in &node.with_options {
        visitor.visit_index_option(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for CreateMaterializedViewStatement<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_create_materialized_view_statement(self)
    }
}
pub fn visit_create_materialized_view_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast CreateMaterializedViewStatement<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_if_exists_behavior(&node.if_exists);
    visitor.visit_unresolved_item_name(&node.name);
    for v in &node.columns {
        visitor.visit_ident(v);
    }
    if let Some(v) = &node.in_cluster {
        visitor.visit_cluster_name(v);
    }
    visitor.visit_query(&node.query);
    if let Some(v) = &node.as_of {
    }
    for v in &node.with_options {
        visitor.visit_materialized_view_option(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for CreateRoleStatement {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_create_role_statement(self)
    }
}
pub fn visit_create_role_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast CreateRoleStatement)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_ident(&node.name);
    for v in &node.options {
        visitor.visit_role_attribute(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for CreateSchemaStatement {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_create_schema_statement(self)
    }
}
pub fn visit_create_schema_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast CreateSchemaStatement)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_unresolved_schema_name(&node.name);
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for CreateSecretStatement<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_create_secret_statement(self)
    }
}
pub fn visit_create_secret_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast CreateSecretStatement<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_unresolved_item_name(&node.name);
    visitor.visit_expr(&node.value);
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for CreateSinkConnection<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_create_sink_connection(self)
    }
}
pub fn visit_create_sink_connection<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast CreateSinkConnection<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        CreateSinkConnection::Kafka {
            connection: binding0,
            options: binding1,
            key: binding2,
            headers: binding3,
        } => {
            visitor.visit_item_name(binding0);
            for v in binding1 {
                visitor.visit_kafka_sink_config_option(v);
            }
            if let Some(v) = binding2 {
                visitor.visit_kafka_sink_key(v);
            }
            if let Some(v) = binding3 {
                visitor.visit_ident(v);
            }
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for CreateSinkOption<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_create_sink_option(self)
    }
}
pub fn visit_create_sink_option<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast CreateSinkOption<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_create_sink_option_name(&node.name);
    if let Some(v) = &node.value {
        visitor.visit_with_option_value(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for CreateSinkOptionName {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_create_sink_option_name(self)
    }
}
pub fn visit_create_sink_option_name<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast CreateSinkOptionName)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        CreateSinkOptionName::Snapshot {
        } => {
        }
        CreateSinkOptionName::Version {
        } => {
        }
        CreateSinkOptionName::PartitionStrategy {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for CreateSinkStatement<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_create_sink_statement(self)
    }
}
pub fn visit_create_sink_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast CreateSinkStatement<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    if let Some(v) = &node.name {
        visitor.visit_unresolved_item_name(v);
    }
    if let Some(v) = &node.in_cluster {
        visitor.visit_cluster_name(v);
    }
    visitor.visit_item_name(&node.from);
    visitor.visit_create_sink_connection(&node.connection);
    if let Some(v) = &node.format {
        visitor.visit_format_specifier(v);
    }
    if let Some(v) = &node.envelope {
        visitor.visit_sink_envelope(v);
    }
    for v in &node.with_options {
        visitor.visit_create_sink_option(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for CreateSourceConnection<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_create_source_connection(self)
    }
}
pub fn visit_create_source_connection<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast CreateSourceConnection<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        CreateSourceConnection::Kafka {
            connection: binding0,
            options: binding1,
        } => {
            visitor.visit_item_name(binding0);
            for v in binding1 {
                visitor.visit_kafka_source_config_option(v);
            }
        }
        CreateSourceConnection::Postgres {
            connection: binding0,
            options: binding1,
        } => {
            visitor.visit_item_name(binding0);
            for v in binding1 {
                visitor.visit_pg_config_option(v);
            }
        }
        CreateSourceConnection::MySql {
            connection: binding0,
            options: binding1,
        } => {
            visitor.visit_item_name(binding0);
            for v in binding1 {
                visitor.visit_my_sql_config_option(v);
            }
        }
        CreateSourceConnection::LoadGenerator {
            generator: binding0,
            options: binding1,
        } => {
            visitor.visit_load_generator(binding0);
            for v in binding1 {
                visitor.visit_load_generator_option(v);
            }
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for CreateSourceOption<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_create_source_option(self)
    }
}
pub fn visit_create_source_option<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast CreateSourceOption<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_create_source_option_name(&node.name);
    if let Some(v) = &node.value {
        visitor.visit_with_option_value(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for CreateSourceOptionName {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_create_source_option_name(self)
    }
}
pub fn visit_create_source_option_name<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast CreateSourceOptionName)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        CreateSourceOptionName::IgnoreKeys {
        } => {
        }
        CreateSourceOptionName::Timeline {
        } => {
        }
        CreateSourceOptionName::TimestampInterval {
        } => {
        }
        CreateSourceOptionName::RetainHistory {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for CreateSourceStatement<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_create_source_statement(self)
    }
}
pub fn visit_create_source_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast CreateSourceStatement<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_unresolved_item_name(&node.name);
    if let Some(v) = &node.in_cluster {
        visitor.visit_cluster_name(v);
    }
    for v in &node.col_names {
        visitor.visit_ident(v);
    }
    visitor.visit_create_source_connection(&node.connection);
    for v in &node.include_metadata {
        visitor.visit_source_include_metadata(v);
    }
    if let Some(v) = &node.format {
        visitor.visit_format_specifier(v);
    }
    if let Some(v) = &node.envelope {
        visitor.visit_source_envelope(v);
    }
    if let Some(v) = &node.key_constraint {
        visitor.visit_key_constraint(v);
    }
    for v in &node.with_options {
        visitor.visit_create_source_option(v);
    }
    if let Some(v) = &node.external_references {
        visitor.visit_external_references(v);
    }
    if let Some(v) = &node.progress_subsource {
        visitor.visit_deferred_item_name(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for CreateSubsourceOption<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_create_subsource_option(self)
    }
}
pub fn visit_create_subsource_option<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast CreateSubsourceOption<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_create_subsource_option_name(&node.name);
    if let Some(v) = &node.value {
        visitor.visit_with_option_value(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for CreateSubsourceOptionName {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_create_subsource_option_name(self)
    }
}
pub fn visit_create_subsource_option_name<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast CreateSubsourceOptionName)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        CreateSubsourceOptionName::Progress {
        } => {
        }
        CreateSubsourceOptionName::ExternalReference {
        } => {
        }
        CreateSubsourceOptionName::TextColumns {
        } => {
        }
        CreateSubsourceOptionName::IgnoreColumns {
        } => {
        }
        CreateSubsourceOptionName::Details {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for CreateSubsourceStatement<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_create_subsource_statement(self)
    }
}
pub fn visit_create_subsource_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast CreateSubsourceStatement<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_unresolved_item_name(&node.name);
    for v in &node.columns {
        visitor.visit_column_def(v);
    }
    if let Some(v) = &node.of_source {
        visitor.visit_item_name(v);
    }
    for v in &node.constraints {
        visitor.visit_table_constraint(v);
    }
    for v in &node.with_options {
        visitor.visit_create_subsource_option(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for CreateTableFromSourceStatement<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_create_table_from_source_statement(self)
    }
}
pub fn visit_create_table_from_source_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast CreateTableFromSourceStatement<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_unresolved_item_name(&node.name);
    for v in &node.columns {
        visitor.visit_ident(v);
    }
    visitor.visit_item_name(&node.source);
    visitor.visit_unresolved_item_name(&node.external_reference);
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for CreateTableStatement<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_create_table_statement(self)
    }
}
pub fn visit_create_table_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast CreateTableStatement<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_unresolved_item_name(&node.name);
    for v in &node.columns {
        visitor.visit_column_def(v);
    }
    for v in &node.constraints {
        visitor.visit_table_constraint(v);
    }
    for v in &node.with_options {
        visitor.visit_table_option(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for CreateTypeAs<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_create_type_as(self)
    }
}
pub fn visit_create_type_as<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast CreateTypeAs<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        CreateTypeAs::List {
            options: binding0,
        } => {
            for v in binding0 {
                visitor.visit_create_type_list_option(v);
            }
        }
        CreateTypeAs::Map {
            options: binding0,
        } => {
            for v in binding0 {
                visitor.visit_create_type_map_option(v);
            }
        }
        CreateTypeAs::Record {
            column_defs: binding0,
        } => {
            for v in binding0 {
                visitor.visit_column_def(v);
            }
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for CreateTypeListOption<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_create_type_list_option(self)
    }
}
pub fn visit_create_type_list_option<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast CreateTypeListOption<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_create_type_list_option_name(&node.name);
    if let Some(v) = &node.value {
        visitor.visit_with_option_value(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for CreateTypeListOptionName {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_create_type_list_option_name(self)
    }
}
pub fn visit_create_type_list_option_name<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast CreateTypeListOptionName)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        CreateTypeListOptionName::ElementType {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for CreateTypeMapOption<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_create_type_map_option(self)
    }
}
pub fn visit_create_type_map_option<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast CreateTypeMapOption<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_create_type_map_option_name(&node.name);
    if let Some(v) = &node.value {
        visitor.visit_with_option_value(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for CreateTypeMapOptionName {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_create_type_map_option_name(self)
    }
}
pub fn visit_create_type_map_option_name<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast CreateTypeMapOptionName)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        CreateTypeMapOptionName::KeyType {
        } => {
        }
        CreateTypeMapOptionName::ValueType {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for CreateTypeStatement<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_create_type_statement(self)
    }
}
pub fn visit_create_type_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast CreateTypeStatement<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_unresolved_item_name(&node.name);
    visitor.visit_create_type_as(&node.as_type);
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for CreateViewStatement<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_create_view_statement(self)
    }
}
pub fn visit_create_view_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast CreateViewStatement<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_if_exists_behavior(&node.if_exists);
    visitor.visit_view_definition(&node.definition);
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for CreateWebhookSourceBody {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_create_webhook_source_body(self)
    }
}
pub fn visit_create_webhook_source_body<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast CreateWebhookSourceBody)
where
    V: Visit<'ast, T, > + ?Sized,
{
    if let Some(v) = &node.alias {
        visitor.visit_ident(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for CreateWebhookSourceCheck<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_create_webhook_source_check(self)
    }
}
pub fn visit_create_webhook_source_check<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast CreateWebhookSourceCheck<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    if let Some(v) = &node.options {
        visitor.visit_create_webhook_source_check_options(v);
    }
    visitor.visit_expr(&node.using);
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for CreateWebhookSourceCheckOptions<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_create_webhook_source_check_options(self)
    }
}
pub fn visit_create_webhook_source_check_options<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast CreateWebhookSourceCheckOptions<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    for v in &node.secrets {
        visitor.visit_create_webhook_source_secret(v);
    }
    for v in &node.headers {
        visitor.visit_create_webhook_source_header(v);
    }
    for v in &node.bodies {
        visitor.visit_create_webhook_source_body(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for CreateWebhookSourceFilterHeader {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_create_webhook_source_filter_header(self)
    }
}
pub fn visit_create_webhook_source_filter_header<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast CreateWebhookSourceFilterHeader)
where
    V: Visit<'ast, T, > + ?Sized,
{
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for CreateWebhookSourceHeader {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_create_webhook_source_header(self)
    }
}
pub fn visit_create_webhook_source_header<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast CreateWebhookSourceHeader)
where
    V: Visit<'ast, T, > + ?Sized,
{
    if let Some(v) = &node.alias {
        visitor.visit_ident(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for CreateWebhookSourceIncludeHeaders {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_create_webhook_source_include_headers(self)
    }
}
pub fn visit_create_webhook_source_include_headers<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast CreateWebhookSourceIncludeHeaders)
where
    V: Visit<'ast, T, > + ?Sized,
{
    for v in &node.mappings {
        visitor.visit_create_webhook_source_map_header(v);
    }
    if let Some(v) = &node.column {
        for v in v {
            visitor.visit_create_webhook_source_filter_header(v);
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for CreateWebhookSourceMapHeader {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_create_webhook_source_map_header(self)
    }
}
pub fn visit_create_webhook_source_map_header<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast CreateWebhookSourceMapHeader)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_ident(&node.column_name);
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for CreateWebhookSourceSecret<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_create_webhook_source_secret(self)
    }
}
pub fn visit_create_webhook_source_secret<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast CreateWebhookSourceSecret<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_item_name(&node.secret);
    if let Some(v) = &node.alias {
        visitor.visit_ident(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for CreateWebhookSourceStatement<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_create_webhook_source_statement(self)
    }
}
pub fn visit_create_webhook_source_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast CreateWebhookSourceStatement<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_unresolved_item_name(&node.name);
    visitor.visit_format(&node.body_format);
    visitor.visit_create_webhook_source_include_headers(&node.include_headers);
    if let Some(v) = &node.validate_using {
        visitor.visit_create_webhook_source_check(v);
    }
    if let Some(v) = &node.in_cluster {
        visitor.visit_cluster_name(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for CsrConfigOption<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_csr_config_option(self)
    }
}
pub fn visit_csr_config_option<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast CsrConfigOption<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_csr_config_option_name(&node.name);
    if let Some(v) = &node.value {
        visitor.visit_with_option_value(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for CsrConfigOptionName<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_csr_config_option_name(self)
    }
}
pub fn visit_csr_config_option_name<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast CsrConfigOptionName<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        CsrConfigOptionName::AvroKeyFullname {
        } => {
        }
        CsrConfigOptionName::AvroValueFullname {
        } => {
        }
        CsrConfigOptionName::NullDefaults {
        } => {
        }
        CsrConfigOptionName::AvroDocOn {
            0: binding0,
        } => {
            visitor.visit_avro_doc_on(binding0);
        }
        CsrConfigOptionName::KeyCompatibilityLevel {
        } => {
        }
        CsrConfigOptionName::ValueCompatibilityLevel {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for CsrConnection<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_csr_connection(self)
    }
}
pub fn visit_csr_connection<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast CsrConnection<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_item_name(&node.connection);
    for v in &node.options {
        visitor.visit_csr_config_option(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for CsrConnectionAvro<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_csr_connection_avro(self)
    }
}
pub fn visit_csr_connection_avro<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast CsrConnectionAvro<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_csr_connection(&node.connection);
    if let Some(v) = &node.key_strategy {
        visitor.visit_reader_schema_selection_strategy(v);
    }
    if let Some(v) = &node.value_strategy {
        visitor.visit_reader_schema_selection_strategy(v);
    }
    if let Some(v) = &node.seed {
        visitor.visit_csr_seed_avro(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for CsrConnectionProtobuf<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_csr_connection_protobuf(self)
    }
}
pub fn visit_csr_connection_protobuf<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast CsrConnectionProtobuf<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_csr_connection(&node.connection);
    if let Some(v) = &node.seed {
        visitor.visit_csr_seed_protobuf(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for CsrSeedAvro {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_csr_seed_avro(self)
    }
}
pub fn visit_csr_seed_avro<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast CsrSeedAvro)
where
    V: Visit<'ast, T, > + ?Sized,
{
    if let Some(v) = &node.key_schema {
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for CsrSeedProtobuf {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_csr_seed_protobuf(self)
    }
}
pub fn visit_csr_seed_protobuf<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast CsrSeedProtobuf)
where
    V: Visit<'ast, T, > + ?Sized,
{
    if let Some(v) = &node.key {
        visitor.visit_csr_seed_protobuf_schema(v);
    }
    visitor.visit_csr_seed_protobuf_schema(&node.value);
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for CsrSeedProtobufSchema {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_csr_seed_protobuf_schema(self)
    }
}
pub fn visit_csr_seed_protobuf_schema<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast CsrSeedProtobufSchema)
where
    V: Visit<'ast, T, > + ?Sized,
{
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for CsvColumns {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_csv_columns(self)
    }
}
pub fn visit_csv_columns<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast CsvColumns)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        CsvColumns::Count {
            0: binding0,
        } => {
        }
        CsvColumns::Header {
            names: binding0,
        } => {
            for v in binding0 {
                visitor.visit_ident(v);
            }
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for Cte<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_cte(self)
    }
}
pub fn visit_cte<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast Cte<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_table_alias(&node.alias);
    visitor.visit_cte_id(&node.id);
    visitor.visit_query(&node.query);
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for CteBlock<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_cte_block(self)
    }
}
pub fn visit_cte_block<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast CteBlock<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        CteBlock::Simple {
            0: binding0,
        } => {
            for v in binding0 {
                visitor.visit_cte(v);
            }
        }
        CteBlock::MutuallyRecursive {
            0: binding0,
        } => {
            visitor.visit_mut_rec_block(binding0);
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for CteMutRec<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_cte_mut_rec(self)
    }
}
pub fn visit_cte_mut_rec<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast CteMutRec<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_ident(&node.name);
    for v in &node.columns {
        visitor.visit_cte_mut_rec_column_def(v);
    }
    visitor.visit_cte_id(&node.id);
    visitor.visit_query(&node.query);
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for CteMutRecColumnDef<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_cte_mut_rec_column_def(self)
    }
}
pub fn visit_cte_mut_rec_column_def<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast CteMutRecColumnDef<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_ident(&node.name);
    visitor.visit_data_type(&node.data_type);
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for DateTimeField {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_date_time_field(self)
    }
}
pub fn visit_date_time_field<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast DateTimeField)
where
    V: Visit<'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, > VisitNode<'ast, T, > for DeallocateStatement {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_deallocate_statement(self)
    }
}
pub fn visit_deallocate_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast DeallocateStatement)
where
    V: Visit<'ast, T, > + ?Sized,
{
    if let Some(v) = &node.name {
        visitor.visit_ident(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for DeclareStatement<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_declare_statement(self)
    }
}
pub fn visit_declare_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast DeclareStatement<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_ident(&node.name);
    visitor.visit_nested_statement(&*&node.stmt);
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for DeferredItemName<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_deferred_item_name(self)
    }
}
pub fn visit_deferred_item_name<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast DeferredItemName<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        DeferredItemName::Named {
            0: binding0,
        } => {
            visitor.visit_item_name(binding0);
        }
        DeferredItemName::Deferred {
            0: binding0,
        } => {
            visitor.visit_unresolved_item_name(binding0);
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for DeleteStatement<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_delete_statement(self)
    }
}
pub fn visit_delete_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast DeleteStatement<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_item_name(&node.table_name);
    if let Some(v) = &node.alias {
        visitor.visit_table_alias(v);
    }
    for v in &node.using {
        visitor.visit_table_with_joins(v);
    }
    if let Some(v) = &node.selection {
        visitor.visit_expr(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for DiscardStatement {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_discard_statement(self)
    }
}
pub fn visit_discard_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast DiscardStatement)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_discard_target(&node.target);
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for DiscardTarget {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_discard_target(self)
    }
}
pub fn visit_discard_target<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast DiscardTarget)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        DiscardTarget::Plans {
        } => {
        }
        DiscardTarget::Sequences {
        } => {
        }
        DiscardTarget::Temp {
        } => {
        }
        DiscardTarget::All {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for Distinct<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_distinct(self)
    }
}
pub fn visit_distinct<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast Distinct<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        Distinct::EntireRow {
        } => {
        }
        Distinct::On {
            0: binding0,
        } => {
            for v in binding0 {
                visitor.visit_expr(v);
            }
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for DocOnIdentifier<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_doc_on_identifier(self)
    }
}
pub fn visit_doc_on_identifier<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast DocOnIdentifier<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        DocOnIdentifier::Column {
            0: binding0,
        } => {
            visitor.visit_column_name(binding0);
        }
        DocOnIdentifier::Type {
            0: binding0,
        } => {
            visitor.visit_item_name(binding0);
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for DocOnSchema {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_doc_on_schema(self)
    }
}
pub fn visit_doc_on_schema<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast DocOnSchema)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        DocOnSchema::KeyOnly {
        } => {
        }
        DocOnSchema::ValueOnly {
        } => {
        }
        DocOnSchema::All {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for DropObjectsStatement {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_drop_objects_statement(self)
    }
}
pub fn visit_drop_objects_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast DropObjectsStatement)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_object_type(&node.object_type);
    for v in &node.names {
        visitor.visit_unresolved_object_name(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for DropOwnedStatement<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_drop_owned_statement(self)
    }
}
pub fn visit_drop_owned_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast DropOwnedStatement<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    for v in &node.role_names {
        visitor.visit_role_name(v);
    }
    if let Some(v) = &node.cascade {
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for ExecuteStatement<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_execute_statement(self)
    }
}
pub fn visit_execute_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast ExecuteStatement<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_ident(&node.name);
    for v in &node.params {
        visitor.visit_expr(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for ExplainFormat {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_explain_format(self)
    }
}
pub fn visit_explain_format<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast ExplainFormat)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        ExplainFormat::Text {
        } => {
        }
        ExplainFormat::Json {
        } => {
        }
        ExplainFormat::Dot {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for ExplainPlanOption<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_explain_plan_option(self)
    }
}
pub fn visit_explain_plan_option<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast ExplainPlanOption<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_explain_plan_option_name(&node.name);
    if let Some(v) = &node.value {
        visitor.visit_with_option_value(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for ExplainPlanOptionName {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_explain_plan_option_name(self)
    }
}
pub fn visit_explain_plan_option_name<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast ExplainPlanOptionName)
where
    V: Visit<'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::ReoptimizeImportedViews {
        } => {
        }
        ExplainPlanOptionName::EnableNewOuterJoinLowering {
        } => {
        }
        ExplainPlanOptionName::EnableEagerDeltaJoins {
        } => {
        }
        ExplainPlanOptionName::EnableVariadicLeftJoinLowering {
        } => {
        }
        ExplainPlanOptionName::EnableLetrecFixpointAnalysis {
        } => {
        }
        ExplainPlanOptionName::EnableOuterJoinNullFilter {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for ExplainPlanStatement<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_explain_plan_statement(self)
    }
}
pub fn visit_explain_plan_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast ExplainPlanStatement<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    if let Some(v) = &node.stage {
        visitor.visit_explain_stage(v);
    }
    for v in &node.with_options {
        visitor.visit_explain_plan_option(v);
    }
    if let Some(v) = &node.format {
        visitor.visit_explain_format(v);
    }
    visitor.visit_explainee(&node.explainee);
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for ExplainPushdownStatement<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_explain_pushdown_statement(self)
    }
}
pub fn visit_explain_pushdown_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast ExplainPushdownStatement<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_explainee(&node.explainee);
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for ExplainSinkSchemaFor {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_explain_sink_schema_for(self)
    }
}
pub fn visit_explain_sink_schema_for<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast ExplainSinkSchemaFor)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        ExplainSinkSchemaFor::Key {
        } => {
        }
        ExplainSinkSchemaFor::Value {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for ExplainSinkSchemaStatement<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_explain_sink_schema_statement(self)
    }
}
pub fn visit_explain_sink_schema_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast ExplainSinkSchemaStatement<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_explain_sink_schema_for(&node.schema_for);
    if let Some(v) = &node.format {
        visitor.visit_explain_format(v);
    }
    visitor.visit_create_sink_statement(&node.statement);
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for ExplainStage {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_explain_stage(self)
    }
}
pub fn visit_explain_stage<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast ExplainStage)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        ExplainStage::RawPlan {
        } => {
        }
        ExplainStage::DecorrelatedPlan {
        } => {
        }
        ExplainStage::LocalPlan {
        } => {
        }
        ExplainStage::GlobalPlan {
        } => {
        }
        ExplainStage::PhysicalPlan {
        } => {
        }
        ExplainStage::Trace {
        } => {
        }
        ExplainStage::PlanInsights {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for ExplainTimestampStatement<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_explain_timestamp_statement(self)
    }
}
pub fn visit_explain_timestamp_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast ExplainTimestampStatement<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    if let Some(v) = &node.format {
        visitor.visit_explain_format(v);
    }
    visitor.visit_select_statement(&node.select);
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for Explainee<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_explainee(self)
    }
}
pub fn visit_explainee<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast Explainee<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        Explainee::View {
            0: binding0,
        } => {
            visitor.visit_item_name(binding0);
        }
        Explainee::MaterializedView {
            0: binding0,
        } => {
            visitor.visit_item_name(binding0);
        }
        Explainee::Index {
            0: binding0,
        } => {
            visitor.visit_item_name(binding0);
        }
        Explainee::ReplanView {
            0: binding0,
        } => {
            visitor.visit_item_name(binding0);
        }
        Explainee::ReplanMaterializedView {
            0: binding0,
        } => {
            visitor.visit_item_name(binding0);
        }
        Explainee::ReplanIndex {
            0: binding0,
        } => {
            visitor.visit_item_name(binding0);
        }
        Explainee::Select {
            0: binding0,
            1: binding1,
        } => {
            visitor.visit_select_statement(&*binding0);
        }
        Explainee::CreateView {
            0: binding0,
            1: binding1,
        } => {
            visitor.visit_create_view_statement(&*binding0);
        }
        Explainee::CreateMaterializedView {
            0: binding0,
            1: binding1,
        } => {
            visitor.visit_create_materialized_view_statement(&*binding0);
        }
        Explainee::CreateIndex {
            0: binding0,
            1: binding1,
        } => {
            visitor.visit_create_index_statement(&*binding0);
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for Expr<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_expr(self)
    }
}
pub fn visit_expr<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast Expr<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        Expr::Identifier {
            0: binding0,
        } => {
            for v in binding0 {
                visitor.visit_ident(v);
            }
        }
        Expr::QualifiedWildcard {
            0: binding0,
        } => {
            for v in binding0 {
                visitor.visit_ident(v);
            }
        }
        Expr::FieldAccess {
            expr: binding0,
            field: binding1,
        } => {
            visitor.visit_expr(&*binding0);
            visitor.visit_ident(binding1);
        }
        Expr::WildcardAccess {
            0: binding0,
        } => {
            visitor.visit_expr(&*binding0);
        }
        Expr::Parameter {
            0: binding0,
        } => {
        }
        Expr::Not {
            expr: binding0,
        } => {
            visitor.visit_expr(&*binding0);
        }
        Expr::And {
            left: binding0,
            right: binding1,
        } => {
            visitor.visit_expr(&*binding0);
            visitor.visit_expr(&*binding1);
        }
        Expr::Or {
            left: binding0,
            right: binding1,
        } => {
            visitor.visit_expr(&*binding0);
            visitor.visit_expr(&*binding1);
        }
        Expr::IsExpr {
            expr: binding0,
            construct: binding1,
            negated: binding2,
        } => {
            visitor.visit_expr(&*binding0);
            visitor.visit_is_expr_construct(binding1);
        }
        Expr::InList {
            expr: binding0,
            list: binding1,
            negated: binding2,
        } => {
            visitor.visit_expr(&*binding0);
            for v in binding1 {
                visitor.visit_expr(v);
            }
        }
        Expr::InSubquery {
            expr: binding0,
            subquery: binding1,
            negated: binding2,
        } => {
            visitor.visit_expr(&*binding0);
            visitor.visit_query(&*binding1);
        }
        Expr::Like {
            expr: binding0,
            pattern: binding1,
            escape: binding2,
            case_insensitive: binding3,
            negated: binding4,
        } => {
            visitor.visit_expr(&*binding0);
            visitor.visit_expr(&*binding1);
            if let Some(v) = binding2 {
                visitor.visit_expr(&*v);
            }
        }
        Expr::Between {
            expr: binding0,
            negated: binding1,
            low: binding2,
            high: binding3,
        } => {
            visitor.visit_expr(&*binding0);
            visitor.visit_expr(&*binding2);
            visitor.visit_expr(&*binding3);
        }
        Expr::Op {
            op: binding0,
            expr1: binding1,
            expr2: binding2,
        } => {
            visitor.visit_op(binding0);
            visitor.visit_expr(&*binding1);
            if let Some(v) = binding2 {
                visitor.visit_expr(&*v);
            }
        }
        Expr::Cast {
            expr: binding0,
            data_type: binding1,
        } => {
            visitor.visit_expr(&*binding0);
            visitor.visit_data_type(binding1);
        }
        Expr::Collate {
            expr: binding0,
            collation: binding1,
        } => {
            visitor.visit_expr(&*binding0);
            visitor.visit_unresolved_item_name(binding1);
        }
        Expr::HomogenizingFunction {
            function: binding0,
            exprs: binding1,
        } => {
            visitor.visit_homogenizing_function(binding0);
            for v in binding1 {
                visitor.visit_expr(v);
            }
        }
        Expr::NullIf {
            l_expr: binding0,
            r_expr: binding1,
        } => {
            visitor.visit_expr(&*binding0);
            visitor.visit_expr(&*binding1);
        }
        Expr::Nested {
            0: binding0,
        } => {
            visitor.visit_expr(&*binding0);
        }
        Expr::Row {
            exprs: binding0,
        } => {
            for v in binding0 {
                visitor.visit_expr(v);
            }
        }
        Expr::Value {
            0: binding0,
        } => {
            visitor.visit_value(binding0);
        }
        Expr::Function {
            0: binding0,
        } => {
            visitor.visit_function(binding0);
        }
        Expr::Case {
            operand: binding0,
            conditions: binding1,
            results: binding2,
            else_result: binding3,
        } => {
            if let Some(v) = binding0 {
                visitor.visit_expr(&*v);
            }
            for v in binding1 {
                visitor.visit_expr(v);
            }
            for v in binding2 {
                visitor.visit_expr(v);
            }
            if let Some(v) = binding3 {
                visitor.visit_expr(&*v);
            }
        }
        Expr::Exists {
            0: binding0,
        } => {
            visitor.visit_query(&*binding0);
        }
        Expr::Subquery {
            0: binding0,
        } => {
            visitor.visit_query(&*binding0);
        }
        Expr::AnySubquery {
            left: binding0,
            op: binding1,
            right: binding2,
        } => {
            visitor.visit_expr(&*binding0);
            visitor.visit_op(binding1);
            visitor.visit_query(&*binding2);
        }
        Expr::AnyExpr {
            left: binding0,
            op: binding1,
            right: binding2,
        } => {
            visitor.visit_expr(&*binding0);
            visitor.visit_op(binding1);
            visitor.visit_expr(&*binding2);
        }
        Expr::AllSubquery {
            left: binding0,
            op: binding1,
            right: binding2,
        } => {
            visitor.visit_expr(&*binding0);
            visitor.visit_op(binding1);
            visitor.visit_query(&*binding2);
        }
        Expr::AllExpr {
            left: binding0,
            op: binding1,
            right: binding2,
        } => {
            visitor.visit_expr(&*binding0);
            visitor.visit_op(binding1);
            visitor.visit_expr(&*binding2);
        }
        Expr::Array {
            0: binding0,
        } => {
            for v in binding0 {
                visitor.visit_expr(v);
            }
        }
        Expr::ArraySubquery {
            0: binding0,
        } => {
            visitor.visit_query(&*binding0);
        }
        Expr::List {
            0: binding0,
        } => {
            for v in binding0 {
                visitor.visit_expr(v);
            }
        }
        Expr::ListSubquery {
            0: binding0,
        } => {
            visitor.visit_query(&*binding0);
        }
        Expr::Map {
            0: binding0,
        } => {
            for v in binding0 {
                visitor.visit_map_entry(v);
            }
        }
        Expr::MapSubquery {
            0: binding0,
        } => {
            visitor.visit_query(&*binding0);
        }
        Expr::Subscript {
            expr: binding0,
            positions: binding1,
        } => {
            visitor.visit_expr(&*binding0);
            for v in binding1 {
                visitor.visit_subscript_position(v);
            }
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for ExternalReferenceExport {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_external_reference_export(self)
    }
}
pub fn visit_external_reference_export<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast ExternalReferenceExport)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_unresolved_item_name(&node.reference);
    if let Some(v) = &node.alias {
        visitor.visit_unresolved_item_name(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for ExternalReferences {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_external_references(self)
    }
}
pub fn visit_external_references<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast ExternalReferences)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        ExternalReferences::SubsetTables {
            0: binding0,
        } => {
            for v in binding0 {
                visitor.visit_external_reference_export(v);
            }
        }
        ExternalReferences::SubsetSchemas {
            0: binding0,
        } => {
            for v in binding0 {
                visitor.visit_ident(v);
            }
        }
        ExternalReferences::All {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for FetchDirection {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_fetch_direction(self)
    }
}
pub fn visit_fetch_direction<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast FetchDirection)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        FetchDirection::ForwardAll {
        } => {
        }
        FetchDirection::ForwardCount {
            0: binding0,
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for FetchOption<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_fetch_option(self)
    }
}
pub fn visit_fetch_option<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast FetchOption<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_fetch_option_name(&node.name);
    if let Some(v) = &node.value {
        visitor.visit_with_option_value(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for FetchOptionName {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_fetch_option_name(self)
    }
}
pub fn visit_fetch_option_name<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast FetchOptionName)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        FetchOptionName::Timeout {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for FetchStatement<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_fetch_statement(self)
    }
}
pub fn visit_fetch_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast FetchStatement<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_ident(&node.name);
    if let Some(v) = &node.count {
        visitor.visit_fetch_direction(v);
    }
    for v in &node.options {
        visitor.visit_fetch_option(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for Format<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_format(self)
    }
}
pub fn visit_format<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast Format<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        Format::Bytes {
        } => {
        }
        Format::Avro {
            0: binding0,
        } => {
            visitor.visit_avro_schema(binding0);
        }
        Format::Protobuf {
            0: binding0,
        } => {
            visitor.visit_protobuf_schema(binding0);
        }
        Format::Regex {
            0: binding0,
        } => {
        }
        Format::Csv {
            columns: binding0,
            delimiter: binding1,
        } => {
            visitor.visit_csv_columns(binding0);
        }
        Format::Json {
            array: binding0,
        } => {
        }
        Format::Text {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for FormatSpecifier<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_format_specifier(self)
    }
}
pub fn visit_format_specifier<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast FormatSpecifier<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        FormatSpecifier::Bare {
            0: binding0,
        } => {
            visitor.visit_format(binding0);
        }
        FormatSpecifier::KeyValue {
            key: binding0,
            value: binding1,
        } => {
            visitor.visit_format(binding0);
            visitor.visit_format(binding1);
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for Function<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_function(self)
    }
}
pub fn visit_function<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast Function<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_item_name(&node.name);
    visitor.visit_function_args(&node.args);
    if let Some(v) = &node.filter {
        visitor.visit_expr(&*v);
    }
    if let Some(v) = &node.over {
        visitor.visit_window_spec(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for FunctionArgs<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_function_args(self)
    }
}
pub fn visit_function_args<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast FunctionArgs<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        FunctionArgs::Star {
        } => {
        }
        FunctionArgs::Args {
            args: binding0,
            order_by: binding1,
        } => {
            for v in binding0 {
                visitor.visit_expr(v);
            }
            for v in binding1 {
                visitor.visit_order_by_expr(v);
            }
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for GrantPrivilegesStatement<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_grant_privileges_statement(self)
    }
}
pub fn visit_grant_privileges_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast GrantPrivilegesStatement<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_privilege_specification(&node.privileges);
    visitor.visit_grant_target_specification(&node.target);
    for v in &node.roles {
        visitor.visit_role_name(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for GrantRoleStatement<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_grant_role_statement(self)
    }
}
pub fn visit_grant_role_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast GrantRoleStatement<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    for v in &node.role_names {
        visitor.visit_role_name(v);
    }
    for v in &node.member_names {
        visitor.visit_role_name(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for GrantTargetAllSpecification<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_grant_target_all_specification(self)
    }
}
pub fn visit_grant_target_all_specification<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast GrantTargetAllSpecification<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        GrantTargetAllSpecification::All {
        } => {
        }
        GrantTargetAllSpecification::AllDatabases {
            databases: binding0,
        } => {
            for v in binding0 {
                visitor.visit_database_name(v);
            }
        }
        GrantTargetAllSpecification::AllSchemas {
            schemas: binding0,
        } => {
            for v in binding0 {
                visitor.visit_schema_name(v);
            }
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for GrantTargetSpecification<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_grant_target_specification(self)
    }
}
pub fn visit_grant_target_specification<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast GrantTargetSpecification<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        GrantTargetSpecification::Object {
            object_type: binding0,
            object_spec_inner: binding1,
        } => {
            visitor.visit_object_type(binding0);
            visitor.visit_grant_target_specification_inner(binding1);
        }
        GrantTargetSpecification::System {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for GrantTargetSpecificationInner<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_grant_target_specification_inner(self)
    }
}
pub fn visit_grant_target_specification_inner<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast GrantTargetSpecificationInner<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        GrantTargetSpecificationInner::All {
            0: binding0,
        } => {
            visitor.visit_grant_target_all_specification(binding0);
        }
        GrantTargetSpecificationInner::Objects {
            names: binding0,
        } => {
            for v in binding0 {
                visitor.visit_object_name(v);
            }
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for HomogenizingFunction {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_homogenizing_function(self)
    }
}
pub fn visit_homogenizing_function<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast HomogenizingFunction)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        HomogenizingFunction::Coalesce {
        } => {
        }
        HomogenizingFunction::Greatest {
        } => {
        }
        HomogenizingFunction::Least {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for Ident {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_ident(self)
    }
}
pub fn visit_ident<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast Ident)
where
    V: Visit<'ast, T, > + ?Sized,
{
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for IdentError {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_ident_error(self)
    }
}
pub fn visit_ident_error<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast IdentError)
where
    V: Visit<'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, > VisitNode<'ast, T, > for IfExistsBehavior {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_if_exists_behavior(self)
    }
}
pub fn visit_if_exists_behavior<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast IfExistsBehavior)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        IfExistsBehavior::Error {
        } => {
        }
        IfExistsBehavior::Skip {
        } => {
        }
        IfExistsBehavior::Replace {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for IndexOption<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_index_option(self)
    }
}
pub fn visit_index_option<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast IndexOption<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_index_option_name(&node.name);
    if let Some(v) = &node.value {
        visitor.visit_with_option_value(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for IndexOptionName {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_index_option_name(self)
    }
}
pub fn visit_index_option_name<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast IndexOptionName)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        IndexOptionName::RetainHistory {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for InsertSource<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_insert_source(self)
    }
}
pub fn visit_insert_source<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast InsertSource<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        InsertSource::Query {
            0: binding0,
        } => {
            visitor.visit_query(binding0);
        }
        InsertSource::DefaultValues {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for InsertStatement<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_insert_statement(self)
    }
}
pub fn visit_insert_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast InsertStatement<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_item_name(&node.table_name);
    for v in &node.columns {
        visitor.visit_ident(v);
    }
    visitor.visit_insert_source(&node.source);
    for v in &node.returning {
        visitor.visit_select_item(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for InspectShardStatement {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_inspect_shard_statement(self)
    }
}
pub fn visit_inspect_shard_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast InspectShardStatement)
where
    V: Visit<'ast, T, > + ?Sized,
{
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for IntervalValue {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_interval_value(self)
    }
}
pub fn visit_interval_value<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast IntervalValue)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_date_time_field(&node.precision_high);
    visitor.visit_date_time_field(&node.precision_low);
    if let Some(v) = &node.fsec_max_precision {
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for IsExprConstruct<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_is_expr_construct(self)
    }
}
pub fn visit_is_expr_construct<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast IsExprConstruct<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        IsExprConstruct::Null {
        } => {
        }
        IsExprConstruct::True {
        } => {
        }
        IsExprConstruct::False {
        } => {
        }
        IsExprConstruct::Unknown {
        } => {
        }
        IsExprConstruct::DistinctFrom {
            0: binding0,
        } => {
            visitor.visit_expr(&*binding0);
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for Join<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_join(self)
    }
}
pub fn visit_join<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast Join<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_table_factor(&node.relation);
    visitor.visit_join_operator(&node.join_operator);
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for JoinConstraint<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_join_constraint(self)
    }
}
pub fn visit_join_constraint<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast JoinConstraint<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        JoinConstraint::On {
            0: binding0,
        } => {
            visitor.visit_expr(binding0);
        }
        JoinConstraint::Using {
            columns: binding0,
            alias: binding1,
        } => {
            for v in binding0 {
                visitor.visit_ident(v);
            }
            if let Some(v) = binding1 {
                visitor.visit_ident(v);
            }
        }
        JoinConstraint::Natural {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for JoinOperator<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_join_operator(self)
    }
}
pub fn visit_join_operator<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast JoinOperator<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        JoinOperator::Inner {
            0: binding0,
        } => {
            visitor.visit_join_constraint(binding0);
        }
        JoinOperator::LeftOuter {
            0: binding0,
        } => {
            visitor.visit_join_constraint(binding0);
        }
        JoinOperator::RightOuter {
            0: binding0,
        } => {
            visitor.visit_join_constraint(binding0);
        }
        JoinOperator::FullOuter {
            0: binding0,
        } => {
            visitor.visit_join_constraint(binding0);
        }
        JoinOperator::CrossJoin {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for KafkaBroker<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_kafka_broker(self)
    }
}
pub fn visit_kafka_broker<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast KafkaBroker<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_kafka_broker_tunnel(&node.tunnel);
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for KafkaBrokerAwsPrivatelink<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_kafka_broker_aws_privatelink(self)
    }
}
pub fn visit_kafka_broker_aws_privatelink<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast KafkaBrokerAwsPrivatelink<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_item_name(&node.connection);
    for v in &node.options {
        visitor.visit_kafka_broker_aws_privatelink_option(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for KafkaBrokerAwsPrivatelinkOption<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_kafka_broker_aws_privatelink_option(self)
    }
}
pub fn visit_kafka_broker_aws_privatelink_option<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast KafkaBrokerAwsPrivatelinkOption<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_kafka_broker_aws_privatelink_option_name(&node.name);
    if let Some(v) = &node.value {
        visitor.visit_with_option_value(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for KafkaBrokerAwsPrivatelinkOptionName {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_kafka_broker_aws_privatelink_option_name(self)
    }
}
pub fn visit_kafka_broker_aws_privatelink_option_name<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast KafkaBrokerAwsPrivatelinkOptionName)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        KafkaBrokerAwsPrivatelinkOptionName::AvailabilityZone {
        } => {
        }
        KafkaBrokerAwsPrivatelinkOptionName::Port {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for KafkaBrokerTunnel<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_kafka_broker_tunnel(self)
    }
}
pub fn visit_kafka_broker_tunnel<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast KafkaBrokerTunnel<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        KafkaBrokerTunnel::Direct {
        } => {
        }
        KafkaBrokerTunnel::AwsPrivatelink {
            0: binding0,
        } => {
            visitor.visit_kafka_broker_aws_privatelink(binding0);
        }
        KafkaBrokerTunnel::SshTunnel {
            0: binding0,
        } => {
            visitor.visit_item_name(binding0);
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for KafkaSinkConfigOption<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_kafka_sink_config_option(self)
    }
}
pub fn visit_kafka_sink_config_option<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast KafkaSinkConfigOption<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_kafka_sink_config_option_name(&node.name);
    if let Some(v) = &node.value {
        visitor.visit_with_option_value(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for KafkaSinkConfigOptionName {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_kafka_sink_config_option_name(self)
    }
}
pub fn visit_kafka_sink_config_option_name<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast KafkaSinkConfigOptionName)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        KafkaSinkConfigOptionName::CompressionType {
        } => {
        }
        KafkaSinkConfigOptionName::ProgressGroupIdPrefix {
        } => {
        }
        KafkaSinkConfigOptionName::Topic {
        } => {
        }
        KafkaSinkConfigOptionName::TransactionalIdPrefix {
        } => {
        }
        KafkaSinkConfigOptionName::LegacyIds {
        } => {
        }
        KafkaSinkConfigOptionName::TopicConfig {
        } => {
        }
        KafkaSinkConfigOptionName::TopicMetadataRefreshInterval {
        } => {
        }
        KafkaSinkConfigOptionName::TopicPartitionCount {
        } => {
        }
        KafkaSinkConfigOptionName::TopicReplicationFactor {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for KafkaSinkKey {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_kafka_sink_key(self)
    }
}
pub fn visit_kafka_sink_key<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast KafkaSinkKey)
where
    V: Visit<'ast, T, > + ?Sized,
{
    for v in &node.key_columns {
        visitor.visit_ident(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for KafkaSourceConfigOption<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_kafka_source_config_option(self)
    }
}
pub fn visit_kafka_source_config_option<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast KafkaSourceConfigOption<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_kafka_source_config_option_name(&node.name);
    if let Some(v) = &node.value {
        visitor.visit_with_option_value(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for KafkaSourceConfigOptionName {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_kafka_source_config_option_name(self)
    }
}
pub fn visit_kafka_source_config_option_name<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast KafkaSourceConfigOptionName)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        KafkaSourceConfigOptionName::GroupIdPrefix {
        } => {
        }
        KafkaSourceConfigOptionName::Topic {
        } => {
        }
        KafkaSourceConfigOptionName::TopicMetadataRefreshInterval {
        } => {
        }
        KafkaSourceConfigOptionName::StartTimestamp {
        } => {
        }
        KafkaSourceConfigOptionName::StartOffset {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for KeyConstraint {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_key_constraint(self)
    }
}
pub fn visit_key_constraint<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast KeyConstraint)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        KeyConstraint::PrimaryKeyNotEnforced {
            columns: binding0,
        } => {
            for v in binding0 {
                visitor.visit_ident(v);
            }
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for Limit<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_limit(self)
    }
}
pub fn visit_limit<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast Limit<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_expr(&node.quantity);
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for LoadGenerator {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_load_generator(self)
    }
}
pub fn visit_load_generator<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast LoadGenerator)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        LoadGenerator::Clock {
        } => {
        }
        LoadGenerator::Counter {
        } => {
        }
        LoadGenerator::Marketing {
        } => {
        }
        LoadGenerator::Auction {
        } => {
        }
        LoadGenerator::Datums {
        } => {
        }
        LoadGenerator::Tpch {
        } => {
        }
        LoadGenerator::KeyValue {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for LoadGeneratorOption<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_load_generator_option(self)
    }
}
pub fn visit_load_generator_option<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast LoadGeneratorOption<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_load_generator_option_name(&node.name);
    if let Some(v) = &node.value {
        visitor.visit_with_option_value(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for LoadGeneratorOptionName {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_load_generator_option_name(self)
    }
}
pub fn visit_load_generator_option_name<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast LoadGeneratorOptionName)
where
    V: Visit<'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, > VisitNode<'ast, T, > for MapEntry<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_map_entry(self)
    }
}
pub fn visit_map_entry<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast MapEntry<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_expr(&node.key);
    visitor.visit_expr(&node.value);
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for MaterializedViewOption<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_materialized_view_option(self)
    }
}
pub fn visit_materialized_view_option<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast MaterializedViewOption<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_materialized_view_option_name(&node.name);
    if let Some(v) = &node.value {
        visitor.visit_with_option_value(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for MaterializedViewOptionName {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_materialized_view_option_name(self)
    }
}
pub fn visit_materialized_view_option_name<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast MaterializedViewOptionName)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        MaterializedViewOptionName::AssertNotNull {
        } => {
        }
        MaterializedViewOptionName::RetainHistory {
        } => {
        }
        MaterializedViewOptionName::Refresh {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for MutRecBlock<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_mut_rec_block(self)
    }
}
pub fn visit_mut_rec_block<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast MutRecBlock<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    for v in &node.options {
        visitor.visit_mut_rec_block_option(v);
    }
    for v in &node.ctes {
        visitor.visit_cte_mut_rec(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for MutRecBlockOption<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_mut_rec_block_option(self)
    }
}
pub fn visit_mut_rec_block_option<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast MutRecBlockOption<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_mut_rec_block_option_name(&node.name);
    if let Some(v) = &node.value {
        visitor.visit_with_option_value(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for MutRecBlockOptionName {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_mut_rec_block_option_name(self)
    }
}
pub fn visit_mut_rec_block_option_name<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast MutRecBlockOptionName)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        MutRecBlockOptionName::RecursionLimit {
        } => {
        }
        MutRecBlockOptionName::ErrorAtRecursionLimit {
        } => {
        }
        MutRecBlockOptionName::ReturnAtRecursionLimit {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for MySqlConfigOption<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_my_sql_config_option(self)
    }
}
pub fn visit_my_sql_config_option<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast MySqlConfigOption<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_my_sql_config_option_name(&node.name);
    if let Some(v) = &node.value {
        visitor.visit_with_option_value(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for MySqlConfigOptionName {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_my_sql_config_option_name(self)
    }
}
pub fn visit_my_sql_config_option_name<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast MySqlConfigOptionName)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        MySqlConfigOptionName::Details {
        } => {
        }
        MySqlConfigOptionName::TextColumns {
        } => {
        }
        MySqlConfigOptionName::IgnoreColumns {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for NamedPlan {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_named_plan(self)
    }
}
pub fn visit_named_plan<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast NamedPlan)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        NamedPlan::Raw {
        } => {
        }
        NamedPlan::Decorrelated {
        } => {
        }
        NamedPlan::Local {
        } => {
        }
        NamedPlan::Global {
        } => {
        }
        NamedPlan::Physical {
        } => {
        }
        NamedPlan::FastPath {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for NoticeSeverity {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_notice_severity(self)
    }
}
pub fn visit_notice_severity<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast NoticeSeverity)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        NoticeSeverity::Debug {
        } => {
        }
        NoticeSeverity::Info {
        } => {
        }
        NoticeSeverity::Log {
        } => {
        }
        NoticeSeverity::Notice {
        } => {
        }
        NoticeSeverity::Warning {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for ObjectType {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_object_type(self)
    }
}
pub fn visit_object_type<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast ObjectType)
where
    V: Visit<'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 {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for Op {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_op(self)
    }
}
pub fn visit_op<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast Op)
where
    V: Visit<'ast, T, > + ?Sized,
{
    if let Some(v) = &node.namespace {
        for v in v {
            visitor.visit_ident(v);
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for OrderByExpr<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_order_by_expr(self)
    }
}
pub fn visit_order_by_expr<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast OrderByExpr<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_expr(&node.expr);
    if let Some(v) = &node.asc {
    }
    if let Some(v) = &node.nulls_last {
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for PgConfigOption<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_pg_config_option(self)
    }
}
pub fn visit_pg_config_option<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast PgConfigOption<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_pg_config_option_name(&node.name);
    if let Some(v) = &node.value {
        visitor.visit_with_option_value(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for PgConfigOptionName {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_pg_config_option_name(self)
    }
}
pub fn visit_pg_config_option_name<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast PgConfigOptionName)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        PgConfigOptionName::Details {
        } => {
        }
        PgConfigOptionName::Publication {
        } => {
        }
        PgConfigOptionName::TextColumns {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for PrepareStatement<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_prepare_statement(self)
    }
}
pub fn visit_prepare_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast PrepareStatement<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_ident(&node.name);
    visitor.visit_nested_statement(&*&node.stmt);
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for Privilege {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_privilege(self)
    }
}
pub fn visit_privilege<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast Privilege)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        Privilege::SELECT {
        } => {
        }
        Privilege::INSERT {
        } => {
        }
        Privilege::UPDATE {
        } => {
        }
        Privilege::DELETE {
        } => {
        }
        Privilege::USAGE {
        } => {
        }
        Privilege::CREATE {
        } => {
        }
        Privilege::CREATEROLE {
        } => {
        }
        Privilege::CREATEDB {
        } => {
        }
        Privilege::CREATECLUSTER {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for PrivilegeSpecification {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_privilege_specification(self)
    }
}
pub fn visit_privilege_specification<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast PrivilegeSpecification)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        PrivilegeSpecification::All {
        } => {
        }
        PrivilegeSpecification::Privileges {
            0: binding0,
        } => {
            for v in binding0 {
                visitor.visit_privilege(v);
            }
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for ProtobufSchema<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_protobuf_schema(self)
    }
}
pub fn visit_protobuf_schema<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast ProtobufSchema<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        ProtobufSchema::Csr {
            csr_connection: binding0,
        } => {
            visitor.visit_csr_connection_protobuf(binding0);
        }
        ProtobufSchema::InlineSchema {
            message_name: binding0,
            schema: binding1,
        } => {
            visitor.visit_schema(binding1);
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for QualifiedReplica {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_qualified_replica(self)
    }
}
pub fn visit_qualified_replica<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast QualifiedReplica)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_ident(&node.cluster);
    visitor.visit_ident(&node.replica);
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for Query<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_query(self)
    }
}
pub fn visit_query<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast Query<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_cte_block(&node.ctes);
    visitor.visit_set_expr(&node.body);
    for v in &node.order_by {
        visitor.visit_order_by_expr(v);
    }
    if let Some(v) = &node.limit {
        visitor.visit_limit(v);
    }
    if let Some(v) = &node.offset {
        visitor.visit_expr(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for RaiseStatement {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_raise_statement(self)
    }
}
pub fn visit_raise_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast RaiseStatement)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_notice_severity(&node.severity);
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for ReaderSchemaSelectionStrategy {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_reader_schema_selection_strategy(self)
    }
}
pub fn visit_reader_schema_selection_strategy<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast ReaderSchemaSelectionStrategy)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        ReaderSchemaSelectionStrategy::Latest {
        } => {
        }
        ReaderSchemaSelectionStrategy::Inline {
            0: binding0,
        } => {
        }
        ReaderSchemaSelectionStrategy::ById {
            0: binding0,
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for ReassignOwnedStatement<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_reassign_owned_statement(self)
    }
}
pub fn visit_reassign_owned_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast ReassignOwnedStatement<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    for v in &node.old_roles {
        visitor.visit_role_name(v);
    }
    visitor.visit_role_name(&node.new_role);
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for RefreshAtOptionValue<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_refresh_at_option_value(self)
    }
}
pub fn visit_refresh_at_option_value<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast RefreshAtOptionValue<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_expr(&node.time);
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for RefreshEveryOptionValue<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_refresh_every_option_value(self)
    }
}
pub fn visit_refresh_every_option_value<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast RefreshEveryOptionValue<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_interval_value(&node.interval);
    if let Some(v) = &node.aligned_to {
        visitor.visit_expr(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for RefreshOptionValue<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_refresh_option_value(self)
    }
}
pub fn visit_refresh_option_value<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast RefreshOptionValue<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        RefreshOptionValue::OnCommit {
        } => {
        }
        RefreshOptionValue::AtCreation {
        } => {
        }
        RefreshOptionValue::At {
            0: binding0,
        } => {
            visitor.visit_refresh_at_option_value(binding0);
        }
        RefreshOptionValue::Every {
            0: binding0,
        } => {
            visitor.visit_refresh_every_option_value(binding0);
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for ReplicaDefinition<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_replica_definition(self)
    }
}
pub fn visit_replica_definition<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast ReplicaDefinition<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_ident(&node.name);
    for v in &node.options {
        visitor.visit_replica_option(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for ReplicaOption<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_replica_option(self)
    }
}
pub fn visit_replica_option<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast ReplicaOption<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_replica_option_name(&node.name);
    if let Some(v) = &node.value {
        visitor.visit_with_option_value(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for ReplicaOptionName {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_replica_option_name(self)
    }
}
pub fn visit_replica_option_name<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast ReplicaOptionName)
where
    V: Visit<'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, > VisitNode<'ast, T, > for ResetVariableStatement {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_reset_variable_statement(self)
    }
}
pub fn visit_reset_variable_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast ResetVariableStatement)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_ident(&node.variable);
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for RevokePrivilegesStatement<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_revoke_privileges_statement(self)
    }
}
pub fn visit_revoke_privileges_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast RevokePrivilegesStatement<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_privilege_specification(&node.privileges);
    visitor.visit_grant_target_specification(&node.target);
    for v in &node.roles {
        visitor.visit_role_name(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for RevokeRoleStatement<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_revoke_role_statement(self)
    }
}
pub fn visit_revoke_role_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast RevokeRoleStatement<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    for v in &node.role_names {
        visitor.visit_role_name(v);
    }
    for v in &node.member_names {
        visitor.visit_role_name(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for RoleAttribute {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_role_attribute(self)
    }
}
pub fn visit_role_attribute<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast RoleAttribute)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        RoleAttribute::Inherit {
        } => {
        }
        RoleAttribute::NoInherit {
        } => {
        }
        RoleAttribute::Login {
        } => {
        }
        RoleAttribute::NoLogin {
        } => {
        }
        RoleAttribute::SuperUser {
        } => {
        }
        RoleAttribute::NoSuperUser {
        } => {
        }
        RoleAttribute::CreateCluster {
        } => {
        }
        RoleAttribute::NoCreateCluster {
        } => {
        }
        RoleAttribute::CreateDB {
        } => {
        }
        RoleAttribute::NoCreateDB {
        } => {
        }
        RoleAttribute::CreateRole {
        } => {
        }
        RoleAttribute::NoCreateRole {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for RollbackStatement {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_rollback_statement(self)
    }
}
pub fn visit_rollback_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast RollbackStatement)
where
    V: Visit<'ast, T, > + ?Sized,
{
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for Schema {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_schema(self)
    }
}
pub fn visit_schema<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast Schema)
where
    V: Visit<'ast, T, > + ?Sized,
{
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for Select<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_select(self)
    }
}
pub fn visit_select<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast Select<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    if let Some(v) = &node.distinct {
        visitor.visit_distinct(v);
    }
    for v in &node.projection {
        visitor.visit_select_item(v);
    }
    for v in &node.from {
        visitor.visit_table_with_joins(v);
    }
    if let Some(v) = &node.selection {
        visitor.visit_expr(v);
    }
    for v in &node.group_by {
        visitor.visit_expr(v);
    }
    if let Some(v) = &node.having {
        visitor.visit_expr(v);
    }
    for v in &node.options {
        visitor.visit_select_option(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for SelectItem<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_select_item(self)
    }
}
pub fn visit_select_item<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast SelectItem<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        SelectItem::Expr {
            expr: binding0,
            alias: binding1,
        } => {
            visitor.visit_expr(binding0);
            if let Some(v) = binding1 {
                visitor.visit_ident(v);
            }
        }
        SelectItem::Wildcard {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for SelectOption<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_select_option(self)
    }
}
pub fn visit_select_option<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast SelectOption<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_select_option_name(&node.name);
    if let Some(v) = &node.value {
        visitor.visit_with_option_value(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for SelectOptionName {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_select_option_name(self)
    }
}
pub fn visit_select_option_name<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast SelectOptionName)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        SelectOptionName::ExpectedGroupSize {
        } => {
        }
        SelectOptionName::AggregateInputGroupSize {
        } => {
        }
        SelectOptionName::DistinctOnInputGroupSize {
        } => {
        }
        SelectOptionName::LimitInputGroupSize {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for SelectStatement<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_select_statement(self)
    }
}
pub fn visit_select_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast SelectStatement<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_query(&node.query);
    if let Some(v) = &node.as_of {
        visitor.visit_as_of(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for SetExpr<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_set_expr(self)
    }
}
pub fn visit_set_expr<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast SetExpr<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        SetExpr::Select {
            0: binding0,
        } => {
            visitor.visit_select(&*binding0);
        }
        SetExpr::Query {
            0: binding0,
        } => {
            visitor.visit_query(&*binding0);
        }
        SetExpr::SetOperation {
            op: binding0,
            all: binding1,
            left: binding2,
            right: binding3,
        } => {
            visitor.visit_set_operator(binding0);
            visitor.visit_set_expr(&*binding2);
            visitor.visit_set_expr(&*binding3);
        }
        SetExpr::Values {
            0: binding0,
        } => {
            visitor.visit_values(binding0);
        }
        SetExpr::Show {
            0: binding0,
        } => {
            visitor.visit_show_statement(binding0);
        }
        SetExpr::Table {
            0: binding0,
        } => {
            visitor.visit_item_name(binding0);
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for SetOperator {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_set_operator(self)
    }
}
pub fn visit_set_operator<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast SetOperator)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        SetOperator::Union {
        } => {
        }
        SetOperator::Except {
        } => {
        }
        SetOperator::Intersect {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for SetRoleVar {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_set_role_var(self)
    }
}
pub fn visit_set_role_var<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast SetRoleVar)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        SetRoleVar::Set {
            name: binding0,
            value: binding1,
        } => {
            visitor.visit_ident(binding0);
            visitor.visit_set_variable_to(binding1);
        }
        SetRoleVar::Reset {
            name: binding0,
        } => {
            visitor.visit_ident(binding0);
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for SetTransactionStatement {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_set_transaction_statement(self)
    }
}
pub fn visit_set_transaction_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast SetTransactionStatement)
where
    V: Visit<'ast, T, > + ?Sized,
{
    for v in &node.modes {
        visitor.visit_transaction_mode(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for SetVariableStatement {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_set_variable_statement(self)
    }
}
pub fn visit_set_variable_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast SetVariableStatement)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_ident(&node.variable);
    visitor.visit_set_variable_to(&node.to);
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for SetVariableTo {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_set_variable_to(self)
    }
}
pub fn visit_set_variable_to<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast SetVariableTo)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        SetVariableTo::Default {
        } => {
        }
        SetVariableTo::Values {
            0: binding0,
        } => {
            for v in binding0 {
                visitor.visit_set_variable_value(v);
            }
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for SetVariableValue {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_set_variable_value(self)
    }
}
pub fn visit_set_variable_value<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast SetVariableValue)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        SetVariableValue::Ident {
            0: binding0,
        } => {
            visitor.visit_ident(binding0);
        }
        SetVariableValue::Literal {
            0: binding0,
        } => {
            visitor.visit_value(binding0);
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for ShowColumnsStatement<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_show_columns_statement(self)
    }
}
pub fn visit_show_columns_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast ShowColumnsStatement<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_item_name(&node.table_name);
    if let Some(v) = &node.filter {
        visitor.visit_show_statement_filter(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for ShowCreateClusterStatement<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_show_create_cluster_statement(self)
    }
}
pub fn visit_show_create_cluster_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast ShowCreateClusterStatement<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_cluster_name(&node.cluster_name);
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for ShowCreateConnectionStatement<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_show_create_connection_statement(self)
    }
}
pub fn visit_show_create_connection_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast ShowCreateConnectionStatement<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_item_name(&node.connection_name);
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for ShowCreateIndexStatement<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_show_create_index_statement(self)
    }
}
pub fn visit_show_create_index_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast ShowCreateIndexStatement<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_item_name(&node.index_name);
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for ShowCreateMaterializedViewStatement<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_show_create_materialized_view_statement(self)
    }
}
pub fn visit_show_create_materialized_view_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast ShowCreateMaterializedViewStatement<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_item_name(&node.materialized_view_name);
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for ShowCreateSinkStatement<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_show_create_sink_statement(self)
    }
}
pub fn visit_show_create_sink_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast ShowCreateSinkStatement<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_item_name(&node.sink_name);
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for ShowCreateSourceStatement<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_show_create_source_statement(self)
    }
}
pub fn visit_show_create_source_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast ShowCreateSourceStatement<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_item_name(&node.source_name);
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for ShowCreateTableStatement<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_show_create_table_statement(self)
    }
}
pub fn visit_show_create_table_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast ShowCreateTableStatement<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_item_name(&node.table_name);
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for ShowCreateViewStatement<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_show_create_view_statement(self)
    }
}
pub fn visit_show_create_view_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast ShowCreateViewStatement<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_item_name(&node.view_name);
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for ShowObjectType<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_show_object_type(self)
    }
}
pub fn visit_show_object_type<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast ShowObjectType<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        ShowObjectType::MaterializedView {
            in_cluster: binding0,
        } => {
            if let Some(v) = binding0 {
                visitor.visit_cluster_name(v);
            }
        }
        ShowObjectType::Index {
            in_cluster: binding0,
            on_object: binding1,
        } => {
            if let Some(v) = binding0 {
                visitor.visit_cluster_name(v);
            }
            if let Some(v) = binding1 {
                visitor.visit_item_name(v);
            }
        }
        ShowObjectType::Table {
        } => {
        }
        ShowObjectType::View {
        } => {
        }
        ShowObjectType::Source {
            in_cluster: binding0,
        } => {
            if let Some(v) = binding0 {
                visitor.visit_cluster_name(v);
            }
        }
        ShowObjectType::Sink {
            in_cluster: binding0,
        } => {
            if let Some(v) = binding0 {
                visitor.visit_cluster_name(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(v);
            }
        }
        ShowObjectType::Subsource {
            on_source: binding0,
        } => {
            if let Some(v) = binding0 {
                visitor.visit_item_name(v);
            }
        }
        ShowObjectType::Privileges {
            object_type: binding0,
            role: binding1,
        } => {
            if let Some(v) = binding0 {
                visitor.visit_system_object_type(v);
            }
            if let Some(v) = binding1 {
                visitor.visit_role_name(v);
            }
        }
        ShowObjectType::DefaultPrivileges {
            object_type: binding0,
            role: binding1,
        } => {
            if let Some(v) = binding0 {
                visitor.visit_object_type(v);
            }
            if let Some(v) = binding1 {
                visitor.visit_role_name(v);
            }
        }
        ShowObjectType::RoleMembership {
            role: binding0,
        } => {
            if let Some(v) = binding0 {
                visitor.visit_role_name(v);
            }
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for ShowObjectsStatement<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_show_objects_statement(self)
    }
}
pub fn visit_show_objects_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast ShowObjectsStatement<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_show_object_type(&node.object_type);
    if let Some(v) = &node.from {
        visitor.visit_schema_name(v);
    }
    if let Some(v) = &node.filter {
        visitor.visit_show_statement_filter(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for ShowStatement<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_show_statement(self)
    }
}
pub fn visit_show_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast ShowStatement<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        ShowStatement::ShowObjects {
            0: binding0,
        } => {
            visitor.visit_show_objects_statement(binding0);
        }
        ShowStatement::ShowColumns {
            0: binding0,
        } => {
            visitor.visit_show_columns_statement(binding0);
        }
        ShowStatement::ShowCreateView {
            0: binding0,
        } => {
            visitor.visit_show_create_view_statement(binding0);
        }
        ShowStatement::ShowCreateMaterializedView {
            0: binding0,
        } => {
            visitor.visit_show_create_materialized_view_statement(binding0);
        }
        ShowStatement::ShowCreateSource {
            0: binding0,
        } => {
            visitor.visit_show_create_source_statement(binding0);
        }
        ShowStatement::ShowCreateTable {
            0: binding0,
        } => {
            visitor.visit_show_create_table_statement(binding0);
        }
        ShowStatement::ShowCreateSink {
            0: binding0,
        } => {
            visitor.visit_show_create_sink_statement(binding0);
        }
        ShowStatement::ShowCreateIndex {
            0: binding0,
        } => {
            visitor.visit_show_create_index_statement(binding0);
        }
        ShowStatement::ShowCreateConnection {
            0: binding0,
        } => {
            visitor.visit_show_create_connection_statement(binding0);
        }
        ShowStatement::ShowCreateCluster {
            0: binding0,
        } => {
            visitor.visit_show_create_cluster_statement(binding0);
        }
        ShowStatement::ShowVariable {
            0: binding0,
        } => {
            visitor.visit_show_variable_statement(binding0);
        }
        ShowStatement::InspectShard {
            0: binding0,
        } => {
            visitor.visit_inspect_shard_statement(binding0);
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for ShowStatementFilter<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_show_statement_filter(self)
    }
}
pub fn visit_show_statement_filter<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast ShowStatementFilter<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        ShowStatementFilter::Like {
            0: binding0,
        } => {
        }
        ShowStatementFilter::Where {
            0: binding0,
        } => {
            visitor.visit_expr(binding0);
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for ShowVariableStatement {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_show_variable_statement(self)
    }
}
pub fn visit_show_variable_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast ShowVariableStatement)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_ident(&node.variable);
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for SinkEnvelope {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_sink_envelope(self)
    }
}
pub fn visit_sink_envelope<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast SinkEnvelope)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        SinkEnvelope::Debezium {
        } => {
        }
        SinkEnvelope::Upsert {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for SourceEnvelope {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_source_envelope(self)
    }
}
pub fn visit_source_envelope<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast SourceEnvelope)
where
    V: Visit<'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(v);
            }
        }
        SourceEnvelope::CdcV2 {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for SourceErrorPolicy {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_source_error_policy(self)
    }
}
pub fn visit_source_error_policy<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast SourceErrorPolicy)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        SourceErrorPolicy::Inline {
            alias: binding0,
        } => {
            if let Some(v) = binding0 {
                visitor.visit_ident(v);
            }
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for SourceIncludeMetadata {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_source_include_metadata(self)
    }
}
pub fn visit_source_include_metadata<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast SourceIncludeMetadata)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        SourceIncludeMetadata::Key {
            alias: binding0,
        } => {
            if let Some(v) = binding0 {
                visitor.visit_ident(v);
            }
        }
        SourceIncludeMetadata::Timestamp {
            alias: binding0,
        } => {
            if let Some(v) = binding0 {
                visitor.visit_ident(v);
            }
        }
        SourceIncludeMetadata::Partition {
            alias: binding0,
        } => {
            if let Some(v) = binding0 {
                visitor.visit_ident(v);
            }
        }
        SourceIncludeMetadata::Offset {
            alias: binding0,
        } => {
            if let Some(v) = binding0 {
                visitor.visit_ident(v);
            }
        }
        SourceIncludeMetadata::Headers {
            alias: binding0,
        } => {
            if let Some(v) = binding0 {
                visitor.visit_ident(v);
            }
        }
        SourceIncludeMetadata::Header {
            key: binding0,
            alias: binding1,
            use_bytes: binding2,
        } => {
            visitor.visit_ident(binding1);
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for StartTransactionStatement {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_start_transaction_statement(self)
    }
}
pub fn visit_start_transaction_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast StartTransactionStatement)
where
    V: Visit<'ast, T, > + ?Sized,
{
    for v in &node.modes {
        visitor.visit_transaction_mode(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for Statement<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_statement(self)
    }
}
pub fn visit_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast Statement<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        Statement::Select {
            0: binding0,
        } => {
            visitor.visit_select_statement(binding0);
        }
        Statement::Insert {
            0: binding0,
        } => {
            visitor.visit_insert_statement(binding0);
        }
        Statement::Copy {
            0: binding0,
        } => {
            visitor.visit_copy_statement(binding0);
        }
        Statement::Update {
            0: binding0,
        } => {
            visitor.visit_update_statement(binding0);
        }
        Statement::Delete {
            0: binding0,
        } => {
            visitor.visit_delete_statement(binding0);
        }
        Statement::CreateConnection {
            0: binding0,
        } => {
            visitor.visit_create_connection_statement(binding0);
        }
        Statement::CreateDatabase {
            0: binding0,
        } => {
            visitor.visit_create_database_statement(binding0);
        }
        Statement::CreateSchema {
            0: binding0,
        } => {
            visitor.visit_create_schema_statement(binding0);
        }
        Statement::CreateWebhookSource {
            0: binding0,
        } => {
            visitor.visit_create_webhook_source_statement(binding0);
        }
        Statement::CreateSource {
            0: binding0,
        } => {
            visitor.visit_create_source_statement(binding0);
        }
        Statement::CreateSubsource {
            0: binding0,
        } => {
            visitor.visit_create_subsource_statement(binding0);
        }
        Statement::CreateSink {
            0: binding0,
        } => {
            visitor.visit_create_sink_statement(binding0);
        }
        Statement::CreateView {
            0: binding0,
        } => {
            visitor.visit_create_view_statement(binding0);
        }
        Statement::CreateMaterializedView {
            0: binding0,
        } => {
            visitor.visit_create_materialized_view_statement(binding0);
        }
        Statement::CreateTable {
            0: binding0,
        } => {
            visitor.visit_create_table_statement(binding0);
        }
        Statement::CreateTableFromSource {
            0: binding0,
        } => {
            visitor.visit_create_table_from_source_statement(binding0);
        }
        Statement::CreateIndex {
            0: binding0,
        } => {
            visitor.visit_create_index_statement(binding0);
        }
        Statement::CreateType {
            0: binding0,
        } => {
            visitor.visit_create_type_statement(binding0);
        }
        Statement::CreateRole {
            0: binding0,
        } => {
            visitor.visit_create_role_statement(binding0);
        }
        Statement::CreateCluster {
            0: binding0,
        } => {
            visitor.visit_create_cluster_statement(binding0);
        }
        Statement::CreateClusterReplica {
            0: binding0,
        } => {
            visitor.visit_create_cluster_replica_statement(binding0);
        }
        Statement::CreateSecret {
            0: binding0,
        } => {
            visitor.visit_create_secret_statement(binding0);
        }
        Statement::AlterCluster {
            0: binding0,
        } => {
            visitor.visit_alter_cluster_statement(binding0);
        }
        Statement::AlterOwner {
            0: binding0,
        } => {
            visitor.visit_alter_owner_statement(binding0);
        }
        Statement::AlterObjectRename {
            0: binding0,
        } => {
            visitor.visit_alter_object_rename_statement(binding0);
        }
        Statement::AlterObjectSwap {
            0: binding0,
        } => {
            visitor.visit_alter_object_swap_statement(binding0);
        }
        Statement::AlterRetainHistory {
            0: binding0,
        } => {
            visitor.visit_alter_retain_history_statement(binding0);
        }
        Statement::AlterIndex {
            0: binding0,
        } => {
            visitor.visit_alter_index_statement(binding0);
        }
        Statement::AlterSecret {
            0: binding0,
        } => {
            visitor.visit_alter_secret_statement(binding0);
        }
        Statement::AlterSetCluster {
            0: binding0,
        } => {
            visitor.visit_alter_set_cluster_statement(binding0);
        }
        Statement::AlterSink {
            0: binding0,
        } => {
            visitor.visit_alter_sink_statement(binding0);
        }
        Statement::AlterSource {
            0: binding0,
        } => {
            visitor.visit_alter_source_statement(binding0);
        }
        Statement::AlterSystemSet {
            0: binding0,
        } => {
            visitor.visit_alter_system_set_statement(binding0);
        }
        Statement::AlterSystemReset {
            0: binding0,
        } => {
            visitor.visit_alter_system_reset_statement(binding0);
        }
        Statement::AlterSystemResetAll {
            0: binding0,
        } => {
            visitor.visit_alter_system_reset_all_statement(binding0);
        }
        Statement::AlterConnection {
            0: binding0,
        } => {
            visitor.visit_alter_connection_statement(binding0);
        }
        Statement::AlterRole {
            0: binding0,
        } => {
            visitor.visit_alter_role_statement(binding0);
        }
        Statement::AlterTableAddColumn {
            0: binding0,
        } => {
            visitor.visit_alter_table_add_column_statement(binding0);
        }
        Statement::Discard {
            0: binding0,
        } => {
            visitor.visit_discard_statement(binding0);
        }
        Statement::DropObjects {
            0: binding0,
        } => {
            visitor.visit_drop_objects_statement(binding0);
        }
        Statement::DropOwned {
            0: binding0,
        } => {
            visitor.visit_drop_owned_statement(binding0);
        }
        Statement::SetVariable {
            0: binding0,
        } => {
            visitor.visit_set_variable_statement(binding0);
        }
        Statement::ResetVariable {
            0: binding0,
        } => {
            visitor.visit_reset_variable_statement(binding0);
        }
        Statement::Show {
            0: binding0,
        } => {
            visitor.visit_show_statement(binding0);
        }
        Statement::StartTransaction {
            0: binding0,
        } => {
            visitor.visit_start_transaction_statement(binding0);
        }
        Statement::SetTransaction {
            0: binding0,
        } => {
            visitor.visit_set_transaction_statement(binding0);
        }
        Statement::Commit {
            0: binding0,
        } => {
            visitor.visit_commit_statement(binding0);
        }
        Statement::Rollback {
            0: binding0,
        } => {
            visitor.visit_rollback_statement(binding0);
        }
        Statement::Subscribe {
            0: binding0,
        } => {
            visitor.visit_subscribe_statement(binding0);
        }
        Statement::ExplainPlan {
            0: binding0,
        } => {
            visitor.visit_explain_plan_statement(binding0);
        }
        Statement::ExplainPushdown {
            0: binding0,
        } => {
            visitor.visit_explain_pushdown_statement(binding0);
        }
        Statement::ExplainTimestamp {
            0: binding0,
        } => {
            visitor.visit_explain_timestamp_statement(binding0);
        }
        Statement::ExplainSinkSchema {
            0: binding0,
        } => {
            visitor.visit_explain_sink_schema_statement(binding0);
        }
        Statement::Declare {
            0: binding0,
        } => {
            visitor.visit_declare_statement(binding0);
        }
        Statement::Fetch {
            0: binding0,
        } => {
            visitor.visit_fetch_statement(binding0);
        }
        Statement::Close {
            0: binding0,
        } => {
            visitor.visit_close_statement(binding0);
        }
        Statement::Prepare {
            0: binding0,
        } => {
            visitor.visit_prepare_statement(binding0);
        }
        Statement::Execute {
            0: binding0,
        } => {
            visitor.visit_execute_statement(binding0);
        }
        Statement::Deallocate {
            0: binding0,
        } => {
            visitor.visit_deallocate_statement(binding0);
        }
        Statement::Raise {
            0: binding0,
        } => {
            visitor.visit_raise_statement(binding0);
        }
        Statement::GrantRole {
            0: binding0,
        } => {
            visitor.visit_grant_role_statement(binding0);
        }
        Statement::RevokeRole {
            0: binding0,
        } => {
            visitor.visit_revoke_role_statement(binding0);
        }
        Statement::GrantPrivileges {
            0: binding0,
        } => {
            visitor.visit_grant_privileges_statement(binding0);
        }
        Statement::RevokePrivileges {
            0: binding0,
        } => {
            visitor.visit_revoke_privileges_statement(binding0);
        }
        Statement::AlterDefaultPrivileges {
            0: binding0,
        } => {
            visitor.visit_alter_default_privileges_statement(binding0);
        }
        Statement::ReassignOwned {
            0: binding0,
        } => {
            visitor.visit_reassign_owned_statement(binding0);
        }
        Statement::ValidateConnection {
            0: binding0,
        } => {
            visitor.visit_validate_connection_statement(binding0);
        }
        Statement::Comment {
            0: binding0,
        } => {
            visitor.visit_comment_statement(binding0);
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for SubscribeOption<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_subscribe_option(self)
    }
}
pub fn visit_subscribe_option<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast SubscribeOption<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_subscribe_option_name(&node.name);
    if let Some(v) = &node.value {
        visitor.visit_with_option_value(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for SubscribeOptionName {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_subscribe_option_name(self)
    }
}
pub fn visit_subscribe_option_name<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast SubscribeOptionName)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        SubscribeOptionName::Snapshot {
        } => {
        }
        SubscribeOptionName::Progress {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for SubscribeOutput<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_subscribe_output(self)
    }
}
pub fn visit_subscribe_output<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast SubscribeOutput<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        SubscribeOutput::Diffs {
        } => {
        }
        SubscribeOutput::WithinTimestampOrderBy {
            order_by: binding0,
        } => {
            for v in binding0 {
                visitor.visit_order_by_expr(v);
            }
        }
        SubscribeOutput::EnvelopeUpsert {
            key_columns: binding0,
        } => {
            for v in binding0 {
                visitor.visit_ident(v);
            }
        }
        SubscribeOutput::EnvelopeDebezium {
            key_columns: binding0,
        } => {
            for v in binding0 {
                visitor.visit_ident(v);
            }
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for SubscribeRelation<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_subscribe_relation(self)
    }
}
pub fn visit_subscribe_relation<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast SubscribeRelation<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        SubscribeRelation::Name {
            0: binding0,
        } => {
            visitor.visit_item_name(binding0);
        }
        SubscribeRelation::Query {
            0: binding0,
        } => {
            visitor.visit_query(binding0);
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for SubscribeStatement<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_subscribe_statement(self)
    }
}
pub fn visit_subscribe_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast SubscribeStatement<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_subscribe_relation(&node.relation);
    for v in &node.options {
        visitor.visit_subscribe_option(v);
    }
    if let Some(v) = &node.as_of {
        visitor.visit_as_of(v);
    }
    if let Some(v) = &node.up_to {
        visitor.visit_expr(v);
    }
    visitor.visit_subscribe_output(&node.output);
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for SubscriptPosition<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_subscript_position(self)
    }
}
pub fn visit_subscript_position<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast SubscriptPosition<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    if let Some(v) = &node.start {
        visitor.visit_expr(v);
    }
    if let Some(v) = &node.end {
        visitor.visit_expr(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for SystemObjectType {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_system_object_type(self)
    }
}
pub fn visit_system_object_type<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast SystemObjectType)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        SystemObjectType::System {
        } => {
        }
        SystemObjectType::Object {
            0: binding0,
        } => {
            visitor.visit_object_type(binding0);
        }
    }
}
pub fn visit_cluster_name<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast T::ClusterName)
where
    V: Visit<'ast, T, > + ?Sized,
{
}
pub fn visit_column_reference<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast T::ColumnReference)
where
    V: Visit<'ast, T, > + ?Sized,
{
}
pub fn visit_cte_id<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast T::CteId)
where
    V: Visit<'ast, T, > + ?Sized,
{
}
pub fn visit_data_type<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast T::DataType)
where
    V: Visit<'ast, T, > + ?Sized,
{
}
pub fn visit_database_name<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast T::DatabaseName)
where
    V: Visit<'ast, T, > + ?Sized,
{
}
pub fn visit_item_name<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast T::ItemName)
where
    V: Visit<'ast, T, > + ?Sized,
{
}
pub fn visit_nested_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast T::NestedStatement)
where
    V: Visit<'ast, T, > + ?Sized,
{
}
pub fn visit_object_name<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast T::ObjectName)
where
    V: Visit<'ast, T, > + ?Sized,
{
}
pub fn visit_role_name<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast T::RoleName)
where
    V: Visit<'ast, T, > + ?Sized,
{
}
pub fn visit_schema_name<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast T::SchemaName)
where
    V: Visit<'ast, T, > + ?Sized,
{
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for TableAlias {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_table_alias(self)
    }
}
pub fn visit_table_alias<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast TableAlias)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_ident(&node.name);
    for v in &node.columns {
        visitor.visit_ident(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for TableConstraint<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_table_constraint(self)
    }
}
pub fn visit_table_constraint<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast TableConstraint<T>)
where
    V: Visit<'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(v);
            }
            for v in binding1 {
                visitor.visit_ident(v);
            }
        }
        TableConstraint::ForeignKey {
            name: binding0,
            columns: binding1,
            foreign_table: binding2,
            referred_columns: binding3,
        } => {
            if let Some(v) = binding0 {
                visitor.visit_ident(v);
            }
            for v in binding1 {
                visitor.visit_ident(v);
            }
            visitor.visit_item_name(binding2);
            for v in binding3 {
                visitor.visit_ident(v);
            }
        }
        TableConstraint::Check {
            name: binding0,
            expr: binding1,
        } => {
            if let Some(v) = binding0 {
                visitor.visit_ident(v);
            }
            visitor.visit_expr(&*binding1);
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for TableFactor<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_table_factor(self)
    }
}
pub fn visit_table_factor<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast TableFactor<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        TableFactor::Table {
            name: binding0,
            alias: binding1,
        } => {
            visitor.visit_item_name(binding0);
            if let Some(v) = binding1 {
                visitor.visit_table_alias(v);
            }
        }
        TableFactor::Function {
            function: binding0,
            alias: binding1,
            with_ordinality: binding2,
        } => {
            visitor.visit_function(binding0);
            if let Some(v) = binding1 {
                visitor.visit_table_alias(v);
            }
        }
        TableFactor::RowsFrom {
            functions: binding0,
            alias: binding1,
            with_ordinality: binding2,
        } => {
            for v in binding0 {
                visitor.visit_function(v);
            }
            if let Some(v) = binding1 {
                visitor.visit_table_alias(v);
            }
        }
        TableFactor::Derived {
            lateral: binding0,
            subquery: binding1,
            alias: binding2,
        } => {
            visitor.visit_query(&*binding1);
            if let Some(v) = binding2 {
                visitor.visit_table_alias(v);
            }
        }
        TableFactor::NestedJoin {
            join: binding0,
            alias: binding1,
        } => {
            visitor.visit_table_with_joins(&*binding0);
            if let Some(v) = binding1 {
                visitor.visit_table_alias(v);
            }
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for TableOption<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_table_option(self)
    }
}
pub fn visit_table_option<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast TableOption<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_table_option_name(&node.name);
    if let Some(v) = &node.value {
        visitor.visit_with_option_value(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for TableOptionName {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_table_option_name(self)
    }
}
pub fn visit_table_option_name<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast TableOptionName)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        TableOptionName::RetainHistory {
        } => {
        }
        TableOptionName::RedactedTest {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for TableWithJoins<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_table_with_joins(self)
    }
}
pub fn visit_table_with_joins<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast TableWithJoins<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_table_factor(&node.relation);
    for v in &node.joins {
        visitor.visit_join(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for TargetRoleSpecification<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_target_role_specification(self)
    }
}
pub fn visit_target_role_specification<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast TargetRoleSpecification<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        TargetRoleSpecification::Roles {
            0: binding0,
        } => {
            for v in binding0 {
                visitor.visit_role_name(v);
            }
        }
        TargetRoleSpecification::AllRoles {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for TransactionAccessMode {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_transaction_access_mode(self)
    }
}
pub fn visit_transaction_access_mode<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast TransactionAccessMode)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        TransactionAccessMode::ReadOnly {
        } => {
        }
        TransactionAccessMode::ReadWrite {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for TransactionIsolationLevel {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_transaction_isolation_level(self)
    }
}
pub fn visit_transaction_isolation_level<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast TransactionIsolationLevel)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        TransactionIsolationLevel::ReadUncommitted {
        } => {
        }
        TransactionIsolationLevel::ReadCommitted {
        } => {
        }
        TransactionIsolationLevel::RepeatableRead {
        } => {
        }
        TransactionIsolationLevel::Serializable {
        } => {
        }
        TransactionIsolationLevel::StrongSessionSerializable {
        } => {
        }
        TransactionIsolationLevel::StrictSerializable {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for TransactionMode {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_transaction_mode(self)
    }
}
pub fn visit_transaction_mode<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast TransactionMode)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        TransactionMode::AccessMode {
            0: binding0,
        } => {
            visitor.visit_transaction_access_mode(binding0);
        }
        TransactionMode::IsolationLevel {
            0: binding0,
        } => {
            visitor.visit_transaction_isolation_level(binding0);
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for UnresolvedDatabaseName {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_unresolved_database_name(self)
    }
}
pub fn visit_unresolved_database_name<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast UnresolvedDatabaseName)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_ident(&node.0);
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for UnresolvedItemName {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_unresolved_item_name(self)
    }
}
pub fn visit_unresolved_item_name<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast UnresolvedItemName)
where
    V: Visit<'ast, T, > + ?Sized,
{
    for v in &node.0 {
        visitor.visit_ident(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for UnresolvedObjectName {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_unresolved_object_name(self)
    }
}
pub fn visit_unresolved_object_name<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast UnresolvedObjectName)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        UnresolvedObjectName::Cluster {
            0: binding0,
        } => {
            visitor.visit_ident(binding0);
        }
        UnresolvedObjectName::ClusterReplica {
            0: binding0,
        } => {
            visitor.visit_qualified_replica(binding0);
        }
        UnresolvedObjectName::Database {
            0: binding0,
        } => {
            visitor.visit_unresolved_database_name(binding0);
        }
        UnresolvedObjectName::Schema {
            0: binding0,
        } => {
            visitor.visit_unresolved_schema_name(binding0);
        }
        UnresolvedObjectName::Role {
            0: binding0,
        } => {
            visitor.visit_ident(binding0);
        }
        UnresolvedObjectName::Item {
            0: binding0,
        } => {
            visitor.visit_unresolved_item_name(binding0);
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for UnresolvedSchemaName {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_unresolved_schema_name(self)
    }
}
pub fn visit_unresolved_schema_name<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast UnresolvedSchemaName)
where
    V: Visit<'ast, T, > + ?Sized,
{
    for v in &node.0 {
        visitor.visit_ident(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for UpdateStatement<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_update_statement(self)
    }
}
pub fn visit_update_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast UpdateStatement<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_item_name(&node.table_name);
    if let Some(v) = &node.alias {
        visitor.visit_table_alias(v);
    }
    for v in &node.assignments {
        visitor.visit_assignment(v);
    }
    if let Some(v) = &node.selection {
        visitor.visit_expr(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for ValidateConnectionStatement<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_validate_connection_statement(self)
    }
}
pub fn visit_validate_connection_statement<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast ValidateConnectionStatement<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_item_name(&node.name);
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for Value {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_value(self)
    }
}
pub fn visit_value<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast Value)
where
    V: Visit<'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(binding0);
        }
        Value::Null {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for ValueError {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_value_error(self)
    }
}
pub fn visit_value_error<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast ValueError)
where
    V: Visit<'ast, T, > + ?Sized,
{
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for Values<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_values(self)
    }
}
pub fn visit_values<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast Values<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    for v in &node.0 {
        for v in v {
            visitor.visit_expr(v);
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for ViewDefinition<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_view_definition(self)
    }
}
pub fn visit_view_definition<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast ViewDefinition<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_unresolved_item_name(&node.name);
    for v in &node.columns {
        visitor.visit_ident(v);
    }
    visitor.visit_query(&node.query);
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for WindowFrame {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_window_frame(self)
    }
}
pub fn visit_window_frame<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast WindowFrame)
where
    V: Visit<'ast, T, > + ?Sized,
{
    visitor.visit_window_frame_units(&node.units);
    visitor.visit_window_frame_bound(&node.start_bound);
    if let Some(v) = &node.end_bound {
        visitor.visit_window_frame_bound(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for WindowFrameBound {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_window_frame_bound(self)
    }
}
pub fn visit_window_frame_bound<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast WindowFrameBound)
where
    V: Visit<'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, > VisitNode<'ast, T, > for WindowFrameUnits {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_window_frame_units(self)
    }
}
pub fn visit_window_frame_units<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast WindowFrameUnits)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        WindowFrameUnits::Rows {
        } => {
        }
        WindowFrameUnits::Range {
        } => {
        }
        WindowFrameUnits::Groups {
        } => {
        }
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for WindowSpec<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_window_spec(self)
    }
}
pub fn visit_window_spec<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast WindowSpec<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    for v in &node.partition_by {
        visitor.visit_expr(v);
    }
    for v in &node.order_by {
        visitor.visit_order_by_expr(v);
    }
    if let Some(v) = &node.window_frame {
        visitor.visit_window_frame(v);
    }
}
impl<'ast, T: AstInfo, > VisitNode<'ast, T, > for WithOptionValue<T> {
    fn visit<V: Visit<'ast, T, >>(&'ast self, visitor: &mut V) {
        visitor.visit_with_option_value(self)
    }
}
pub fn visit_with_option_value<'ast, V, T: AstInfo, >(visitor: &mut V, node: &'ast WithOptionValue<T>)
where
    V: Visit<'ast, T, > + ?Sized,
{
    match node {
        WithOptionValue::Value {
            0: binding0,
        } => {
            visitor.visit_value(binding0);
        }
        WithOptionValue::DataType {
            0: binding0,
        } => {
            visitor.visit_data_type(binding0);
        }
        WithOptionValue::Secret {
            0: binding0,
        } => {
            visitor.visit_item_name(binding0);
        }
        WithOptionValue::Item {
            0: binding0,
        } => {
            visitor.visit_item_name(binding0);
        }
        WithOptionValue::UnresolvedItemName {
            0: binding0,
        } => {
            visitor.visit_unresolved_item_name(binding0);
        }
        WithOptionValue::Ident {
            0: binding0,
        } => {
            visitor.visit_ident(binding0);
        }
        WithOptionValue::Sequence {
            0: binding0,
        } => {
            for v in binding0 {
                visitor.visit_with_option_value(v);
            }
        }
        WithOptionValue::Map {
            0: binding0,
        } => {
            for (_, value) in binding0 {
                visitor.visit_with_option_value(value);
            }
        }
        WithOptionValue::ClusterReplicas {
            0: binding0,
        } => {
            for v in binding0 {
                visitor.visit_replica_definition(v);
            }
        }
        WithOptionValue::ConnectionKafkaBroker {
            0: binding0,
        } => {
            visitor.visit_kafka_broker(binding0);
        }
        WithOptionValue::ConnectionAwsPrivatelink {
            0: binding0,
        } => {
            visitor.visit_connection_default_aws_privatelink(binding0);
        }
        WithOptionValue::RetainHistoryFor {
            0: binding0,
        } => {
            visitor.visit_value(binding0);
        }
        WithOptionValue::Refresh {
            0: binding0,
        } => {
            visitor.visit_refresh_option_value(binding0);
        }
        WithOptionValue::ClusterScheduleOptionValue {
            0: binding0,
        } => {
            visitor.visit_cluster_schedule_option_value(binding0);
        }
        WithOptionValue::ClusterAlterStrategy {
            0: binding0,
        } => {
            visitor.visit_cluster_alter_option_value(binding0);
        }
    }
}