Trait sql::ast::fold::Fold[−][src]

pub trait Fold<T, T2> where
    T: AstInfo,
    T2: AstInfo, {

Show 139 methods    fn fold_id(&mut self, node: <T as AstInfo>::Id) -> <T2 as AstInfo>::Id;

    fn fold_object_name(
        &mut self, 
        node: <T as AstInfo>::ObjectName
    ) -> <T2 as AstInfo>::ObjectName;

    fn fold_alter_index_action(
        &mut self, 
        node: AlterIndexAction
    ) -> AlterIndexAction { ... }

    fn fold_alter_index_statement(
        &mut self, 
        node: AlterIndexStatement
    ) -> AlterIndexStatement { ... }

    fn fold_alter_object_rename_statement(
        &mut self, 
        node: AlterObjectRenameStatement
    ) -> AlterObjectRenameStatement { ... }

    fn fold_assignment(&mut self, node: Assignment<T>) -> Assignment<T2> { ... }

    fn fold_avro_schema(&mut self, node: AvroSchema<T>) -> AvroSchema<T2> { ... }

    fn fold_catalog_name(&mut self, node: CatalogName) -> CatalogName { ... }

    fn fold_close_statement(&mut self, node: CloseStatement) -> CloseStatement { ... }

    fn fold_column_def(&mut self, node: ColumnDef<T>) -> ColumnDef<T2> { ... }

    fn fold_column_option(&mut self, node: ColumnOption<T>) -> ColumnOption<T2> { ... }

    fn fold_column_option_def(
        &mut self, 
        node: ColumnOptionDef<T>
    ) -> ColumnOptionDef<T2> { ... }

    fn fold_commit_statement(
        &mut self, 
        node: CommitStatement
    ) -> CommitStatement { ... }

    fn fold_compression(&mut self, node: Compression) -> Compression { ... }

    fn fold_copy_direction(&mut self, node: CopyDirection) -> CopyDirection { ... }

    fn fold_copy_relation(&mut self, node: CopyRelation<T>) -> CopyRelation<T2> { ... }

    fn fold_copy_statement(
        &mut self, 
        node: CopyStatement<T>
    ) -> CopyStatement<T2> { ... }

    fn fold_copy_target(&mut self, node: CopyTarget) -> CopyTarget { ... }

    fn fold_create_database_statement(
        &mut self, 
        node: CreateDatabaseStatement
    ) -> CreateDatabaseStatement { ... }

    fn fold_create_index_statement(
        &mut self, 
        node: CreateIndexStatement<T>
    ) -> CreateIndexStatement<T2> { ... }

    fn fold_create_role_option(
        &mut self, 
        node: CreateRoleOption
    ) -> CreateRoleOption { ... }

    fn fold_create_role_statement(
        &mut self, 
        node: CreateRoleStatement
    ) -> CreateRoleStatement { ... }

    fn fold_create_schema_statement(
        &mut self, 
        node: CreateSchemaStatement
    ) -> CreateSchemaStatement { ... }

    fn fold_create_sink_connector(
        &mut self, 
        node: CreateSinkConnector<T>
    ) -> CreateSinkConnector<T2> { ... }

    fn fold_create_sink_statement(
        &mut self, 
        node: CreateSinkStatement<T>
    ) -> CreateSinkStatement<T2> { ... }

    fn fold_create_source_connector(
        &mut self, 
        node: CreateSourceConnector
    ) -> CreateSourceConnector { ... }

    fn fold_create_source_format(
        &mut self, 
        node: CreateSourceFormat<T>
    ) -> CreateSourceFormat<T2> { ... }

    fn fold_create_source_statement(
        &mut self, 
        node: CreateSourceStatement<T>
    ) -> CreateSourceStatement<T2> { ... }

    fn fold_create_table_statement(
        &mut self, 
        node: CreateTableStatement<T>
    ) -> CreateTableStatement<T2> { ... }

    fn fold_create_type_as(&mut self, node: CreateTypeAs) -> CreateTypeAs { ... }

    fn fold_create_type_statement(
        &mut self, 
        node: CreateTypeStatement<T>
    ) -> CreateTypeStatement<T2> { ... }

    fn fold_create_view_statement(
        &mut self, 
        node: CreateViewStatement<T>
    ) -> CreateViewStatement<T2> { ... }

    fn fold_create_views_definitions(
        &mut self, 
        node: CreateViewsDefinitions<T>
    ) -> CreateViewsDefinitions<T2> { ... }

    fn fold_create_views_source_target(
        &mut self, 
        node: CreateViewsSourceTarget
    ) -> CreateViewsSourceTarget { ... }

    fn fold_create_views_statement(
        &mut self, 
        node: CreateViewsStatement<T>
    ) -> CreateViewsStatement<T2> { ... }

    fn fold_csr_connector_avro(
        &mut self, 
        node: CsrConnectorAvro<T>
    ) -> CsrConnectorAvro<T2> { ... }

    fn fold_csr_connector_proto(
        &mut self, 
        node: CsrConnectorProto<T>
    ) -> CsrConnectorProto<T2> { ... }

    fn fold_csr_seed(&mut self, node: CsrSeed) -> CsrSeed { ... }

    fn fold_csr_seed_compiled(
        &mut self, 
        node: CsrSeedCompiled
    ) -> CsrSeedCompiled { ... }

    fn fold_csr_seed_compiled_encoding(
        &mut self, 
        node: CsrSeedCompiledEncoding
    ) -> CsrSeedCompiledEncoding { ... }

    fn fold_csr_seed_compiled_or_legacy(
        &mut self, 
        node: CsrSeedCompiledOrLegacy
    ) -> CsrSeedCompiledOrLegacy { ... }

    fn fold_csv_columns(&mut self, node: CsvColumns) -> CsvColumns { ... }

    fn fold_cte(&mut self, node: Cte<T>) -> Cte<T2> { ... }

    fn fold_data_type(&mut self, node: DataType<T>) -> DataType<T2> { ... }

    fn fold_date_time_field(&mut self, node: DateTimeField) -> DateTimeField { ... }

    fn fold_dbz_mode(&mut self, node: DbzMode) -> DbzMode { ... }

    fn fold_deallocate_statement(
        &mut self, 
        node: DeallocateStatement
    ) -> DeallocateStatement { ... }

    fn fold_declare_statement(
        &mut self, 
        node: DeclareStatement<T>
    ) -> DeclareStatement<T2> { ... }

    fn fold_delete_statement(
        &mut self, 
        node: DeleteStatement<T>
    ) -> DeleteStatement<T2> { ... }

    fn fold_discard_statement(
        &mut self, 
        node: DiscardStatement
    ) -> DiscardStatement { ... }

    fn fold_discard_target(&mut self, node: DiscardTarget) -> DiscardTarget { ... }

    fn fold_distinct(&mut self, node: Distinct<T>) -> Distinct<T2> { ... }

    fn fold_drop_database_statement(
        &mut self, 
        node: DropDatabaseStatement
    ) -> DropDatabaseStatement { ... }

    fn fold_drop_objects_statement(
        &mut self, 
        node: DropObjectsStatement
    ) -> DropObjectsStatement { ... }

    fn fold_envelope(&mut self, node: Envelope) -> Envelope { ... }

    fn fold_execute_statement(
        &mut self, 
        node: ExecuteStatement<T>
    ) -> ExecuteStatement<T2> { ... }

    fn fold_explain_options(&mut self, node: ExplainOptions) -> ExplainOptions { ... }

    fn fold_explain_stage(&mut self, node: ExplainStage) -> ExplainStage { ... }

    fn fold_explain_statement(
        &mut self, 
        node: ExplainStatement<T>
    ) -> ExplainStatement<T2> { ... }

    fn fold_explainee(&mut self, node: Explainee<T>) -> Explainee<T2> { ... }

    fn fold_expr(&mut self, node: Expr<T>) -> Expr<T2> { ... }

    fn fold_fetch_direction(&mut self, node: FetchDirection) -> FetchDirection { ... }

    fn fold_fetch_statement(&mut self, node: FetchStatement) -> FetchStatement { ... }

    fn fold_format(&mut self, node: Format<T>) -> Format<T2> { ... }

    fn fold_function(&mut self, node: Function<T>) -> Function<T2> { ... }

    fn fold_function_args(&mut self, node: FunctionArgs<T>) -> FunctionArgs<T2> { ... }

    fn fold_homogenizing_function(
        &mut self, 
        node: HomogenizingFunction
    ) -> HomogenizingFunction { ... }

    fn fold_ident(&mut self, node: Ident) -> Ident { ... }

    fn fold_if_exists_behavior(
        &mut self, 
        node: IfExistsBehavior
    ) -> IfExistsBehavior { ... }

    fn fold_insert_source(&mut self, node: InsertSource<T>) -> InsertSource<T2> { ... }

    fn fold_insert_statement(
        &mut self, 
        node: InsertStatement<T>
    ) -> InsertStatement<T2> { ... }

    fn fold_interval_value(&mut self, node: IntervalValue) -> IntervalValue { ... }

    fn fold_is_expr_construct(
        &mut self, 
        node: IsExprConstruct
    ) -> IsExprConstruct { ... }

    fn fold_join(&mut self, node: Join<T>) -> Join<T2> { ... }

    fn fold_join_constraint(
        &mut self, 
        node: JoinConstraint<T>
    ) -> JoinConstraint<T2> { ... }

    fn fold_join_operator(&mut self, node: JoinOperator<T>) -> JoinOperator<T2> { ... }

    fn fold_kafka_consistency(
        &mut self, 
        node: KafkaConsistency<T>
    ) -> KafkaConsistency<T2> { ... }

    fn fold_kafka_sink_key(&mut self, node: KafkaSinkKey) -> KafkaSinkKey { ... }

    fn fold_key_constraint(&mut self, node: KeyConstraint) -> KeyConstraint { ... }

    fn fold_limit(&mut self, node: Limit<T>) -> Limit<T2> { ... }

    fn fold_object_type(&mut self, node: ObjectType) -> ObjectType { ... }

    fn fold_op(&mut self, node: Op) -> Op { ... }

    fn fold_order_by_expr(&mut self, node: OrderByExpr<T>) -> OrderByExpr<T2> { ... }

    fn fold_pg_table(&mut self, node: PgTable<T>) -> PgTable<T2> { ... }

    fn fold_prepare_statement(
        &mut self, 
        node: PrepareStatement<T>
    ) -> PrepareStatement<T2> { ... }

    fn fold_protobuf_schema(
        &mut self, 
        node: ProtobufSchema<T>
    ) -> ProtobufSchema<T2> { ... }

    fn fold_query(&mut self, node: Query<T>) -> Query<T2> { ... }

    fn fold_raw(&mut self, node: Raw) -> Raw { ... }

    fn fold_raw_name(&mut self, node: RawName) -> RawName { ... }

    fn fold_rollback_statement(
        &mut self, 
        node: RollbackStatement
    ) -> RollbackStatement { ... }

    fn fold_s3_key_source(&mut self, node: S3KeySource) -> S3KeySource { ... }

    fn fold_schema(&mut self, node: Schema) -> Schema { ... }

    fn fold_select(&mut self, node: Select<T>) -> Select<T2> { ... }

    fn fold_select_item(&mut self, node: SelectItem<T>) -> SelectItem<T2> { ... }

    fn fold_select_statement(
        &mut self, 
        node: SelectStatement<T>
    ) -> SelectStatement<T2> { ... }

    fn fold_set_expr(&mut self, node: SetExpr<T>) -> SetExpr<T2> { ... }

    fn fold_set_operator(&mut self, node: SetOperator) -> SetOperator { ... }

    fn fold_set_transaction_statement(
        &mut self, 
        node: SetTransactionStatement
    ) -> SetTransactionStatement { ... }

    fn fold_set_variable_statement(
        &mut self, 
        node: SetVariableStatement
    ) -> SetVariableStatement { ... }

    fn fold_set_variable_value(
        &mut self, 
        node: SetVariableValue
    ) -> SetVariableValue { ... }

    fn fold_show_columns_statement(
        &mut self, 
        node: ShowColumnsStatement<T>
    ) -> ShowColumnsStatement<T2> { ... }

    fn fold_show_create_index_statement(
        &mut self, 
        node: ShowCreateIndexStatement
    ) -> ShowCreateIndexStatement { ... }

    fn fold_show_create_sink_statement(
        &mut self, 
        node: ShowCreateSinkStatement
    ) -> ShowCreateSinkStatement { ... }

    fn fold_show_create_source_statement(
        &mut self, 
        node: ShowCreateSourceStatement
    ) -> ShowCreateSourceStatement { ... }

    fn fold_show_create_table_statement(
        &mut self, 
        node: ShowCreateTableStatement
    ) -> ShowCreateTableStatement { ... }

    fn fold_show_create_view_statement(
        &mut self, 
        node: ShowCreateViewStatement
    ) -> ShowCreateViewStatement { ... }

    fn fold_show_databases_statement(
        &mut self, 
        node: ShowDatabasesStatement<T>
    ) -> ShowDatabasesStatement<T2> { ... }

    fn fold_show_indexes_statement(
        &mut self, 
        node: ShowIndexesStatement<T>
    ) -> ShowIndexesStatement<T2> { ... }

    fn fold_show_objects_statement(
        &mut self, 
        node: ShowObjectsStatement<T>
    ) -> ShowObjectsStatement<T2> { ... }

    fn fold_show_statement_filter(
        &mut self, 
        node: ShowStatementFilter<T>
    ) -> ShowStatementFilter<T2> { ... }

    fn fold_show_variable_statement(
        &mut self, 
        node: ShowVariableStatement
    ) -> ShowVariableStatement { ... }

    fn fold_source_include_metadata(
        &mut self, 
        node: SourceIncludeMetadata
    ) -> SourceIncludeMetadata { ... }

    fn fold_source_include_metadata_type(
        &mut self, 
        node: SourceIncludeMetadataType
    ) -> SourceIncludeMetadataType { ... }

    fn fold_sql_option(&mut self, node: SqlOption<T>) -> SqlOption<T2> { ... }

    fn fold_start_transaction_statement(
        &mut self, 
        node: StartTransactionStatement
    ) -> StartTransactionStatement { ... }

    fn fold_statement(&mut self, node: Statement<T>) -> Statement<T2> { ... }

    fn fold_subscript_position(
        &mut self, 
        node: SubscriptPosition<T>
    ) -> SubscriptPosition<T2> { ... }

    fn fold_table_alias(&mut self, node: TableAlias) -> TableAlias { ... }

    fn fold_table_constraint(
        &mut self, 
        node: TableConstraint<T>
    ) -> TableConstraint<T2> { ... }

    fn fold_table_factor(&mut self, node: TableFactor<T>) -> TableFactor<T2> { ... }

    fn fold_table_function(
        &mut self, 
        node: TableFunction<T>
    ) -> TableFunction<T2> { ... }

    fn fold_table_with_joins(
        &mut self, 
        node: TableWithJoins<T>
    ) -> TableWithJoins<T2> { ... }

    fn fold_tail_relation(&mut self, node: TailRelation<T>) -> TailRelation<T2> { ... }

    fn fold_tail_statement(
        &mut self, 
        node: TailStatement<T>
    ) -> TailStatement<T2> { ... }

    fn fold_transaction_access_mode(
        &mut self, 
        node: TransactionAccessMode
    ) -> TransactionAccessMode { ... }

    fn fold_transaction_isolation_level(
        &mut self, 
        node: TransactionIsolationLevel
    ) -> TransactionIsolationLevel { ... }

    fn fold_transaction_mode(
        &mut self, 
        node: TransactionMode
    ) -> TransactionMode { ... }

    fn fold_unresolved_object_name(
        &mut self, 
        node: UnresolvedObjectName
    ) -> UnresolvedObjectName { ... }

    fn fold_update_statement(
        &mut self, 
        node: UpdateStatement<T>
    ) -> UpdateStatement<T2> { ... }

    fn fold_value(&mut self, node: Value) -> Value { ... }

    fn fold_value_error(&mut self, node: ValueError) -> ValueError { ... }

    fn fold_values(&mut self, node: Values<T>) -> Values<T2> { ... }

    fn fold_view_definition(
        &mut self, 
        node: ViewDefinition<T>
    ) -> ViewDefinition<T2> { ... }

    fn fold_window_frame(&mut self, node: WindowFrame) -> WindowFrame { ... }

    fn fold_window_frame_bound(
        &mut self, 
        node: WindowFrameBound
    ) -> WindowFrameBound { ... }

    fn fold_window_frame_units(
        &mut self, 
        node: WindowFrameUnits
    ) -> WindowFrameUnits { ... }

    fn fold_window_spec(&mut self, node: WindowSpec<T>) -> WindowSpec<T2> { ... }

    fn fold_with_option(&mut self, node: WithOption) -> WithOption { ... }

    fn fold_with_option_value(
        &mut self, 
        node: WithOptionValue
    ) -> WithOptionValue { ... }

}

Required methods

Provided methods

Implementors