rebase & cargo clippy

Author: xudong963

datafusion/datasource-parquet/src/metrics.rs

@@ -100,7 +100,7 @@ impl ParquetFileMetrics {
         let limit_pruned_row_groups = MetricBuilder::new(metrics)
             .with_new_label("filename", filename.to_string())
             .counter("limit_pruned_row_groups", partition);
-        
+
         let row_groups_fully_matched_statistics = MetricBuilder::new(metrics)
             .with_new_label("filename", filename.to_string())
             .counter("row_groups_fully_matched_statistics", partition);

datafusion/datasource-parquet/src/row_group_filter.rs

@@ -204,14 +204,14 @@ impl RowGroupAccessPlanFilter {
                 if !fully_contained_candidates_original_idx.is_empty() {
                     // Use NotExpr to create the inverted predicate
                     let inverted_expr =
-                        Arc::new(NotExpr::new(predicate.orig_expr().clone()));
+                        Arc::new(NotExpr::new(Arc::clone(predicate.orig_expr())));
                     // Simplify the NOT expression (e.g., NOT(c1 = 0) -> c1 != 0)
                     // before building the pruning predicate
                     let mut simplifier = PhysicalExprSimplifier::new(arrow_schema);
                     let inverted_expr = simplifier.simplify(inverted_expr).unwrap();
                     if let Ok(inverted_predicate) = PruningPredicate::try_new(
                         inverted_expr,
-                        predicate.schema().clone(),
+                        Arc::clone(predicate.schema()),
                     ) {
                         let inverted_pruning_stats = RowGroupPruningStatistics {
                             parquet_schema,

datafusion/execution/src/memory_pool/pool.rs

@@ -34,7 +34,7 @@ pub struct UnboundedMemoryPool {
 }
 
 impl MemoryPool for UnboundedMemoryPool {
-    fn grow(&self, _reservation: &MemoryReservation, additional: usize) {}
+    fn grow(&self, _reservation: &MemoryReservation, _additional: usize) {}
 
     fn shrink(&self, _reservation: &MemoryReservation, shrink: usize) {
         self.used.fetch_sub(shrink, Ordering::Relaxed);

datafusion/physical-expr/src/simplifier/not.rs

@@ -131,13 +131,13 @@ pub fn simplify_not_expr_recursive(
     schema: &Schema,
 ) -> Result<Transformed<Arc<dyn PhysicalExpr>>> {
     // First, try to simplify any NOT expressions in this expression
-    let not_simplified = simplify_not_expr(expr.clone(), schema)?;
+    let not_simplified = simplify_not_expr(Arc::clone(&expr), schema)?;
 
     // If the expression was transformed, we might have created new opportunities for simplification
     if not_simplified.transformed {
         // Recursively simplify the result
         let further_simplified =
-            simplify_not_expr_recursive(not_simplified.data.clone(), schema)?;
+            simplify_not_expr_recursive(Arc::clone(&not_simplified.data), schema)?;
         if further_simplified.transformed {
             return Ok(Transformed::yes(further_simplified.data));
         } else {
@@ -202,12 +202,12 @@ mod tests {
         let schema = test_schema();
 
         // Create NOT(NOT(b > 5))
-        let inner_expr = Arc::new(BinaryExpr::new(
+        let inner_expr: Arc<dyn PhysicalExpr> = Arc::new(BinaryExpr::new(
             col("b", &schema)?,
             Operator::Gt,
             lit(ScalarValue::Int32(Some(5))),
         ));
-        let inner_not = Arc::new(NotExpr::new(inner_expr.clone()));
+        let inner_not = Arc::new(NotExpr::new(Arc::clone(&inner_expr)));
         let double_not = Arc::new(NotExpr::new(inner_not));
 
         let result = simplify_not_expr_recursive(double_not, &schema)?;