Bump rand to 0.9, rand_distr to 0.5.0, getrandom to 0.3.1

Cargo.toml

@@ -142,7 +142,7 @@ pbjson = { version = "0.7.0" }
 # Should match arrow-flight's version of prost.
 prost = "0.13.1"
 prost-derive = "0.13.1"
-rand = "0.8"
+rand = "0.9"
 recursive = "0.1.1"
 regex = "1.8"
 rstest = "0.24.0"

datafusion/common/Cargo.toml

@@ -74,4 +74,4 @@ web-time = "1.1.0"
 
 [dev-dependencies]
 chrono = { workspace = true }
-rand = { workspace = true }
+rand = { workspace = true, features = ["thread_rng"] }

datafusion/common/src/scalar/mod.rs

@@ -7130,14 +7130,14 @@ mod tests {
     fn get_random_timestamps(sample_size: u64) -> Vec<ScalarValue> {
         let vector_size = sample_size;
         let mut timestamp = vec![];
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
         for i in 0..vector_size {
-            let year = rng.gen_range(1995..=2050);
-            let month = rng.gen_range(1..=12);
-            let day = rng.gen_range(1..=28); // to exclude invalid dates
-            let hour = rng.gen_range(0..=23);
-            let minute = rng.gen_range(0..=59);
-            let second = rng.gen_range(0..=59);
+            let year = rng.random_range(1995..=2050);
+            let month = rng.random_range(1..=12);
+            let day = rng.random_range(1..=28); // to exclude invalid dates
+            let hour = rng.random_range(0..=23);
+            let minute = rng.random_range(0..=59);
+            let second = rng.random_range(0..=59);
             if i % 4 == 0 {
                 timestamp.push(ScalarValue::TimestampSecond(
                     Some(
@@ -7151,7 +7151,7 @@ mod tests {
                     None,
                 ))
             } else if i % 4 == 1 {
-                let millisec = rng.gen_range(0..=999);
+                let millisec = rng.random_range(0..=999);
                 timestamp.push(ScalarValue::TimestampMillisecond(
                     Some(
                         NaiveDate::from_ymd_opt(year, month, day)
@@ -7164,7 +7164,7 @@ mod tests {
                     None,
                 ))
             } else if i % 4 == 2 {
-                let microsec = rng.gen_range(0..=999_999);
+                let microsec = rng.random_range(0..=999_999);
                 timestamp.push(ScalarValue::TimestampMicrosecond(
                     Some(
                         NaiveDate::from_ymd_opt(year, month, day)
@@ -7177,7 +7177,7 @@ mod tests {
                     None,
                 ))
             } else if i % 4 == 3 {
-                let nanosec = rng.gen_range(0..=999_999_999);
+                let nanosec = rng.random_range(0..=999_999_999);
                 timestamp.push(ScalarValue::TimestampNanosecond(
                     Some(
                         NaiveDate::from_ymd_opt(year, month, day)
@@ -7201,27 +7201,27 @@ mod tests {
 
         let vector_size = sample_size;
         let mut intervals = vec![];
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
         const SECS_IN_ONE_DAY: i32 = 86_400;
         const MICROSECS_IN_ONE_DAY: i64 = 86_400_000_000;
         for i in 0..vector_size {
             if i % 4 == 0 {
-                let days = rng.gen_range(0..5000);
+                let days = rng.random_range(0..5000);
                 // to not break second precision
-                let millis = rng.gen_range(0..SECS_IN_ONE_DAY) * 1000;
+                let millis = rng.random_range(0..SECS_IN_ONE_DAY) * 1000;
                 intervals.push(ScalarValue::new_interval_dt(days, millis));
             } else if i % 4 == 1 {
-                let days = rng.gen_range(0..5000);
-                let millisec = rng.gen_range(0..(MILLISECS_IN_ONE_DAY as i32));
+                let days = rng.random_range(0..5000);
+                let millisec = rng.random_range(0..(MILLISECS_IN_ONE_DAY as i32));
                 intervals.push(ScalarValue::new_interval_dt(days, millisec));
             } else if i % 4 == 2 {
-                let days = rng.gen_range(0..5000);
+                let days = rng.random_range(0..5000);
                 // to not break microsec precision
-                let nanosec = rng.gen_range(0..MICROSECS_IN_ONE_DAY) * 1000;
+                let nanosec = rng.random_range(0..MICROSECS_IN_ONE_DAY) * 1000;
                 intervals.push(ScalarValue::new_interval_mdn(0, days, nanosec));
             } else {
-                let days = rng.gen_range(0..5000);
-                let nanosec = rng.gen_range(0..NANOSECS_IN_ONE_DAY);
+                let days = rng.random_range(0..5000);
+                let nanosec = rng.random_range(0..NANOSECS_IN_ONE_DAY);
                 intervals.push(ScalarValue::new_interval_mdn(0, days, nanosec));
             }
         }

datafusion/core/Cargo.toml

@@ -124,7 +124,7 @@ num-traits = { version = "0.2", optional = true }
 object_store = { workspace = true }
 parking_lot = { workspace = true }
 parquet = { workspace = true, optional = true, default-features = true }
-rand = { workspace = true }
+rand = { workspace = true, features = ["thread_rng"] }
 regex = { workspace = true }
 sqlparser = { workspace = true }
 tempfile = { workspace = true }
@@ -145,8 +145,9 @@ datafusion-physical-optimizer = { workspace = true }
 doc-comment = { workspace = true }
 env_logger = { workspace = true }
 paste = "^1.0"
-rand = { workspace = true, features = ["small_rng"] }
-rand_distr = "0.4.3"
+rand = { workspace = true, features = ["small_rng", "thread_rng"] }
+rand_chacha = "0.9.0"
+rand_distr = "0.5.0"
 regex = { workspace = true }
 rstest = { workspace = true }
 serde_json = { workspace = true }

datafusion/core/benches/data_utils/mod.rs

@@ -29,8 +29,7 @@ use arrow_array::builder::{Int64Builder, StringBuilder};
 use datafusion::datasource::MemTable;
 use datafusion::error::Result;
 use datafusion_common::DataFusionError;
-use rand::rngs::StdRng;
-use rand::seq::SliceRandom;
+use rand::{rngs::StdRng, seq::IndexedRandom};
 use rand::{Rng, SeedableRng};
 use rand_distr::Distribution;
 use rand_distr::{Normal, Pareto};
@@ -80,10 +79,10 @@ fn create_data(size: usize, null_density: f64) -> Vec<Option<f64>> {
 
     (0..size)
         .map(|_| {
-            if rng.gen::<f64>() > null_density {
+            if rng.random::<f64>() > null_density {
                 None
             } else {
-                Some(rng.gen::<f64>())
+                Some(rng.random::<f64>())
             }
         })
         .collect()
@@ -95,10 +94,10 @@ fn create_integer_data(size: usize, value_density: f64) -> Vec<Option<u64>> {
 
     (0..size)
         .map(|_| {
-            if rng.gen::<f64>() > value_density {
+            if rng.random::<f64>() > value_density {
                 None
             } else {
-                Some(rng.gen::<u64>())
+                Some(rng.random::<u64>())
             }
         })
         .collect()
@@ -128,7 +127,7 @@ fn create_record_batch(
 
     // Integer values between [0, 9].
     let integer_values_narrow = (0..batch_size)
-        .map(|_| rng.gen_range(0_u64..10))
+        .map(|_| rng.random_range(0_u64..10))
         .collect::<Vec<_>>();
 
     RecordBatch::try_new(
@@ -188,7 +187,7 @@ pub(crate) fn make_data(
         let mut id_builder = StringBuilder::new();
         let mut ts_builder = Int64Builder::new();
         let gen_id = |rng: &mut rand::rngs::SmallRng| {
-            rng.gen::<[u8; 16]>()
+            rng.random::<[u8; 16]>()
                 .iter()
                 .fold(String::new(), |mut output, b| {
                     let _ = write!(output, "{b:02X}");
@@ -204,7 +203,7 @@ pub(crate) fn make_data(
             .map(|_| gen_sample_cnt(&mut rng))
             .collect::<Vec<_>>();
         for _ in 0..sample_cnt {
-            let random_index = rng.gen_range(0..simultaneous_group_cnt);
+            let random_index = rng.random_range(0..simultaneous_group_cnt);
             let trace_id = &mut group_ids[random_index];
             let sample_cnt = &mut group_sample_cnts[random_index];
             *sample_cnt -= 1;