Rolling back logical plan

Author: edmondop

datafusion/expr/src/logical_plan/builder.rs

@@ -342,9 +342,9 @@ impl LogicalPlanBuilder {
     }
 
     /// Apply a filter
-    pub fn filter(self, expr: impl Into<Expr>, default_selectivity:u8) -> Result<Self> {
+    pub fn filter(self, expr: impl Into<Expr>) -> Result<Self> {
         let expr = normalize_col(expr.into(), &self.plan)?;
-        Filter::try_new(expr, Arc::new(self.plan), default_selectivity)
+        Filter::try_new(expr, Arc::new(self.plan))
             .map(LogicalPlan::Filter)
             .map(Self::from)
     }
@@ -849,7 +849,7 @@ impl LogicalPlanBuilder {
             let join = Self::from(self.plan).cross_join(right)?;
             join.filter(filters.ok_or_else(|| {
                 DataFusionError::Internal("filters should not be None here".to_string())
-            })?, 20)
+            })?)
         } else {
             Ok(Self::from(LogicalPlan::Join(Join {
                 left: Arc::new(self.plan),

datafusion/expr/src/logical_plan/plan.rs

@@ -645,7 +645,7 @@ impl LogicalPlan {
                         .collect::<Vec<_>>(),
                 }))
             }
-            LogicalPlan::Filter(filter )=> {
+            LogicalPlan::Filter { .. } => {
                 assert_eq!(1, expr.len());
                 let predicate = expr.pop().unwrap();
 
@@ -687,7 +687,7 @@ impl LogicalPlan {
                 let mut remove_aliases = RemoveAliases {};
                 let predicate = predicate.rewrite(&mut remove_aliases)?;
 
-                Filter::try_new(predicate, Arc::new(inputs[0].clone()),filter.default_selectivity)
+                Filter::try_new(predicate, Arc::new(inputs[0].clone()))
                     .map(LogicalPlan::Filter)
             }
             LogicalPlan::Repartition(Repartition {
@@ -1887,13 +1887,11 @@ pub struct Filter {
     pub predicate: Expr,
     /// The incoming logical plan
     pub input: Arc<LogicalPlan>,
-    // Selectivity
-    pub default_selectivity: u8,
 }
 
 impl Filter {
     /// Create a new filter operator.
-    pub fn try_new(predicate: Expr, input: Arc<LogicalPlan>, default_selectivity: u8) -> Result<Self> {
+    pub fn try_new(predicate: Expr, input: Arc<LogicalPlan>) -> Result<Self> {
         // Filter predicates must return a boolean value so we try and validate that here.
         // Note that it is not always possible to resolve the predicate expression during plan
         // construction (such as with correlated subqueries) so we make a best effort here and
@@ -1914,10 +1912,8 @@ impl Filter {
                 aliased."
             );
         }
-        if default_selectivity > 100 {
-            return plan_err!("Filter Selectivity must be between 0 and 100");
-        }
-        Ok(Self { predicate, input, default_selectivity })
+
+        Ok(Self { predicate, input })
     }
 }