risingwave_frontend::optimizer::plan_rewriter

Trait PlanRewriter

Help

pub trait PlanRewriter {
Show 110 methods    // Required methods
    fn rewrite_logical_share(&mut self, plan: &LogicalShare) -> PlanRef;
    fn rewrite_stream_share(&mut self, plan: &StreamShare) -> PlanRef;

    // Provided methods
    fn rewrite(&mut self, plan: PlanRef) -> PlanRef { ... }
    fn rewrite_logical_agg(&mut self, plan: &LogicalAgg) -> PlanRef { ... }
    fn rewrite_logical_apply(&mut self, plan: &LogicalApply) -> PlanRef { ... }
    fn rewrite_logical_filter(&mut self, plan: &LogicalFilter) -> PlanRef { ... }
    fn rewrite_logical_project(&mut self, plan: &LogicalProject) -> PlanRef { ... }
    fn rewrite_logical_scan(&mut self, plan: &LogicalScan) -> PlanRef { ... }
    fn rewrite_logical_cdc_scan(&mut self, plan: &LogicalCdcScan) -> PlanRef { ... }
    fn rewrite_logical_sys_scan(&mut self, plan: &LogicalSysScan) -> PlanRef { ... }
    fn rewrite_logical_source(&mut self, plan: &LogicalSource) -> PlanRef { ... }
    fn rewrite_logical_insert(&mut self, plan: &LogicalInsert) -> PlanRef { ... }
    fn rewrite_logical_delete(&mut self, plan: &LogicalDelete) -> PlanRef { ... }
    fn rewrite_logical_update(&mut self, plan: &LogicalUpdate) -> PlanRef { ... }
    fn rewrite_logical_join(&mut self, plan: &LogicalJoin) -> PlanRef { ... }
    fn rewrite_logical_values(&mut self, plan: &LogicalValues) -> PlanRef { ... }
    fn rewrite_logical_limit(&mut self, plan: &LogicalLimit) -> PlanRef { ... }
    fn rewrite_logical_top_n(&mut self, plan: &LogicalTopN) -> PlanRef { ... }
    fn rewrite_logical_hop_window(&mut self, plan: &LogicalHopWindow) -> PlanRef { ... }
    fn rewrite_logical_table_function(
        &mut self,
        plan: &LogicalTableFunction,
    ) -> PlanRef { ... }
    fn rewrite_logical_multi_join(&mut self, plan: &LogicalMultiJoin) -> PlanRef { ... }
    fn rewrite_logical_expand(&mut self, plan: &LogicalExpand) -> PlanRef { ... }
    fn rewrite_logical_project_set(
        &mut self,
        plan: &LogicalProjectSet,
    ) -> PlanRef { ... }
    fn rewrite_logical_union(&mut self, plan: &LogicalUnion) -> PlanRef { ... }
    fn rewrite_logical_over_window(
        &mut self,
        plan: &LogicalOverWindow,
    ) -> PlanRef { ... }
    fn rewrite_logical_now(&mut self, plan: &LogicalNow) -> PlanRef { ... }
    fn rewrite_logical_dedup(&mut self, plan: &LogicalDedup) -> PlanRef { ... }
    fn rewrite_logical_intersect(&mut self, plan: &LogicalIntersect) -> PlanRef { ... }
    fn rewrite_logical_except(&mut self, plan: &LogicalExcept) -> PlanRef { ... }
    fn rewrite_logical_max_one_row(
        &mut self,
        plan: &LogicalMaxOneRow,
    ) -> PlanRef { ... }
    fn rewrite_logical_kafka_scan(&mut self, plan: &LogicalKafkaScan) -> PlanRef { ... }
    fn rewrite_logical_iceberg_scan(
        &mut self,
        plan: &LogicalIcebergScan,
    ) -> PlanRef { ... }
    fn rewrite_logical_recursive_union(
        &mut self,
        plan: &LogicalRecursiveUnion,
    ) -> PlanRef { ... }
    fn rewrite_logical_cte_ref(&mut self, plan: &LogicalCteRef) -> PlanRef { ... }
    fn rewrite_logical_change_log(&mut self, plan: &LogicalChangeLog) -> PlanRef { ... }
    fn rewrite_logical_file_scan(&mut self, plan: &LogicalFileScan) -> PlanRef { ... }
    fn rewrite_logical_postgres_query(
        &mut self,
        plan: &LogicalPostgresQuery,
    ) -> PlanRef { ... }
    fn rewrite_logical_my_sql_query(
        &mut self,
        plan: &LogicalMySqlQuery,
    ) -> PlanRef { ... }
    fn rewrite_batch_simple_agg(&mut self, plan: &BatchSimpleAgg) -> PlanRef { ... }
    fn rewrite_batch_hash_agg(&mut self, plan: &BatchHashAgg) -> PlanRef { ... }
    fn rewrite_batch_sort_agg(&mut self, plan: &BatchSortAgg) -> PlanRef { ... }
    fn rewrite_batch_project(&mut self, plan: &BatchProject) -> PlanRef { ... }
    fn rewrite_batch_filter(&mut self, plan: &BatchFilter) -> PlanRef { ... }
    fn rewrite_batch_insert(&mut self, plan: &BatchInsert) -> PlanRef { ... }
    fn rewrite_batch_delete(&mut self, plan: &BatchDelete) -> PlanRef { ... }
    fn rewrite_batch_update(&mut self, plan: &BatchUpdate) -> PlanRef { ... }
    fn rewrite_batch_seq_scan(&mut self, plan: &BatchSeqScan) -> PlanRef { ... }
    fn rewrite_batch_sys_seq_scan(&mut self, plan: &BatchSysSeqScan) -> PlanRef { ... }
    fn rewrite_batch_log_seq_scan(&mut self, plan: &BatchLogSeqScan) -> PlanRef { ... }
    fn rewrite_batch_hash_join(&mut self, plan: &BatchHashJoin) -> PlanRef { ... }
    fn rewrite_batch_nested_loop_join(
        &mut self,
        plan: &BatchNestedLoopJoin,
    ) -> PlanRef { ... }
    fn rewrite_batch_values(&mut self, plan: &BatchValues) -> PlanRef { ... }
    fn rewrite_batch_sort(&mut self, plan: &BatchSort) -> PlanRef { ... }
    fn rewrite_batch_exchange(&mut self, plan: &BatchExchange) -> PlanRef { ... }
    fn rewrite_batch_limit(&mut self, plan: &BatchLimit) -> PlanRef { ... }
    fn rewrite_batch_top_n(&mut self, plan: &BatchTopN) -> PlanRef { ... }
    fn rewrite_batch_hop_window(&mut self, plan: &BatchHopWindow) -> PlanRef { ... }
    fn rewrite_batch_table_function(
        &mut self,
        plan: &BatchTableFunction,
    ) -> PlanRef { ... }
    fn rewrite_batch_expand(&mut self, plan: &BatchExpand) -> PlanRef { ... }
    fn rewrite_batch_lookup_join(&mut self, plan: &BatchLookupJoin) -> PlanRef { ... }
    fn rewrite_batch_project_set(&mut self, plan: &BatchProjectSet) -> PlanRef { ... }
    fn rewrite_batch_union(&mut self, plan: &BatchUnion) -> PlanRef { ... }
    fn rewrite_batch_group_top_n(&mut self, plan: &BatchGroupTopN) -> PlanRef { ... }
    fn rewrite_batch_source(&mut self, plan: &BatchSource) -> PlanRef { ... }
    fn rewrite_batch_over_window(&mut self, plan: &BatchOverWindow) -> PlanRef { ... }
    fn rewrite_batch_max_one_row(&mut self, plan: &BatchMaxOneRow) -> PlanRef { ... }
    fn rewrite_batch_kafka_scan(&mut self, plan: &BatchKafkaScan) -> PlanRef { ... }
    fn rewrite_batch_iceberg_scan(&mut self, plan: &BatchIcebergScan) -> PlanRef { ... }
    fn rewrite_batch_file_scan(&mut self, plan: &BatchFileScan) -> PlanRef { ... }
    fn rewrite_batch_postgres_query(
        &mut self,
        plan: &BatchPostgresQuery,
    ) -> PlanRef { ... }
    fn rewrite_batch_my_sql_query(&mut self, plan: &BatchMySqlQuery) -> PlanRef { ... }
    fn rewrite_stream_project(&mut self, plan: &StreamProject) -> PlanRef { ... }
    fn rewrite_stream_filter(&mut self, plan: &StreamFilter) -> PlanRef { ... }
    fn rewrite_stream_table_scan(&mut self, plan: &StreamTableScan) -> PlanRef { ... }
    fn rewrite_stream_cdc_table_scan(
        &mut self,
        plan: &StreamCdcTableScan,
    ) -> PlanRef { ... }
    fn rewrite_stream_sink(&mut self, plan: &StreamSink) -> PlanRef { ... }
    fn rewrite_stream_source(&mut self, plan: &StreamSource) -> PlanRef { ... }
    fn rewrite_stream_source_scan(&mut self, plan: &StreamSourceScan) -> PlanRef { ... }
    fn rewrite_stream_hash_join(&mut self, plan: &StreamHashJoin) -> PlanRef { ... }
    fn rewrite_stream_exchange(&mut self, plan: &StreamExchange) -> PlanRef { ... }
    fn rewrite_stream_hash_agg(&mut self, plan: &StreamHashAgg) -> PlanRef { ... }
    fn rewrite_stream_simple_agg(&mut self, plan: &StreamSimpleAgg) -> PlanRef { ... }
    fn rewrite_stream_stateless_simple_agg(
        &mut self,
        plan: &StreamStatelessSimpleAgg,
    ) -> PlanRef { ... }
    fn rewrite_stream_materialize(
        &mut self,
        plan: &StreamMaterialize,
    ) -> PlanRef { ... }
    fn rewrite_stream_top_n(&mut self, plan: &StreamTopN) -> PlanRef { ... }
    fn rewrite_stream_hop_window(&mut self, plan: &StreamHopWindow) -> PlanRef { ... }
    fn rewrite_stream_delta_join(&mut self, plan: &StreamDeltaJoin) -> PlanRef { ... }
    fn rewrite_stream_expand(&mut self, plan: &StreamExpand) -> PlanRef { ... }
    fn rewrite_stream_dynamic_filter(
        &mut self,
        plan: &StreamDynamicFilter,
    ) -> PlanRef { ... }
    fn rewrite_stream_project_set(&mut self, plan: &StreamProjectSet) -> PlanRef { ... }
    fn rewrite_stream_group_top_n(&mut self, plan: &StreamGroupTopN) -> PlanRef { ... }
    fn rewrite_stream_union(&mut self, plan: &StreamUnion) -> PlanRef { ... }
    fn rewrite_stream_row_id_gen(&mut self, plan: &StreamRowIdGen) -> PlanRef { ... }
    fn rewrite_stream_dml(&mut self, plan: &StreamDml) -> PlanRef { ... }
    fn rewrite_stream_now(&mut self, plan: &StreamNow) -> PlanRef { ... }
    fn rewrite_stream_watermark_filter(
        &mut self,
        plan: &StreamWatermarkFilter,
    ) -> PlanRef { ... }
    fn rewrite_stream_temporal_join(
        &mut self,
        plan: &StreamTemporalJoin,
    ) -> PlanRef { ... }
    fn rewrite_stream_values(&mut self, plan: &StreamValues) -> PlanRef { ... }
    fn rewrite_stream_dedup(&mut self, plan: &StreamDedup) -> PlanRef { ... }
    fn rewrite_stream_eowc_over_window(
        &mut self,
        plan: &StreamEowcOverWindow,
    ) -> PlanRef { ... }
    fn rewrite_stream_eowc_sort(&mut self, plan: &StreamEowcSort) -> PlanRef { ... }
    fn rewrite_stream_over_window(&mut self, plan: &StreamOverWindow) -> PlanRef { ... }
    fn rewrite_stream_fs_fetch(&mut self, plan: &StreamFsFetch) -> PlanRef { ... }
    fn rewrite_stream_change_log(&mut self, plan: &StreamChangeLog) -> PlanRef { ... }
    fn rewrite_stream_global_approx_percentile(
        &mut self,
        plan: &StreamGlobalApproxPercentile,
    ) -> PlanRef { ... }
    fn rewrite_stream_local_approx_percentile(
        &mut self,
        plan: &StreamLocalApproxPercentile,
    ) -> PlanRef { ... }
    fn rewrite_stream_row_merge(&mut self, plan: &StreamRowMerge) -> PlanRef { ... }
    fn rewrite_stream_as_of_join(&mut self, plan: &StreamAsOfJoin) -> PlanRef { ... }
    fn rewrite_stream_sync_log_store(
        &mut self,
        plan: &StreamSyncLogStore,
    ) -> PlanRef { ... }
    fn rewrite_stream_materialized_exprs(
        &mut self,
        plan: &StreamMaterializedExprs,
    ) -> PlanRef { ... }
}

Expand description

it’s kind of like a PlanVisitor<PlanRef>, but with default behaviour of each rewrite method

Required Methods§

Source

fn rewrite_logical_share(&mut self, plan: &LogicalShare) -> PlanRef

When we use the plan rewriter, we need to take care of the share operator, because our plan is a DAG rather than a tree. Make sure this method can keep the shape of DAG.

Source

fn rewrite_stream_share(&mut self, plan: &StreamShare) -> PlanRef

When we use the plan rewriter, we need to take care of the share operator, because our plan is a DAG rather than a tree. Make sure this method can keep the shape of DAG.