diff --git a/core/translate/optimizer.rs b/core/translate/optimizer.rs
index 9ccd8e7f7..9e93b1d71 100644
--- a/core/translate/optimizer.rs
+++ b/core/translate/optimizer.rs
@@ -9,58 +9,58 @@ use super::plan::{
     Direction, IterationDirection, Plan, Search, SourceOperator,
 };
 
-pub fn optimize_select_plan(plan: Plan) -> Result<Plan> {
-    optimize_plan(plan, true, true, true)
-}
-
-pub fn optimize_delete_plan(plan: Plan) -> Result<Plan> {
-    optimize_plan(plan, false, true, false)
-}
-
 /**
  * Make a few passes over the plan to optimize it.
  * TODO: these could probably be done in less passes,
  * but having them separate makes them easier to understand
  */
-fn optimize_plan(
-    mut select_plan: Plan,
-    optimize_push_predicates: bool,
-    optimize_use_indexes: bool,
-    optimize_eliminate_unnecessary_order_by: bool,
-) -> Result<Plan> {
-    eliminate_between(&mut select_plan.source, &mut select_plan.where_clause)?;
+pub fn optimize_select_plan(mut plan: Plan) -> Result<Plan> {
+    eliminate_between(&mut plan.source, &mut plan.where_clause)?;
     if let ConstantConditionEliminationResult::ImpossibleCondition =
-        eliminate_constants(&mut select_plan.source, &mut select_plan.where_clause)?
+        eliminate_constants(&mut plan.source, &mut plan.where_clause)?
     {
-        select_plan.contains_constant_false_condition = true;
-        return Ok(select_plan);
+        plan.contains_constant_false_condition = true;
+        return Ok(plan);
     }
 
-    if optimize_push_predicates {
-        push_predicates(
-            &mut select_plan.source,
-            &mut select_plan.where_clause,
-            &select_plan.referenced_tables,
-        )?;
+    push_predicates(
+        &mut plan.source,
+        &mut plan.where_clause,
+        &plan.referenced_tables,
+    )?;
+
+    use_indexes(
+        &mut plan.source,
+        &plan.referenced_tables,
+        &plan.available_indexes,
+    )?;
+
+    eliminate_unnecessary_orderby(
+        &mut plan.source,
+        &mut plan.order_by,
+        &plan.referenced_tables,
+        &plan.available_indexes,
+    )?;
+
+    Ok(plan)
+}
+
+pub fn optimize_delete_plan(mut plan: Plan) -> Result<Plan> {
+    eliminate_between(&mut plan.source, &mut plan.where_clause)?;
+    if let ConstantConditionEliminationResult::ImpossibleCondition =
+        eliminate_constants(&mut plan.source, &mut plan.where_clause)?
+    {
+        plan.contains_constant_false_condition = true;
+        return Ok(plan);
     }
 
-    if optimize_use_indexes {
-        use_indexes(
-            &mut select_plan.source,
-            &select_plan.referenced_tables,
-            &select_plan.available_indexes,
-        )?;
-    }
+    use_indexes(
+        &mut plan.source,
+        &plan.referenced_tables,
+        &plan.available_indexes,
+    )?;
 
-    if optimize_eliminate_unnecessary_order_by {
-        eliminate_unnecessary_orderby(
-            &mut select_plan.source,
-            &mut select_plan.order_by,
-            &select_plan.referenced_tables,
-            &select_plan.available_indexes,
-        )?;
-    }
-    Ok(select_plan)
+    Ok(plan)
 }
 
 fn _operator_is_already_ordered_by(