merge

Author: comphead

datafusion/core/tests/fuzz_cases/aggregation_fuzzer/fuzzer.rs

@@ -21,7 +21,6 @@ use arrow::array::RecordBatch;
 use arrow::util::pretty::pretty_format_batches;
 use datafusion_common::{DataFusionError, Result};
 use datafusion_common_runtime::JoinSet;
-use rand::seq::SliceRandom;
 use rand::{rng, Rng};
 
 use crate::fuzz_cases::aggregation_fuzzer::query_builder::QueryBuilder;

datafusion/core/tests/fuzz_cases/aggregation_fuzzer/query_builder.rs

@@ -17,7 +17,7 @@
 
 use std::{collections::HashSet, str::FromStr};
 
-use rand::{seq::SliceRandom, thread_rng, Rng};
+use rand::{rng, seq::SliceRandom, Rng};
 
 /// Random aggregate query builder
 ///
@@ -277,8 +277,8 @@ impl QueryBuilder {
     /// * `alias` is a unique alias `colN` for the column (to avoid duplicate column names)
     fn random_aggregate_functions(&self, group_by_cols: &[String]) -> Vec<String> {
         const MAX_NUM_FUNCTIONS: usize = 5;
-        let mut rng = thread_rng();
-        let num_aggregate_functions = rng.gen_range(1..=MAX_NUM_FUNCTIONS);
+        let mut rng = rng();
+        let num_aggregate_functions = rng.random_range(1..=MAX_NUM_FUNCTIONS);
 
         let mut alias_gen = 1;
 
@@ -292,7 +292,7 @@ impl QueryBuilder {
         }
 
         while aggregate_functions.len() < num_aggregate_functions {
-            let idx = rng.gen_range(0..self.aggregate_functions.len());
+            let idx = rng.random_range(0..self.aggregate_functions.len());
             let (function_name, is_distinct) = &self.aggregate_functions[idx];
             let argument = self.random_argument();
             let alias = format!("col{alias_gen}");
@@ -320,8 +320,8 @@ impl QueryBuilder {
 
     /// Pick a random aggregate function argument
     fn random_argument(&self) -> String {
-        let mut rng = thread_rng();
-        let idx = rng.gen_range(0..self.arguments.len());
+        let mut rng = rng();
+        let idx = rng.random_range(0..self.arguments.len());
         self.arguments[idx].clone()
     }
 
@@ -333,25 +333,25 @@ impl QueryBuilder {
             .cloned()
             .collect();
 
-        available_columns.shuffle(&mut thread_rng());
+        available_columns.shuffle(&mut rng());
 
         let num_of_order_by_col = 12;
         let column_count = std::cmp::min(num_of_order_by_col, available_columns.len());
 
         let selected_columns = &available_columns[0..column_count];
 
-        let mut rng = thread_rng();
+        let mut rng = rng();
         let mut result = String::from_str(" order by ").unwrap();
         for col in selected_columns {
-            let order = if rng.gen_bool(0.5) { "ASC" } else { "DESC" };
+            let order = if rng.random_bool(0.5) { "ASC" } else { "DESC" };
             result.push_str(&format!("{col} {order},"));
         }
 
         result.strip_suffix(",").unwrap().to_string()
     }
 
     fn null_opt(&self) -> String {
-        if thread_rng().gen_bool(0.5) {
+        if rng().random_bool(0.5) {
             "RESPECT NULLS".to_string()
         } else {
             "IGNORE NULLS".to_string()
@@ -363,18 +363,18 @@ impl QueryBuilder {
     /// Limited to `max_group_by_columns` group by columns to ensure coverage for large groups.
     /// With larger numbers of columns, each group has many fewer values.
     fn random_group_by(&self) -> Vec<String> {
-        let mut rng = thread_rng();
+        let mut rng = rng();
         let min_groups = self.min_group_by_columns;
         let max_groups = self.max_group_by_columns;
         assert!(min_groups <= max_groups);
-        let num_group_by = rng.gen_range(min_groups..=max_groups);
+        let num_group_by = rng.random_range(min_groups..=max_groups);
 
         let mut already_used = HashSet::new();
         let mut group_by = vec![];
         while group_by.len() < num_group_by
             && already_used.len() != self.group_by_columns.len()
         {
-            let idx = rng.gen_range(0..self.group_by_columns.len());
+            let idx = rng.random_range(0..self.group_by_columns.len());
             if already_used.insert(idx) {
                 group_by.push(self.group_by_columns[idx].clone());
             }

datafusion/functions-aggregate/benches/array_agg.rs

@@ -27,7 +27,7 @@ use datafusion_expr::Accumulator;
 use datafusion_functions_aggregate::array_agg::ArrayAggAccumulator;
 
 use arrow::buffer::OffsetBuffer;
-use rand::distributions::{Distribution, Standard};
+use rand::distr::{Distribution, StandardUniform};
 use rand::prelude::StdRng;
 use rand::Rng;
 use rand::SeedableRng;
@@ -55,16 +55,16 @@ fn merge_batch_bench(c: &mut Criterion, name: &str, values: ArrayRef) {
 pub fn create_primitive_array<T>(size: usize, null_density: f32) -> PrimitiveArray<T>
 where
     T: ArrowPrimitiveType,
-    Standard: Distribution<T::Native>,
+    StandardUniform: Distribution<T::Native>,
 {
     let mut rng = seedable_rng();
 
     (0..size)
         .map(|_| {
-            if rng.gen::<f32>() < null_density {
+            if rng.random::<f32>() < null_density {
                 None
             } else {
-                Some(rng.gen())
+                Some(rng.random())
             }
         })
         .collect()
@@ -116,24 +116,6 @@ where
     )
 }
 
-fn create_primitive_array<T>(size: usize, null_density: f32) -> PrimitiveArray<T>
-where
-    T: ArrowPrimitiveType,
-    StandardUniform: Distribution<T::Native>,
-{
-    let mut rng = StdRng::seed_from_u64(42);
-
-    (0..size)
-        .map(|_| {
-            if rng.random::<f32>() < null_density {
-                None
-            } else {
-                Some(rng.random())
-            }
-        })
-        .collect()
-}
-
 fn array_agg_benchmark(c: &mut Criterion) {
     let values = Arc::new(create_list_array::<Int64Type>(8192, 0.0, 1.0)) as ArrayRef;
     merge_batch_bench(c, "array_agg i64 merge_batch no nulls", values);