rename

Author: jackwener

datafusion/optimizer/src/eliminate_outer_join.rs

@@ -29,25 +29,17 @@ use datafusion_expr::expr::Cast;
 use std::sync::Arc;
 
 #[derive(Default)]
-pub struct ReduceOuterJoin;
+pub struct EliminateOuterJoin;
 
-impl ReduceOuterJoin {
+impl EliminateOuterJoin {
     #[allow(missing_docs)]
     pub fn new() -> Self {
         Self {}
     }
 }
 
-/// Attempt to eliminate outer joins to inner joins.
-/// for query: select ... from a left join b on ... where b.xx = 100;
-/// if b.xx is null, and b.xx = 100 returns false, filtered those null rows.
-/// Therefore, there is no need to produce null rows for output, we can use
-/// inner join instead of left join.
-///
-/// Generally, an outer join can be eliminated to inner join if equals from where
-/// return false while any inputs are null and columns of those equals are come from
-/// nullable side of outer join.
-impl OptimizerRule for ReduceOuterJoin {
+/// Attempt to eliminate outer joins.
+impl OptimizerRule for EliminateOuterJoin {
     fn optimize(
         &self,
         plan: &LogicalPlan,
@@ -56,36 +48,35 @@ impl OptimizerRule for ReduceOuterJoin {
         match plan {
             LogicalPlan::Filter(filter) => match filter.input().as_ref() {
                 LogicalPlan::Join(join) => {
-                    let mut nonnullable_cols: Vec<Column> = vec![];
+                    let mut non_nullable_cols: Vec<Column> = vec![];
 
-                    extract_nonnullable_columns(
+                    extract_non_nullable_columns(
                         filter.predicate(),
-                        &mut nonnullable_cols,
+                        &mut non_nullable_cols,
                         join.left.schema(),
                         join.right.schema(),
                         true,
                     )?;
 
                     let new_join_type = if join.join_type.is_outer() {
-                        let mut left_nonnullable = false;
-                        let mut right_nonnullable = false;
-                        for col in nonnullable_cols.iter() {
+                        let mut left_non_nullable = false;
+                        let mut right_non_nullable = false;
+                        for col in non_nullable_cols.iter() {
                             if join.left.schema().field_from_column(col).is_ok() {
-                                left_nonnullable = true;
+                                left_non_nullable = true;
                             }
                             if join.right.schema().field_from_column(col).is_ok() {
-                                right_nonnullable = true;
+                                right_non_nullable = true;
                             }
                         }
                         eliminate_outer(
                             join.join_type,
-                            left_nonnullable,
-                            right_nonnullable,
+                            left_non_nullable,
+                            right_non_nullable,
                         )
                     } else {
                         join.join_type
                     };
-
                     let new_join = LogicalPlan::Join(Join {
                         left: Arc::new((*join.left).clone()),
                         right: Arc::new((*join.right).clone()),
@@ -112,27 +103,27 @@ impl OptimizerRule for ReduceOuterJoin {
 
 pub fn eliminate_outer(
     join_type: JoinType,
-    left_nonnullable: bool,
-    right_nonnullable: bool,
+    left_non_nullable: bool,
+    right_non_nullable: bool,
 ) -> JoinType {
     let mut new_join_type = join_type;
     match join_type {
         JoinType::Left => {
-            if right_nonnullable {
+            if right_non_nullable {
                 new_join_type = JoinType::Inner;
             }
         }
         JoinType::Right => {
-            if left_nonnullable {
+            if left_non_nullable {
                 new_join_type = JoinType::Inner;
             }
         }
         JoinType::Full => {
-            if left_nonnullable && right_nonnullable {
+            if left_non_nullable && right_non_nullable {
                 new_join_type = JoinType::Inner;
-            } else if left_nonnullable {
+            } else if left_non_nullable {
                 new_join_type = JoinType::Left;
-            } else if right_nonnullable {
+            } else if right_non_nullable {
                 new_join_type = JoinType::Right;
             }
         }
@@ -142,23 +133,23 @@ pub fn eliminate_outer(
 }
 
 /// Recursively traverses expr, if expr returns false when
-/// any inputs are null, treats columns of both sides as nonnullable columns.
+/// any inputs are null, treats columns of both sides as non_nullable columns.
 ///
 /// For and/or expr, extracts from all sub exprs and merges the columns.
 /// For or expr, if one of sub exprs returns true, discards all columns from or expr.
 /// For IS NOT NULL/NOT expr, always returns false for NULL input.
 ///     extracts columns from these exprs.
 /// For all other exprs, fall through
-fn extract_nonnullable_columns(
+fn extract_non_nullable_columns(
     expr: &Expr,
-    nonnullable_cols: &mut Vec<Column>,
+    non_nullable_cols: &mut Vec<Column>,
     left_schema: &Arc<DFSchema>,
     right_schema: &Arc<DFSchema>,
     top_level: bool,
 ) -> Result<()> {
     match expr {
         Expr::Column(col) => {
-            nonnullable_cols.push(col.clone());
+            non_nullable_cols.push(col.clone());
             Ok(())
         }
         Expr::BinaryExpr(BinaryExpr { left, op, right }) => match op {
@@ -169,16 +160,16 @@ fn extract_nonnullable_columns(
             | Operator::LtEq
             | Operator::Gt
             | Operator::GtEq => {
-                extract_nonnullable_columns(
+                extract_non_nullable_columns(
                     left,
-                    nonnullable_cols,
+                    non_nullable_cols,
                     left_schema,
                     right_schema,
                     false,
                 )?;
-                extract_nonnullable_columns(
+                extract_non_nullable_columns(
                     right,
-                    nonnullable_cols,
+                    non_nullable_cols,
                     left_schema,
                     right_schema,
                     false,
@@ -188,36 +179,36 @@ fn extract_nonnullable_columns(
                 // treat And as Or if does not from top level, such as
                 // not (c1 < 10 and c2 > 100)
                 if top_level && *op == Operator::And {
-                    extract_nonnullable_columns(
+                    extract_non_nullable_columns(
                         left,
-                        nonnullable_cols,
+                        non_nullable_cols,
                         left_schema,
                         right_schema,
                         top_level,
                     )?;
-                    extract_nonnullable_columns(
+                    extract_non_nullable_columns(
                         right,
-                        nonnullable_cols,
+                        non_nullable_cols,
                         left_schema,
                         right_schema,
                         top_level,
                     )?;
                     return Ok(());
                 }
 
-                let mut left_nonnullable_cols: Vec<Column> = vec![];
-                let mut right_nonnullable_cols: Vec<Column> = vec![];
+                let mut left_non_nullable_cols: Vec<Column> = vec![];
+                let mut right_non_nullable_cols: Vec<Column> = vec![];
 
-                extract_nonnullable_columns(
+                extract_non_nullable_columns(
                     left,
-                    &mut left_nonnullable_cols,
+                    &mut left_non_nullable_cols,
                     left_schema,
                     right_schema,
                     top_level,
                 )?;
-                extract_nonnullable_columns(
+                extract_non_nullable_columns(
                     right,
-                    &mut right_nonnullable_cols,
+                    &mut right_non_nullable_cols,
                     left_schema,
                     right_schema,
                     top_level,
@@ -229,16 +220,17 @@ fn extract_nonnullable_columns(
                 // this can not be eliminated.
                 // If columns of relation exist in both sub exprs, any columns of this relation
                 // can be added to non nullable columns.
-                if !left_nonnullable_cols.is_empty() && !right_nonnullable_cols.is_empty()
+                if !left_non_nullable_cols.is_empty()
+                    && !right_non_nullable_cols.is_empty()
                 {
-                    for left_col in &left_nonnullable_cols {
-                        for right_col in &right_nonnullable_cols {
+                    for left_col in &left_non_nullable_cols {
+                        for right_col in &right_non_nullable_cols {
                             if (left_schema.field_from_column(left_col).is_ok()
                                 && left_schema.field_from_column(right_col).is_ok())
                                 || (right_schema.field_from_column(left_col).is_ok()
                                     && right_schema.field_from_column(right_col).is_ok())
                             {
-                                nonnullable_cols.push(left_col.clone());
+                                non_nullable_cols.push(left_col.clone());
                                 break;
                             }
                         }
@@ -248,9 +240,9 @@ fn extract_nonnullable_columns(
             }
             _ => Ok(()),
         },
-        Expr::Not(arg) => extract_nonnullable_columns(
+        Expr::Not(arg) => extract_non_nullable_columns(
             arg,
-            nonnullable_cols,
+            non_nullable_cols,
             left_schema,
             right_schema,
             false,
@@ -259,18 +251,18 @@ fn extract_nonnullable_columns(
             if !top_level {
                 return Ok(());
             }
-            extract_nonnullable_columns(
+            extract_non_nullable_columns(
                 arg,
-                nonnullable_cols,
+                non_nullable_cols,
                 left_schema,
                 right_schema,
                 false,
             )
         }
         Expr::Cast(Cast { expr, data_type: _ })
-        | Expr::TryCast { expr, data_type: _ } => extract_nonnullable_columns(
+        | Expr::TryCast { expr, data_type: _ } => extract_non_nullable_columns(
             expr,
-            nonnullable_cols,
+            non_nullable_cols,
             left_schema,
             right_schema,
             false,
@@ -292,7 +284,7 @@ mod tests {
     };
 
     fn assert_optimized_plan_eq(plan: &LogicalPlan, expected: &str) {
-        let rule = ReduceOuterJoin::new();
+        let rule = EliminateOuterJoin::new();
         let optimized_plan = rule
             .optimize(plan, &mut OptimizerConfig::new())
             .expect("failed to optimize plan");

datafusion/optimizer/src/optimizer.rs

@@ -22,7 +22,7 @@ use crate::decorrelate_where_exists::DecorrelateWhereExists;
 use crate::decorrelate_where_in::DecorrelateWhereIn;
 use crate::eliminate_filter::EliminateFilter;
 use crate::eliminate_limit::EliminateLimit;
-use crate::eliminate_outer_join::ReduceOuterJoin;
+use crate::eliminate_outer_join::EliminateOuterJoin;
 use crate::filter_null_join_keys::FilterNullJoinKeys;
 use crate::filter_push_down::FilterPushDown;
 use crate::inline_table_scan::InlineTableScan;
@@ -183,7 +183,7 @@ impl Optimizer {
         if config.filter_null_keys {
             rules.push(Arc::new(FilterNullJoinKeys::default()));
         }
-        rules.push(Arc::new(ReduceOuterJoin::new()));
+        rules.push(Arc::new(EliminateOuterJoin::new()));
         rules.push(Arc::new(FilterPushDown::new()));
         rules.push(Arc::new(LimitPushDown::new()));
         rules.push(Arc::new(SingleDistinctToGroupBy::new()));