query/optimizer/
merge_scan_projection.rs1use 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 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 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}