[AURON #2001] Upgrade Rust nightly toolchain to 2025-06-23.

Signed-off-by: slfan1989 <slfan1989@apache.org>

Author: slfan1989

native-engine/datafusion-ext-plans/src/agg/acc.rs

@@ -456,10 +456,10 @@ impl AccBytesColumn {
     fn refresh_heap_mem_used(&mut self) {
         self.heap_mem_used = 0;
         for item in &self.items {
-            if let Some(v) = item {
-                if v.spilled() {
-                    self.heap_mem_used += v.capacity();
-                }
+            if let Some(v) = item
+                && v.spilled()
+            {
+                self.heap_mem_used += v.capacity();
             }
         }
     }

native-engine/datafusion-ext-plans/src/agg/agg_table.rs

@@ -126,10 +126,10 @@ impl AggTable {
         self.update_mem_used(mem_used).await?;
 
         // update udaf memory tracker, spill if update failed
-        if let Some(udaf_mem_tracker) = self.agg_ctx.get_udaf_mem_tracker() {
-            if !udaf_mem_tracker.update_used()? {
-                self.force_spill().await?;
-            }
+        if let Some(udaf_mem_tracker) = self.agg_ctx.get_udaf_mem_tracker()
+            && !udaf_mem_tracker.update_used()?
+        {
+            self.force_spill().await?;
         }
         Ok(())
     }
@@ -329,10 +329,10 @@ impl MemConsumer for AggTable {
 
         // use pre-merging if cardinality is low
         let mut next_is_hashing = false;
-        if let InMemData::Hashing(hashing_data) = &in_mem.data {
-            if hashing_data.cardinality_ratio() < 0.5 {
-                next_is_hashing = true;
-            }
+        if let InMemData::Hashing(hashing_data) = &in_mem.data
+            && hashing_data.cardinality_ratio() < 0.5
+        {
+            next_is_hashing = true;
         }
         let cur_in_mem = in_mem.renew(next_is_hashing)?;
 
@@ -449,15 +449,14 @@ impl InMemTable {
         if self.id == 0 // only works on first table
             && !self.agg_ctx.is_expand_agg
             && self.agg_ctx.supports_partial_skipping
+            && let InMemData::Hashing(hashing_data) = &self.data
         {
-            if let InMemData::Hashing(hashing_data) = &self.data {
-                let cardinality_ratio = hashing_data.cardinality_ratio();
-                if cardinality_ratio > self.agg_ctx.partial_skipping_ratio {
-                    log::warn!(
-                        "AggTable cardinality ratio = {cardinality_ratio}, will trigger partial skipping",
-                    );
-                    return true;
-                }
+            let cardinality_ratio = hashing_data.cardinality_ratio();
+            if cardinality_ratio > self.agg_ctx.partial_skipping_ratio {
+                log::warn!(
+                    "AggTable cardinality ratio = {cardinality_ratio}, will trigger partial skipping",
+                );
+                return true;
             }
         }
         false

native-engine/datafusion-ext-plans/src/common/cached_exprs_evaluator.rs

@@ -211,13 +211,13 @@ fn transform_to_cached_exprs(exprs: &[PhysicalExprRef]) -> Result<(Vec<PhysicalE
             // short circuiting expression - only first child can be cached
             // first `when` expr can also be cached
             collect_dups(&expr.children()[0], current_count, expr_counts, dups);
-            if let Ok(case_expr) = downcast_any!(expr, CaseExpr) {
-                if case_expr.expr().is_some() {
-                    let children = case_expr.children();
-                    if children.len() >= 2 {
-                        // cache first `when` expr
-                        collect_dups(&expr.children()[1], current_count, expr_counts, dups);
-                    }
+            if let Ok(case_expr) = downcast_any!(expr, CaseExpr)
+                && case_expr.expr().is_some()
+            {
+                let children = case_expr.children();
+                if children.len() >= 2 {
+                    // cache first `when` expr
+                    collect_dups(&expr.children()[1], current_count, expr_counts, dups);
                 }
             }
         } else {
@@ -272,11 +272,12 @@ fn transform_to_cached_exprs(exprs: &[PhysicalExprRef]) -> Result<(Vec<PhysicalE
                 .collect::<Vec<_>>();
             children[0] = transform(children[0].clone(), cached_expr_ids, cache)?;
 
-            if let Some(case_expr) = expr.as_any().downcast_ref::<CaseExpr>() {
-                if children.len() >= 2 && case_expr.expr().is_some() {
-                    // cache first `when` expr
-                    children[1] = transform(children[1].clone(), cached_expr_ids, cache)?;
-                }
+            if let Some(case_expr) = expr.as_any().downcast_ref::<CaseExpr>()
+                && children.len() >= 2
+                && case_expr.expr().is_some()
+            {
+                // cache first `when` expr
+                children[1] = transform(children[1].clone(), cached_expr_ids, cache)?;
             }
             expr.clone().with_new_children(children)?
         } else {

native-engine/datafusion-ext-plans/src/common/execution_context.rs

@@ -431,10 +431,10 @@ impl ExecutionContext {
                 match ready!(self.as_mut().input.poll_next_unpin(cx)) {
                     Some(r) => Poll::Ready(Some(r)),
                     None => {
-                        if let Some(on_completion) = self.as_mut().on_completion.take() {
-                            if let Err(e) = on_completion() {
-                                return Poll::Ready(Some(Err(e)));
-                            }
+                        if let Some(on_completion) = self.as_mut().on_completion.take()
+                            && let Err(e) = on_completion()
+                        {
+                            return Poll::Ready(Some(Err(e)));
                         }
                         Poll::Ready(None)
                     }

native-engine/datafusion-ext-plans/src/debug_exec.rs

@@ -109,7 +109,7 @@ impl ExecutionPlan for DebugExec {
         Ok(
             exec_ctx.output_with_sender("Debug", move |sender| async move {
                 while let Some(batch) = input.next().await.transpose()? {
-                    let table_str = pretty_format_batches(&[batch.clone()])?
+                    let table_str = pretty_format_batches(std::slice::from_ref(&batch))?
                         .to_string()
                         .replace('\n', &format!("\n{debug_id} - "));
                     log::info!("DebugExec(partition={partition}):\n{table_str}");

native-engine/datafusion-ext-plans/src/generate_exec.rs

@@ -402,7 +402,7 @@ mod test {
             "|   |                 | {}             |",
             "+---+-----------------+----------------+",
         ];
-        assert_batches_eq!(input, &[input_batch.clone()]);
+        assert_batches_eq!(input, std::slice::from_ref(&input_batch));
 
         let input = Arc::new(TestMemoryExec::try_new(
             &[vec![input_batch.clone()]],

native-engine/datafusion-ext-plans/src/orc_exec.rs

@@ -455,13 +455,13 @@ fn collect_and_predicates(
     }
 
     // Handle BinaryExpr with AND operator
-    if let Some(binary) = expr.as_any().downcast_ref::<BinaryExpr>() {
-        if matches!(binary.op(), Operator::And) {
-            // Recursively collect AND sub-conditions from both sides
-            collect_and_predicates(binary.left(), schema, predicates);
-            collect_and_predicates(binary.right(), schema, predicates);
-            return;
-        }
+    if let Some(binary) = expr.as_any().downcast_ref::<BinaryExpr>()
+        && matches!(binary.op(), Operator::And)
+    {
+        // Recursively collect AND sub-conditions from both sides
+        collect_and_predicates(binary.left(), schema, predicates);
+        collect_and_predicates(binary.right(), schema, predicates);
+        return;
     }
 
     // Not an AND expression, convert the whole expression
@@ -487,13 +487,13 @@ fn collect_or_predicates(
     }
 
     // Handle BinaryExpr with OR operator
-    if let Some(binary) = expr.as_any().downcast_ref::<BinaryExpr>() {
-        if matches!(binary.op(), Operator::Or) {
-            // Recursively collect OR sub-conditions from both sides
-            collect_or_predicates(binary.left(), schema, predicates);
-            collect_or_predicates(binary.right(), schema, predicates);
-            return;
-        }
+    if let Some(binary) = expr.as_any().downcast_ref::<BinaryExpr>()
+        && matches!(binary.op(), Operator::Or)
+    {
+        // Recursively collect OR sub-conditions from both sides
+        collect_or_predicates(binary.left(), schema, predicates);
+        collect_or_predicates(binary.right(), schema, predicates);
+        return;
     }
 
     // Not an OR expression, convert the whole expression
@@ -667,10 +667,10 @@ fn convert_expr_to_orc_internal(
             // Convert IN to multiple OR conditions: col = val1 OR col = val2 OR ...
             let mut predicates = Vec::new();
             for list_expr in in_list.list() {
-                if let Some(lit) = list_expr.as_any().downcast_ref::<Literal>() {
-                    if let Some(pred_value) = convert_scalar_value(lit.value()) {
-                        predicates.push(Predicate::eq(col_name, pred_value));
-                    }
+                if let Some(lit) = list_expr.as_any().downcast_ref::<Literal>()
+                    && let Some(pred_value) = convert_scalar_value(lit.value())
+                {
+                    predicates.push(Predicate::eq(col_name, pred_value));
                 }
             }
 
@@ -699,20 +699,20 @@ fn convert_expr_to_orc_internal(
             return None;
         }
 
-        if let Some(col) = left.as_any().downcast_ref::<Column>() {
-            if let Some(lit) = right.as_any().downcast_ref::<Literal>() {
-                let col_name = col.name();
-                let value = lit.value();
-                return build_comparison_predicate(col_name, op, value);
-            }
+        if let Some(col) = left.as_any().downcast_ref::<Column>()
+            && let Some(lit) = right.as_any().downcast_ref::<Literal>()
+        {
+            let col_name = col.name();
+            let value = lit.value();
+            return build_comparison_predicate(col_name, op, value);
         }
 
-        if let Some(lit) = left.as_any().downcast_ref::<Literal>() {
-            if let Some(col) = right.as_any().downcast_ref::<Column>() {
-                let col_name = col.name();
-                let value = lit.value();
-                return build_comparison_predicate_reversed(col_name, op, value);
-            }
+        if let Some(lit) = left.as_any().downcast_ref::<Literal>()
+            && let Some(col) = right.as_any().downcast_ref::<Column>()
+        {
+            let col_name = col.name();
+            let value = lit.value();
+            return build_comparison_predicate_reversed(col_name, op, value);
         }
     }