[AURON #2001] Upgrade Rust nightly toolchain to 2025-12-15.

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

Author: slfan1989

native-engine/auron-memmgr/src/spill.rs

@@ -166,10 +166,10 @@ impl Drop for FileSpill {
         self.1
             .disk_spill_iotime
             .add_duration(Duration::from_nanos(self.1.mem_spill_iotime.value() as u64));
-        if let Some(file_path) = &self.2 {
-            if let Err(e) = fs::remove_file(file_path) {
-                warn!("Was unable to delete spill file: {file_path}. error: {e}");
-            }
+        if let Some(file_path) = &self.2
+            && let Err(e) = fs::remove_file(file_path)
+        {
+            warn!("Was unable to delete spill file: {file_path}. error: {e}");
         }
     }
 }

native-engine/datafusion-ext-commons/src/hash/xxhash.rs

@@ -98,7 +98,7 @@ fn xxh64_merge_round(mut hash: u64, acc: u64) -> u64 {
 
 #[inline]
 fn xxh_rotl64(value: u64, amt: i32) -> u64 {
-    (value << (amt % 64)) | (value >> (64 - amt % 64))
+    value.rotate_left((amt as u32) % 64)
 }
 
 #[inline]

native-engine/datafusion-ext-commons/src/io/batch_serde.rs

@@ -750,7 +750,7 @@ mod test {
                 "| [6, 7]    | [6, 7]    |",
                 "+-----------+-----------+"
             ],
-            &[batch.clone()]
+            std::slice::from_ref(&batch)
         );
 
         // test read after write

native-engine/datafusion-ext-commons/src/io/ipc_compression.rs

@@ -336,8 +336,8 @@ mod tests {
         let test_array2: ArrayRef = Arc::new(StringArray::from(vec![Some("foo"), Some("bar")]));
         let schema = Arc::new(Schema::new(vec![Field::new("", DataType::Utf8, false)]));
 
-        writer.write_batch(2, &[test_array1.clone()])?;
-        writer.write_batch(2, &[test_array2.clone()])?;
+        writer.write_batch(2, std::slice::from_ref(&test_array1))?;
+        writer.write_batch(2, std::slice::from_ref(&test_array2))?;
         writer.finish_current_buf()?;
 
         let mut reader = IpcCompressionReader::new(Cursor::new(buf));

native-engine/datafusion-ext-commons/src/lib.rs

@@ -16,7 +16,6 @@
 #![allow(internal_features)]
 #![feature(core_intrinsics)]
 #![feature(slice_swap_unchecked)]
-#![feature(vec_into_raw_parts)]
 
 use auron_jni_bridge::conf::{
     BATCH_SIZE, IntConf, SUGGESTED_BATCH_MEM_SIZE, SUGGESTED_BATCH_MEM_SIZE_KWAY_MERGE,
@@ -141,21 +140,21 @@ macro_rules! assume {
 macro_rules! prefetch_read_data {
     ($e:expr) => {{
         // safety: use prefetch
-        let locality = 3;
+        const LOCALITY: i32 = 3;
         #[allow(unused_unsafe)]
         unsafe {
-            std::intrinsics::prefetch_read_data($e, locality)
+            std::intrinsics::prefetch_read_data::<_, { LOCALITY }>($e)
         }
     }};
 }
 #[macro_export]
 macro_rules! prefetch_write_data {
     ($e:expr) => {{
         // safety: use prefetch
-        let locality = 3;
+        const LOCALITY: i32 = 3;
         #[allow(unused_unsafe)]
         unsafe {
-            std::intrinsics::prefetch_write_data($e, locality)
+            std::intrinsics::prefetch_write_data::<_, { LOCALITY }>($e)
         }
     }};
 }

native-engine/datafusion-ext-commons/src/spark_hash.rs

@@ -467,7 +467,7 @@ mod tests {
         ])) as ArrayRef;
 
         // generated with Murmur3Hash(Seq(Literal(1L)), 42).eval() since Spark is tested
-        let hashes = create_murmur3_hashes(5, &[i.clone()], 42);
+        let hashes = create_murmur3_hashes(5, std::slice::from_ref(&i), 42);
         let expected: Vec<i32> = [
             0x99f0149d_u32,
             0x9c67b85d,
@@ -482,7 +482,7 @@ mod tests {
 
         // generated with XxHash64(Seq(Literal(1L)), 42).eval() since Spark is tested
         // against this as well
-        let hashes = create_xxhash64_hashes(5, &[i.clone()], 42);
+        let hashes = create_xxhash64_hashes(5, std::slice::from_ref(&i), 42);
         let expected = vec![
             -7001672635703045582,
             -5252525462095825812,
@@ -495,11 +495,11 @@ mod tests {
 
     #[test]
     fn test_str() {
-        let i = Arc::new(StringArray::from(vec!["hello", "bar", "", "😁", "天地"]));
+        let i = Arc::new(StringArray::from(vec!["hello", "bar", "", "😁", "天地"])) as ArrayRef;
 
         // generated with Murmur3Hash(Seq(Literal("")), 42).eval() since Spark is tested
         // against this as well
-        let hashes = create_murmur3_hashes(5, &[i.clone()], 42);
+        let hashes = create_murmur3_hashes(5, std::slice::from_ref(&i), 42);
         let expected: Vec<i32> = [3286402344_u32, 2486176763, 142593372, 885025535, 2395000894]
             .into_iter()
             .map(|v| v as i32)
@@ -508,7 +508,7 @@ mod tests {
 
         // generated with XxHash64(Seq(Literal("")), 42).eval() since Spark is tested
         // against this as well
-        let hashes = create_xxhash64_hashes(5, &[i.clone()], 42);
+        let hashes = create_xxhash64_hashes(5, std::slice::from_ref(&i), 42);
         let expected = vec![
             -4367754540140381902,
             -1798770879548125814,
@@ -541,7 +541,7 @@ mod tests {
         let array_ref = Arc::new(list_array) as ArrayRef;
 
         // Test Murmur3 hash
-        let hashes = create_murmur3_hashes(3, &[array_ref.clone()], 42);
+        let hashes = create_murmur3_hashes(3, std::slice::from_ref(&array_ref), 42);
         assert_eq!(hashes, vec![-222940379, -374492525, -331964951]);
         Ok(())
     }

native-engine/datafusion-ext-functions/src/spark_dates.rs

@@ -64,11 +64,8 @@ pub fn spark_quarter(args: &[ColumnarValue]) -> Result<ColumnarValue> {
         .expect("date_part(Month) must return Int32Array");
 
     // Compute quarter: ((month - 1) / 3) + 1, preserving NULLs
-    let quarter = Int32Array::from_iter(
-        month_arr
-            .iter()
-            .map(|opt_m| opt_m.map(|m| ((m - 1) / 3 + 1))),
-    );
+    let quarter =
+        Int32Array::from_iter(month_arr.iter().map(|opt_m| opt_m.map(|m| (m - 1) / 3 + 1)));
 
     Ok(ColumnarValue::Array(Arc::new(quarter)))
 }

native-engine/datafusion-ext-functions/src/spark_get_json_object.rs

@@ -305,15 +305,15 @@ impl HiveGetJsonObjectEvaluator {
         json_str: &str,
     ) -> std::result::Result<Option<String>, HiveGetJsonObjectError> {
         // first try parsing with sonic-rs and fail-backing to serde-json
-        if let Ok(root_value) = sonic_rs::from_str::<sonic_rs::Value>(json_str) {
-            if let Ok(v) = self.evaluate_with_value_sonic(&root_value) {
-                return Ok(v);
-            }
+        if let Ok(root_value) = sonic_rs::from_str::<sonic_rs::Value>(json_str)
+            && let Ok(v) = self.evaluate_with_value_sonic(&root_value)
+        {
+            return Ok(v);
         }
-        if let Ok(root_value) = serde_json::from_str::<serde_json::Value>(json_str) {
-            if let Ok(v) = self.evaluate_with_value_serde_json(&root_value) {
-                return Ok(v);
-            }
+        if let Ok(root_value) = serde_json::from_str::<serde_json::Value>(json_str)
+            && let Ok(v) = self.evaluate_with_value_serde_json(&root_value)
+        {
+            return Ok(v);
         }
         Err(HiveGetJsonObjectError::InvalidInput)
     }

native-engine/datafusion-ext-functions/src/spark_strings.rs

@@ -216,10 +216,10 @@ pub fn string_concat_ws(args: &[ColumnarValue]) -> Result<ColumnarValue> {
                     if let Ok(s) = as_string_array(&array).cloned() {
                         return Ok(Arg::Array(s));
                     }
-                    if let Ok(l) = as_list_array(&array).cloned() {
-                        if l.value_type() == DataType::Utf8 {
-                            return Ok(Arg::List(l));
-                        }
+                    if let Ok(l) = as_list_array(&array).cloned()
+                        && l.value_type() == DataType::Utf8
+                    {
+                        return Ok(Arg::List(l));
                     }
                 }
                 ColumnarValue::Scalar(scalar) => {

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();
             }
         }
     }