Revert "Update rand requirement from 0.8 to 0.9 (#7045)" (#7125)

* Revert "Update rand requirement from 0.8 to 0.9 (#7045)"

This reverts commit 69eeee3.

* downgrade API

Author: alamb

arrow-array/Cargo.toml

@@ -55,7 +55,7 @@ ffi = ["arrow-schema/ffi", "arrow-data/ffi"]
 force_validate = []
 
 [dev-dependencies]
-rand = { version = "0.9", default-features = false, features = ["std", "std_rng", "thread_rng"] }
+rand = { version = "0.8", default-features = false, features = ["std", "std_rng"] }
 criterion = { version = "0.5", default-features = false }
 
 [build-dependencies]

arrow-array/benches/fixed_size_list_array.rs

@@ -18,13 +18,13 @@
 use arrow_array::{Array, FixedSizeListArray, Int32Array};
 use arrow_schema::Field;
 use criterion::*;
-use rand::{rng, Rng};
+use rand::{thread_rng, Rng};
 use std::sync::Arc;
 
 fn gen_fsl(len: usize, value_len: usize) -> FixedSizeListArray {
-    let mut rng = rng();
+    let mut rng = thread_rng();
     let values = Arc::new(Int32Array::from(
-        (0..len).map(|_| rng.random::<i32>()).collect::<Vec<_>>(),
+        (0..len).map(|_| rng.gen::<i32>()).collect::<Vec<_>>(),
     ));
     let field = Arc::new(Field::new_list_field(values.data_type().clone(), true));
     FixedSizeListArray::new(field, value_len as i32, values, None)

arrow-array/benches/occupancy.rs

@@ -19,7 +19,7 @@ use arrow_array::types::Int32Type;
 use arrow_array::{DictionaryArray, Int32Array};
 use arrow_buffer::NullBuffer;
 use criterion::*;
-use rand::{rng, Rng};
+use rand::{thread_rng, Rng};
 use std::sync::Arc;
 
 fn gen_dict(
@@ -28,11 +28,11 @@ fn gen_dict(
     occupancy: f64,
     null_percent: f64,
 ) -> DictionaryArray<Int32Type> {
-    let mut rng = rng();
+    let mut rng = thread_rng();
     let values = Int32Array::from(vec![0; values_len]);
     let max_key = (values_len as f64 * occupancy) as i32;
-    let keys = (0..len).map(|_| rng.random_range(0..max_key)).collect();
-    let nulls = (0..len).map(|_| !rng.random_bool(null_percent)).collect();
+    let keys = (0..len).map(|_| rng.gen_range(0..max_key)).collect();
+    let nulls = (0..len).map(|_| !rng.gen_bool(null_percent)).collect();
 
     let keys = Int32Array::new(keys, Some(NullBuffer::new(nulls)));
     DictionaryArray::new(keys, Arc::new(values))

arrow-array/benches/union_array.rs

@@ -24,27 +24,27 @@ use arrow_array::{Array, ArrayRef, Int32Array, UnionArray};
 use arrow_buffer::{NullBuffer, ScalarBuffer};
 use arrow_schema::{DataType, Field, UnionFields};
 use criterion::*;
-use rand::{rng, Rng};
+use rand::{thread_rng, Rng};
 
 fn array_with_nulls() -> ArrayRef {
-    let mut rng = rng();
+    let mut rng = thread_rng();
 
-    let values = ScalarBuffer::from_iter(repeat_with(|| rng.random()).take(4096));
+    let values = ScalarBuffer::from_iter(repeat_with(|| rng.gen()).take(4096));
 
     // nulls with at least one null and one valid
     let nulls: NullBuffer = [true, false]
         .into_iter()
-        .chain(repeat_with(|| rng.random()))
+        .chain(repeat_with(|| rng.gen()))
         .take(4096)
         .collect();
 
     Arc::new(Int32Array::new(values.clone(), Some(nulls)))
 }
 
 fn array_without_nulls() -> ArrayRef {
-    let mut rng = rng();
+    let mut rng = thread_rng();
 
-    let values = ScalarBuffer::from_iter(repeat_with(|| rng.random()).take(4096));
+    let values = ScalarBuffer::from_iter(repeat_with(|| rng.gen()).take(4096));
 
     Arc::new(Int32Array::new(values.clone(), None))
 }

arrow-array/src/array/boolean_array.rs

@@ -479,7 +479,7 @@ impl From<BooleanBuffer> for BooleanArray {
 mod tests {
     use super::*;
     use arrow_buffer::Buffer;
-    use rand::{rng, Rng};
+    use rand::{thread_rng, Rng};
 
     #[test]
     fn test_boolean_fmt_debug() {
@@ -667,11 +667,11 @@ mod tests {
     #[test]
     #[cfg_attr(miri, ignore)] // Takes too long
     fn test_true_false_count() {
-        let mut rng = rng();
+        let mut rng = thread_rng();
 
         for _ in 0..10 {
             // No nulls
-            let d: Vec<_> = (0..2000).map(|_| rng.random_bool(0.5)).collect();
+            let d: Vec<_> = (0..2000).map(|_| rng.gen_bool(0.5)).collect();
             let b = BooleanArray::from(d.clone());
 
             let expected_true = d.iter().filter(|x| **x).count();
@@ -680,7 +680,7 @@ mod tests {
 
             // With nulls
             let d: Vec<_> = (0..2000)
-                .map(|_| rng.random_bool(0.5).then(|| rng.random_bool(0.5)))
+                .map(|_| rng.gen_bool(0.5).then(|| rng.gen_bool(0.5)))
                 .collect();
             let b = BooleanArray::from(d.clone());
 

arrow-array/src/array/run_array.rs

@@ -662,8 +662,8 @@ where
 
 #[cfg(test)]
 mod tests {
-    use rand::rng;
     use rand::seq::SliceRandom;
+    use rand::thread_rng;
     use rand::Rng;
 
     use super::*;
@@ -691,7 +691,7 @@ mod tests {
         ];
         let mut result: Vec<Option<i32>> = Vec::with_capacity(size);
         let mut ix = 0;
-        let mut rng = rng();
+        let mut rng = thread_rng();
         // run length can go up to 8. Cap the max run length for smaller arrays to size / 2.
         let max_run_length = 8_usize.min(1_usize.max(size / 2));
         while result.len() < size {
@@ -700,7 +700,7 @@ mod tests {
                 seed.shuffle(&mut rng);
             }
             // repeat the items between 1 and 8 times. Cap the length for smaller sized arrays
-            let num = max_run_length.min(rand::rng().random_range(1..=max_run_length));
+            let num = max_run_length.min(rand::thread_rng().gen_range(1..=max_run_length));
             for _ in 0..num {
                 result.push(seed[ix]);
             }
@@ -1000,7 +1000,7 @@ mod tests {
             let mut logical_indices: Vec<u32> = (0_u32..(logical_len as u32)).collect();
             // add same indices once more
             logical_indices.append(&mut logical_indices.clone());
-            let mut rng = rng();
+            let mut rng = thread_rng();
             logical_indices.shuffle(&mut rng);
 
             let physical_indices = run_array.get_physical_indices(&logical_indices).unwrap();
@@ -1036,7 +1036,7 @@ mod tests {
             let mut logical_indices: Vec<u32> = (0_u32..(slice_len as u32)).collect();
             // add same indices once more
             logical_indices.append(&mut logical_indices.clone());
-            let mut rng = rng();
+            let mut rng = thread_rng();
             logical_indices.shuffle(&mut rng);
 
             // test for offset = 0 and slice length = slice_len

arrow-array/src/run_iterator.rs

@@ -172,7 +172,7 @@ where
 
 #[cfg(test)]
 mod tests {
-    use rand::{rng, seq::SliceRandom, Rng};
+    use rand::{seq::SliceRandom, thread_rng, Rng};
 
     use crate::{
         array::{Int32Array, StringArray},
@@ -200,7 +200,7 @@ mod tests {
         ];
         let mut result: Vec<Option<i32>> = Vec::with_capacity(size);
         let mut ix = 0;
-        let mut rng = rng();
+        let mut rng = thread_rng();
         // run length can go up to 8. Cap the max run length for smaller arrays to size / 2.
         let max_run_length = 8_usize.min(1_usize.max(size / 2));
         while result.len() < size {
@@ -209,7 +209,7 @@ mod tests {
                 seed.shuffle(&mut rng);
             }
             // repeat the items between 1 and 8 times. Cap the length for smaller sized arrays
-            let num = max_run_length.min(rand::rng().random_range(1..=max_run_length));
+            let num = max_run_length.min(rand::thread_rng().gen_range(1..=max_run_length));
             for _ in 0..num {
                 result.push(seed[ix]);
             }

arrow-avro/Cargo.toml

@@ -51,4 +51,5 @@ crc = { version = "3.0", optional = true }
 
 
 [dev-dependencies]
-rand = { version = "0.9", default-features = false, features = ["std", "std_rng", "thread_rng"] }
+rand = { version = "0.8", default-features = false, features = ["std", "std_rng"] }
+

arrow-buffer/Cargo.toml

@@ -40,7 +40,7 @@ half = { version = "2.1", default-features = false }
 
 [dev-dependencies]
 criterion = { version = "0.5", default-features = false }
-rand = { version = "0.9", default-features = false, features = ["std", "std_rng", "thread_rng"] }
+rand = { version = "0.8", default-features = false, features = ["std", "std_rng"] }
 
 [build-dependencies]
 

arrow-buffer/benches/i256.rs

@@ -47,16 +47,16 @@ fn criterion_benchmark(c: &mut Criterion) {
 
     let numerators: Vec<_> = (0..SIZE)
         .map(|_| {
-            let high = rng.random_range(1000..i128::MAX);
-            let low = rng.random();
+            let high = rng.gen_range(1000..i128::MAX);
+            let low = rng.gen();
             i256::from_parts(low, high)
         })
         .collect();
 
     let divisors: Vec<_> = numerators
         .iter()
         .map(|n| {
-            let quotient = rng.random_range(1..100_i32);
+            let quotient = rng.gen_range(1..100_i32);
             n.wrapping_div(i256::from(quotient))
         })
         .collect();
@@ -70,7 +70,7 @@ fn criterion_benchmark(c: &mut Criterion) {
     });
 
     let divisors: Vec<_> = (0..SIZE)
-        .map(|_| i256::from(rng.random_range(1..100_i32)))
+        .map(|_| i256::from(rng.gen_range(1..100_i32)))
         .collect();
 
     c.bench_function("i256_div_rem small divisor", |b| {