fix

Author: zhuqi-lucas

datafusion/physical-optimizer/src/reverse_order.rs

@@ -49,7 +49,7 @@ impl PhysicalOptimizerRule for ReverseOrder {
     fn optimize(
         &self,
         plan: Arc<dyn ExecutionPlan>,
-        config: &ConfigOptions,
+        _config: &ConfigOptions,
     ) -> Result<Arc<dyn ExecutionPlan>> {
         // Search for any SortExec nodes and try to optimize them
         plan.transform_up(&|plan: Arc<dyn ExecutionPlan>| {
@@ -62,7 +62,7 @@ impl PhysicalOptimizerRule for ReverseOrder {
 
             // First, check if the sort is already satisfied by input ordering
             // This is similar to analyze_immediate_sort_removal in EnforceSorting
-            if let Some(input_ordering) = sort_input.output_ordering() {
+            if let Some(_input_ordering) = sort_input.output_ordering() {
                 let input_eq_properties = sort_input.equivalence_properties();
 
                 // Check if input already satisfies the sort requirement
@@ -181,8 +181,8 @@ impl TreeNodeRewriter for ReverseRewriter {
                 .map(|sort| !sort)
                 .collect();
             let exec = SortMergeJoinExec::try_new(
-                sort_merge_join.left.clone(),
-                sort_merge_join.right.clone(),
+                Arc::clone(&sort_merge_join.left),
+                Arc::clone(&sort_merge_join.right),
                 sort_merge_join.on.clone(),
                 sort_merge_join.filter.clone(),
                 sort_merge_join.join_type,
@@ -285,8 +285,9 @@ impl PushdownReverse for DataSourceExec {
                         reverse_parquet_source.with_predicate(predicate);
                 }
 
-                let source = reverse_parquet_source
-                    .with_statistics(cfg.statistics().unwrap_or_default().clone());
+                let source = reverse_parquet_source.with_statistics(
+                    cfg.partition_statistics(None).unwrap_or_default().clone(),
+                );
                 let cfg = FileScanConfigBuilder::from(cfg).with_source(source).build();
 
                 return Some(DataSourceExec::new(Arc::new(cfg)));
@@ -374,7 +375,7 @@ mod tests {
                     Arc::new(arrow::array::StringArray::from(
                         values
                             .iter()
-                            .map(|v| format!("val_{}", v))
+                            .map(|v| format!("val_{v}"))
                             .collect::<Vec<_>>(),
                     )),
                     Arc::new(arrow::array::Float64Array::from(
@@ -439,7 +440,7 @@ mod tests {
         let lex_ordering = LexOrdering::new(sort_expr).unwrap();
         let sort_exec = Arc::new(SortExec::new(lex_ordering, lazy_exec));
 
-        let optimizer = ReverseOrder::default();
+        let optimizer = ReverseOrder;
         let result = optimizer.optimize(sort_exec, &config)?;
 
         // The optimizer should either remove the sort or keep it if it can't verify the ordering
@@ -485,7 +486,7 @@ mod tests {
             SortExec::new(lex_ordering, repartitioned).with_preserve_partitioning(false),
         );
 
-        let optimizer = ReverseOrder::default();
+        let optimizer = ReverseOrder;
         let result = optimizer.optimize(sort_exec, &config)?;
 
         // Verify: Should be replaced with SortPreservingMergeExec
@@ -524,7 +525,7 @@ mod tests {
         let sort_exec =
             Arc::new(SortExec::new(lex_ordering, lazy_exec).with_fetch(Some(10)));
 
-        let optimizer = ReverseOrder::default();
+        let optimizer = ReverseOrder;
         let result = optimizer.optimize(sort_exec, &config)?;
 
         // Should optimize to either GlobalLimitExec or keep as TopK (SortExec with fetch)
@@ -571,7 +572,7 @@ mod tests {
                 .with_preserve_partitioning(true), // preserve partitions
         );
 
-        let optimizer = ReverseOrder::default();
+        let optimizer = ReverseOrder;
         let result = optimizer.optimize(sort_exec, &config)?;
 
         // Verify: Should be replaced with LocalLimitExec for multi-partition
@@ -619,7 +620,7 @@ mod tests {
         let lex_ordering = LexOrdering::new(sort_expr).unwrap();
         let sort_exec = Arc::new(SortExec::new(lex_ordering, unsorted_exec));
 
-        let optimizer = ReverseOrder::default();
+        let optimizer = ReverseOrder;
         let result = optimizer.optimize(sort_exec, &config)?;
 
         // Verify: SortExec should still be present since input is not sorted
@@ -667,7 +668,7 @@ mod tests {
         let lex_ordering = LexOrdering::new(asc_sort_expr).unwrap();
         let sort_exec = Arc::new(SortExec::new(lex_ordering, lazy_exec));
 
-        let optimizer = ReverseOrder::default();
+        let optimizer = ReverseOrder;
         let result = optimizer.optimize(sort_exec, &config)?;
 
         // The optimizer may or may not be able to reverse LazyMemoryExec
@@ -706,7 +707,7 @@ mod tests {
         // Add second unnecessary sort on top
         let outer_sort = Arc::new(SortExec::new(lex_ordering, inner_sort));
 
-        let optimizer = ReverseOrder::default();
+        let optimizer = ReverseOrder;
         let result = optimizer.optimize(outer_sort, &config)?;
 
         // Verify: At least one sort should be removed
@@ -739,7 +740,7 @@ mod tests {
             vec![Arc::new(RwLock::new(generator))],
         )?);
 
-        let optimizer = ReverseOrder::default();
+        let optimizer = ReverseOrder;
         let result = optimizer.optimize(Arc::clone(&lazy_exec) as _, &config)?;
 
         // Verify: Plan should be unchanged
@@ -766,7 +767,7 @@ mod tests {
     #[test]
     fn test_optimizer_properties() {
         // Test basic optimizer properties
-        let optimizer = ReverseOrder::default();
+        let optimizer = ReverseOrder;
 
         assert_eq!(optimizer.name(), "ReverseOrder");
         assert!(optimizer.schema_check());
@@ -775,7 +776,7 @@ mod tests {
     #[test]
     fn test_reverse_order_clone() {
         // Test that optimizer can be cloned
-        let optimizer1 = ReverseOrder::default();
+        let optimizer1 = ReverseOrder;
         let optimizer2 = optimizer1.clone();
 
         assert_eq!(optimizer1.name(), optimizer2.name());
@@ -789,7 +790,7 @@ mod tests {
         let config = ConfigOptions::new();
         let schema = create_test_schema();
 
-        let empty_exec = Arc::new(EmptyExec::new(schema.clone()));
+        let empty_exec = Arc::new(EmptyExec::new(Arc::clone(&schema)));
         let sort_expr = vec![PhysicalSortExpr {
             expr: Arc::new(Column::new("col1", 0)),
             options: SortOptions {
@@ -801,7 +802,7 @@ mod tests {
         let lex_ordering = LexOrdering::new(sort_expr).unwrap();
         let sort_exec = Arc::new(SortExec::new(lex_ordering, empty_exec));
 
-        let optimizer = ReverseOrder::default();
+        let optimizer = ReverseOrder;
         let result = optimizer.optimize(sort_exec, &config)?;
 
         // EmptyExec has no output ordering, so sort should remain
@@ -842,7 +843,7 @@ mod tests {
         let lex_ordering = LexOrdering::new(sort_expr).unwrap();
         let sort_exec = Arc::new(SortExec::new(lex_ordering, lazy_exec));
 
-        let optimizer = ReverseOrder::default();
+        let optimizer = ReverseOrder;
         let result = optimizer.optimize(sort_exec, &config)?;
 
         // Verify the optimizer returns a valid plan (may or may not optimize depending on