chore: make cargo clippy happy in nigtly (#2860)

datafusion/core/src/datasource/mod.rs

@@ -114,7 +114,7 @@ pub async fn get_statistics_with_limit(
 
     let column_stats = if has_statistics {
         Some(get_col_stats(
-            &*file_schema,
+            &file_schema,
             null_counts,
             &mut max_values,
             &mut min_values,

datafusion/core/src/execution/memory_manager.rs

@@ -303,10 +303,12 @@ impl MemoryManager {
                         None
                     }
                 });
-        update.expect(&*format!(
-            "Tracker total memory shrink by {} underflow, current value is ",
-            delta
-        ));
+        update.unwrap_or_else(|_| {
+            panic!(
+                "Tracker total memory shrink by {} underflow, current value is ",
+                delta
+            )
+        });
     }
 
     /// Return the total memory usage for all requesters

datafusion/core/src/physical_optimizer/hash_build_probe_order.rs

@@ -167,7 +167,7 @@ impl PhysicalOptimizerRule for HashBuildProbeOrder {
                     hash_join.null_equals_null(),
                 )?;
                 let proj = ProjectionExec::try_new(
-                    swap_reverting_projection(&*left.schema(), &*right.schema()),
+                    swap_reverting_projection(&left.schema(), &right.schema()),
                     Arc::new(new_join),
                 )?;
                 return Ok(Arc::new(proj));
@@ -179,7 +179,7 @@ impl PhysicalOptimizerRule for HashBuildProbeOrder {
                 let new_join =
                     CrossJoinExec::try_new(Arc::clone(right), Arc::clone(left))?;
                 let proj = ProjectionExec::try_new(
-                    swap_reverting_projection(&*left.schema(), &*right.schema()),
+                    swap_reverting_projection(&left.schema(), &right.schema()),
                     Arc::new(new_join),
                 )?;
                 return Ok(Arc::new(proj));

datafusion/core/src/physical_plan/sorts/sort.rs

@@ -144,7 +144,7 @@ impl ExternalSorter {
             let mut streams: Vec<SortedStream> = vec![];
             if in_mem_batches.len() > 0 {
                 let in_mem_stream = in_mem_partial_sort(
-                    &mut *in_mem_batches,
+                    &mut in_mem_batches,
                     self.schema.clone(),
                     &self.expr,
                     batch_size,
@@ -175,7 +175,7 @@ impl ExternalSorter {
                 .metrics_set
                 .new_final_tracking(partition, self.runtime.clone());
             let result = in_mem_partial_sort(
-                &mut *in_mem_batches,
+                &mut in_mem_batches,
                 self.schema.clone(),
                 &self.expr,
                 batch_size,
@@ -265,9 +265,9 @@ impl MemoryConsumer for ExternalSorter {
 
         let spillfile = self.runtime.disk_manager.create_tmp_file()?;
         let stream = in_mem_partial_sort(
-            &mut *in_mem_batches,
+            &mut in_mem_batches,
             self.schema.clone(),
-            &*self.expr,
+            &self.expr,
             self.session_config.batch_size(),
             tracking_metrics,
         );

datafusion/optimizer/src/subquery_filter_to_join.rs

@@ -96,7 +96,7 @@ impl OptimizerRule for SubqueryFilterToJoin {
                             negated,
                         } => {
                             let right_input = self.optimize(
-                                &*subquery.subquery,
+                                &subquery.subquery,
                                 optimizer_config
                             )?;
                             let right_schema = right_input.schema();

datafusion/physical-expr/src/expressions/case.rs

@@ -118,7 +118,7 @@ impl CaseExpr {
     ///     [ELSE result]
     /// END
     fn case_when_with_expr(&self, batch: &RecordBatch) -> Result<ColumnarValue> {
-        let return_type = self.data_type(&*batch.schema())?;
+        let return_type = self.data_type(&batch.schema())?;
         let expr = self.expr.as_ref().unwrap();
         let base_value = expr.evaluate(batch)?;
         let base_value = base_value.into_array(batch.num_rows());
@@ -154,7 +154,7 @@ impl CaseExpr {
 
         if let Some(e) = &self.else_expr {
             // keep `else_expr`'s data type and return type consistent
-            let expr = try_cast(e.clone(), &*batch.schema(), return_type.clone())
+            let expr = try_cast(e.clone(), &batch.schema(), return_type.clone())
                 .unwrap_or_else(|_| e.clone());
             // null and unmatched tuples should be assigned else value
             remainder = or(&base_nulls, &remainder)?;
@@ -175,7 +175,7 @@ impl CaseExpr {
     ///      [ELSE result]
     /// END
     fn case_when_no_expr(&self, batch: &RecordBatch) -> Result<ColumnarValue> {
-        let return_type = self.data_type(&*batch.schema())?;
+        let return_type = self.data_type(&batch.schema())?;
 
         // start with nulls as default output
         let mut current_value = new_null_array(&return_type, batch.num_rows());
@@ -220,7 +220,7 @@ impl CaseExpr {
 
         if let Some(e) = &self.else_expr {
             // keep `else_expr`'s data type and return type consistent
-            let expr = try_cast(e.clone(), &*batch.schema(), return_type.clone())
+            let expr = try_cast(e.clone(), &batch.schema(), return_type.clone())
                 .unwrap_or_else(|_| e.clone());
             let else_ = expr
                 .evaluate_selection(batch, &remainder)?

datafusion/sql/src/utils.rs

@@ -201,7 +201,7 @@ where
                     .collect::<Result<Vec<Expr>>>()?,
             }),
             Expr::Alias(nested_expr, alias_name) => Ok(Expr::Alias(
-                Box::new(clone_with_replacement(&**nested_expr, replacement_fn)?),
+                Box::new(clone_with_replacement(nested_expr, replacement_fn)?),
                 alias_name.clone(),
             )),
             Expr::Between {
@@ -210,54 +210,52 @@ where
                 low,
                 high,
             } => Ok(Expr::Between {
-                expr: Box::new(clone_with_replacement(&**nested_expr, replacement_fn)?),
+                expr: Box::new(clone_with_replacement(nested_expr, replacement_fn)?),
                 negated: *negated,
-                low: Box::new(clone_with_replacement(&**low, replacement_fn)?),
-                high: Box::new(clone_with_replacement(&**high, replacement_fn)?),
+                low: Box::new(clone_with_replacement(low, replacement_fn)?),
+                high: Box::new(clone_with_replacement(high, replacement_fn)?),
             }),
             Expr::InList {
                 expr: nested_expr,
                 list,
                 negated,
             } => Ok(Expr::InList {
-                expr: Box::new(clone_with_replacement(&**nested_expr, replacement_fn)?),
+                expr: Box::new(clone_with_replacement(nested_expr, replacement_fn)?),
                 list: list
                     .iter()
                     .map(|e| clone_with_replacement(e, replacement_fn))
                     .collect::<Result<Vec<Expr>>>()?,
                 negated: *negated,
             }),
             Expr::BinaryExpr { left, right, op } => Ok(Expr::BinaryExpr {
-                left: Box::new(clone_with_replacement(&**left, replacement_fn)?),
+                left: Box::new(clone_with_replacement(left, replacement_fn)?),
                 op: *op,
-                right: Box::new(clone_with_replacement(&**right, replacement_fn)?),
+                right: Box::new(clone_with_replacement(right, replacement_fn)?),
             }),
             Expr::Case {
                 expr: case_expr_opt,
                 when_then_expr,
                 else_expr: else_expr_opt,
             } => Ok(Expr::Case {
                 expr: match case_expr_opt {
-                    Some(case_expr) => Some(Box::new(clone_with_replacement(
-                        &**case_expr,
-                        replacement_fn,
-                    )?)),
+                    Some(case_expr) => {
+                        Some(Box::new(clone_with_replacement(case_expr, replacement_fn)?))
+                    }
                     None => None,
                 },
                 when_then_expr: when_then_expr
                     .iter()
                     .map(|(a, b)| {
                         Ok((
-                            Box::new(clone_with_replacement(&**a, replacement_fn)?),
-                            Box::new(clone_with_replacement(&**b, replacement_fn)?),
+                            Box::new(clone_with_replacement(a, replacement_fn)?),
+                            Box::new(clone_with_replacement(b, replacement_fn)?),
                         ))
                     })
                     .collect::<Result<Vec<(_, _)>>>()?,
                 else_expr: match else_expr_opt {
-                    Some(else_expr) => Some(Box::new(clone_with_replacement(
-                        &**else_expr,
-                        replacement_fn,
-                    )?)),
+                    Some(else_expr) => {
+                        Some(Box::new(clone_with_replacement(else_expr, replacement_fn)?))
+                    }
                     None => None,
                 },
             }),
@@ -276,38 +274,38 @@ where
                     .collect::<Result<Vec<Expr>>>()?,
             }),
             Expr::Negative(nested_expr) => Ok(Expr::Negative(Box::new(
-                clone_with_replacement(&**nested_expr, replacement_fn)?,
+                clone_with_replacement(nested_expr, replacement_fn)?,
             ))),
             Expr::Not(nested_expr) => Ok(Expr::Not(Box::new(clone_with_replacement(
-                &**nested_expr,
+                nested_expr,
                 replacement_fn,
             )?))),
             Expr::IsNotNull(nested_expr) => Ok(Expr::IsNotNull(Box::new(
-                clone_with_replacement(&**nested_expr, replacement_fn)?,
+                clone_with_replacement(nested_expr, replacement_fn)?,
             ))),
             Expr::IsNull(nested_expr) => Ok(Expr::IsNull(Box::new(
-                clone_with_replacement(&**nested_expr, replacement_fn)?,
+                clone_with_replacement(nested_expr, replacement_fn)?,
             ))),
             Expr::Cast {
                 expr: nested_expr,
                 data_type,
             } => Ok(Expr::Cast {
-                expr: Box::new(clone_with_replacement(&**nested_expr, replacement_fn)?),
+                expr: Box::new(clone_with_replacement(nested_expr, replacement_fn)?),
                 data_type: data_type.clone(),
             }),
             Expr::TryCast {
                 expr: nested_expr,
                 data_type,
             } => Ok(Expr::TryCast {
-                expr: Box::new(clone_with_replacement(&**nested_expr, replacement_fn)?),
+                expr: Box::new(clone_with_replacement(nested_expr, replacement_fn)?),
                 data_type: data_type.clone(),
             }),
             Expr::Sort {
                 expr: nested_expr,
                 asc,
                 nulls_first,
             } => Ok(Expr::Sort {
-                expr: Box::new(clone_with_replacement(&**nested_expr, replacement_fn)?),
+                expr: Box::new(clone_with_replacement(nested_expr, replacement_fn)?),
                 asc: *asc,
                 nulls_first: *nulls_first,
             }),
@@ -321,7 +319,7 @@ where
                 subquery,
                 negated,
             } => Ok(Expr::InSubquery {
-                expr: Box::new(clone_with_replacement(&**nested_expr, replacement_fn)?),
+                expr: Box::new(clone_with_replacement(nested_expr, replacement_fn)?),
                 subquery: subquery.clone(),
                 negated: *negated,
             }),
@@ -461,10 +459,10 @@ pub(crate) fn make_decimal_type(
 
     // Arrow decimal is i128 meaning 38 maximum decimal digits
     if precision > DECIMAL_MAX_PRECISION || scale > precision {
-        return Err(DataFusionError::Internal(format!(
+        Err(DataFusionError::Internal(format!(
             "For decimal(precision, scale) precision must be less than or equal to 38 and scale can't be greater than precision. Got ({}, {})",
             precision, scale
-        )));
+        )))
     } else {
         Ok(DataType::Decimal(precision, scale))
     }