Skip to main content

query/optimizer/
merge_scan_projection.rs

1// Copyright 2023 Greptime Team
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7//     http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15use datafusion_common::Result;
16use datafusion_common::tree_node::Transformed;
17use datafusion_expr::{Expr, LogicalPlan, LogicalPlanBuilder};
18use datafusion_optimizer::optimizer::ApplyOrder;
19use datafusion_optimizer::{OptimizerConfig, OptimizerRule};
20
21use crate::dist_plan::MergeScanLogicalPlan;
22
23#[derive(Debug)]
24pub(crate) struct MergeScanProjection;
25
26impl OptimizerRule for MergeScanProjection {
27    fn name(&self) -> &str {
28        "merge_scan_projection"
29    }
30
31    fn apply_order(&self) -> Option<ApplyOrder> {
32        Some(ApplyOrder::BottomUp)
33    }
34
35    fn rewrite(
36        &self,
37        plan: LogicalPlan,
38        _config: &dyn OptimizerConfig,
39    ) -> Result<Transformed<LogicalPlan>> {
40        let LogicalPlan::Projection(projection) = &plan else {
41            return Ok(Transformed::no(plan));
42        };
43        // Remote batches do not yet preserve the row count of empty projections.
44        if projection.expr.is_empty()
45            || !projection
46                .expr
47                .iter()
48                .all(|expr| matches!(expr, Expr::Column(_)))
49        {
50            return Ok(Transformed::no(plan));
51        }
52        let LogicalPlan::Extension(extension) = projection.input.as_ref() else {
53            return Ok(Transformed::no(plan));
54        };
55        let Some(scan) = extension
56            .node
57            .as_any()
58            .downcast_ref::<MergeScanLogicalPlan>()
59        else {
60            return Ok(Transformed::no(plan));
61        };
62        if scan.is_placeholder() {
63            return Ok(Transformed::no(plan));
64        }
65        // Project after the remote subtree, preserving its sort, limit, and aggregation scope.
66        let remote = LogicalPlanBuilder::from(scan.input().clone())
67            .project(projection.expr.clone())?
68            .build()?;
69        let mut projected =
70            MergeScanLogicalPlan::new(remote, false).with_output_schema(projection.schema.clone());
71        if let Some(id) = scan.remote_dyn_filter_producer_id() {
72            projected = projected.with_remote_dyn_filter_producer_id(id);
73        }
74        Ok(Transformed::yes(projected.into_logical_plan()))
75    }
76}
77
78#[cfg(test)]
79mod tests {
80    use datafusion_expr::{col, lit};
81    use datafusion_optimizer::optimizer::OptimizerContext;
82
83    use super::*;
84
85    #[test]
86    fn projects_remote_columns_without_changing_limit_scope() {
87        let input = LogicalPlanBuilder::values(vec![vec![lit(1), lit(2)]])
88            .unwrap()
89            .limit(0, Some(1))
90            .unwrap()
91            .build()
92            .unwrap();
93        let producer = crate::dist_plan::RemoteDynFilterProducerId::new(42);
94        let scan = MergeScanLogicalPlan::new(input.clone(), false)
95            .with_remote_dyn_filter_producer_id(producer);
96        let plan = LogicalPlanBuilder::from(scan.into_logical_plan())
97            .project(vec![col("column2")])
98            .unwrap()
99            .build()
100            .unwrap();
101        let schema = plan.schema().clone();
102        let result = MergeScanProjection
103            .rewrite(plan, &OptimizerContext::new())
104            .unwrap();
105        assert!(result.transformed);
106        assert_eq!(result.data.schema(), &schema);
107        let LogicalPlan::Extension(extension) = result.data else {
108            panic!("expected MergeScan")
109        };
110        let scan = extension
111            .node
112            .as_any()
113            .downcast_ref::<MergeScanLogicalPlan>()
114            .unwrap();
115        assert_eq!(scan.remote_dyn_filter_producer_id(), Some(producer));
116        let LogicalPlan::Projection(projection) = scan.input() else {
117            panic!("expected remote projection")
118        };
119        assert_eq!(projection.expr, vec![col("column2")]);
120        assert_eq!(*projection.input, input);
121    }
122
123    #[test]
124    fn keeps_computed_expressions_local() {
125        let input = LogicalPlanBuilder::values(vec![vec![lit(1), lit(2)]])
126            .unwrap()
127            .build()
128            .unwrap();
129        let plan =
130            LogicalPlanBuilder::from(MergeScanLogicalPlan::new(input, false).into_logical_plan())
131                .project(vec![col("column2") + lit(1)])
132                .unwrap()
133                .build()
134                .unwrap();
135        let result = MergeScanProjection
136            .rewrite(plan.clone(), &OptimizerContext::new())
137            .unwrap();
138        assert!(!result.transformed);
139        assert_eq!(result.data, plan);
140    }
141}