Change all usages to global arc

Author: alamb

datafusion/common/src/config.rs

@@ -34,9 +34,7 @@ use std::collections::{BTreeMap, HashMap};
 use std::error::Error;
 use std::fmt::{self, Display};
 use std::str::FromStr;
-#[cfg(feature = "parquet_encryption")]
-use std::sync::Arc;
-use std::sync::LazyLock;
+use std::sync::{Arc, LazyLock};
 
 /// A macro that wraps a configuration struct and automatically derives
 /// [`Default`] and [`ConfigField`] for it, allowing it to be used

datafusion/core/tests/fuzz_cases/equivalence/ordering.rs

@@ -111,7 +111,7 @@ fn test_ordering_satisfy_with_equivalence_complex_random() -> Result<()> {
             Arc::clone(&test_fun),
             vec![col_a],
             &test_schema,
-            Arc::new(ConfigOptions::default()),
+            ConfigOptions::default_arc(),
         )?);
         let a_plus_b = Arc::new(BinaryExpr::new(
             col("a", &test_schema)?,

datafusion/core/tests/fuzz_cases/equivalence/projection.rs

@@ -50,7 +50,7 @@ fn project_orderings_random() -> Result<()> {
             Arc::clone(&test_fun),
             vec![col_a],
             &test_schema,
-            Arc::new(ConfigOptions::default()),
+            ConfigOptions::default_arc(),
         )?);
         // a + b
         let a_plus_b = Arc::new(BinaryExpr::new(
@@ -124,7 +124,7 @@ fn ordering_satisfy_after_projection_random() -> Result<()> {
             Arc::clone(&test_fun),
             vec![col_a],
             &test_schema,
-            Arc::new(ConfigOptions::default()),
+            ConfigOptions::default_arc(),
         )?) as PhysicalExprRef;
         // a + b
         let a_plus_b = Arc::new(BinaryExpr::new(

datafusion/core/tests/fuzz_cases/equivalence/properties.rs

@@ -50,7 +50,7 @@ fn test_find_longest_permutation_random() -> Result<()> {
             Arc::clone(&test_fun),
             vec![col_a],
             &test_schema,
-            Arc::new(ConfigOptions::default()),
+            ConfigOptions::default_arc(),
         )?) as _;
 
         let a_plus_b = Arc::new(BinaryExpr::new(

datafusion/core/tests/physical_optimizer/filter_pushdown.rs

@@ -98,7 +98,7 @@ fn test_pushdown_volatile_functions_not_allowed() {
     // Test that we do not push down filters with volatile functions
     // Use random() as an example of a volatile function
     let scan = TestScanBuilder::new(schema()).with_support(true).build();
-    let cfg = Arc::new(ConfigOptions::default());
+    let cfg = ConfigOptions::default_arc();
     let predicate = Arc::new(BinaryExpr::new(
         Arc::new(Column::new_with_schema("a", &schema()).unwrap()),
         Operator::Eq,
@@ -695,7 +695,7 @@ fn test_filter_with_fetch_partially_pushed_to_scan() {
     let scan = TestScanBuilder::new(schema()).with_support(true).build();
     let pushed_predicate = col_lit_predicate("a", "foo", &schema());
     let volatile_predicate = {
-        let cfg = Arc::new(ConfigOptions::default());
+        let cfg = ConfigOptions::default_arc();
         Arc::new(BinaryExpr::new(
             Arc::new(Column::new_with_schema("a", &schema()).unwrap()),
             Operator::Eq,

datafusion/core/tests/physical_optimizer/projection_pushdown.rs

@@ -130,7 +130,7 @@ fn test_update_matching_exprs() -> Result<()> {
                 )),
             ],
             Field::new("f", DataType::Int32, true).into(),
-            Arc::new(ConfigOptions::default()),
+            ConfigOptions::default_arc(),
         )),
         Arc::new(CaseExpr::try_new(
             Some(Arc::new(Column::new("d", 2))),
@@ -196,7 +196,7 @@ fn test_update_matching_exprs() -> Result<()> {
                 )),
             ],
             Field::new("f", DataType::Int32, true).into(),
-            Arc::new(ConfigOptions::default()),
+            ConfigOptions::default_arc(),
         )),
         Arc::new(CaseExpr::try_new(
             Some(Arc::new(Column::new("d", 3))),
@@ -271,7 +271,7 @@ fn test_update_projected_exprs() -> Result<()> {
                 )),
             ],
             Field::new("f", DataType::Int32, true).into(),
-            Arc::new(ConfigOptions::default()),
+            ConfigOptions::default_arc(),
         )),
         Arc::new(CaseExpr::try_new(
             Some(Arc::new(Column::new("d", 2))),
@@ -337,7 +337,7 @@ fn test_update_projected_exprs() -> Result<()> {
                 )),
             ],
             Field::new("f", DataType::Int32, true).into(),
-            Arc::new(ConfigOptions::default()),
+            ConfigOptions::default_arc(),
         )),
         Arc::new(CaseExpr::try_new(
             Some(Arc::new(Column::new("d_new", 3))),

datafusion/execution/src/config.rs

@@ -106,7 +106,7 @@ pub struct SessionConfig {
 impl Default for SessionConfig {
     fn default() -> Self {
         Self {
-            options: Arc::new(ConfigOptions::new()),
+            options: ConfigOptions::default_arc(),
             // Assume no extensions by default.
             extensions: HashMap::with_capacity_and_hasher(
                 0,

datafusion/expr/src/execution_props.rs

@@ -72,7 +72,7 @@ impl ExecutionProps {
 
     #[deprecated(since = "50.0.0", note = "Use mark_start_execution instead")]
     pub fn start_execution(&mut self) -> &Self {
-        let default_config = Arc::new(ConfigOptions::default());
+        let default_config = ConfigOptions::default_arc();
         self.mark_start_execution(default_config)
     }
 

datafusion/functions-nested/benches/array_has.rs

@@ -59,7 +59,7 @@ fn criterion_benchmark(c: &mut Criterion) {
 fn bench_array_has(c: &mut Criterion, array_size: usize) {
     let mut group = c.benchmark_group("array_has_i64");
     let list_array = create_int64_list_array(NUM_ROWS, array_size, NULL_DENSITY);
-    let config_options = Arc::new(ConfigOptions::default());
+    let config_options = ConfigOptions::default_arc();
     let return_field: Arc<Field> = Field::new("result", DataType::Boolean, true).into();
     let arg_fields: Vec<Arc<Field>> = vec![
         Field::new("arr", list_array.data_type().clone(), false).into(),
@@ -123,7 +123,7 @@ fn bench_array_has_all(c: &mut Criterion, array_size: usize) {
     let mut group = c.benchmark_group("array_has_all");
     let haystack = create_int64_list_array(NUM_ROWS, array_size, NULL_DENSITY);
     let list_type = haystack.data_type().clone();
-    let config_options = Arc::new(ConfigOptions::default());
+    let config_options = ConfigOptions::default_arc();
     let return_field: Arc<Field> = Field::new("result", DataType::Boolean, true).into();
     let arg_fields: Vec<Arc<Field>> = vec![
         Field::new("haystack", list_type.clone(), false).into(),
@@ -192,7 +192,7 @@ fn bench_array_has_any(c: &mut Criterion, array_size: usize) {
     let mut group = c.benchmark_group("array_has_any");
     let first_arr = create_int64_list_array(NUM_ROWS, array_size, NULL_DENSITY);
     let list_type = first_arr.data_type().clone();
-    let config_options = Arc::new(ConfigOptions::default());
+    let config_options = ConfigOptions::default_arc();
     let return_field: Arc<Field> = Field::new("result", DataType::Boolean, true).into();
     let arg_fields: Vec<Arc<Field>> = vec![
         Field::new("first", list_type.clone(), false).into(),
@@ -313,7 +313,7 @@ fn bench_array_has_any(c: &mut Criterion, array_size: usize) {
 
 fn bench_array_has_strings(c: &mut Criterion) {
     let mut group = c.benchmark_group("array_has_strings");
-    let config_options = Arc::new(ConfigOptions::default());
+    let config_options = ConfigOptions::default_arc();
     let return_field: Arc<Field> = Field::new("result", DataType::Boolean, true).into();
 
     let sizes = vec![10, 100, 500];
@@ -371,7 +371,7 @@ fn bench_array_has_strings(c: &mut Criterion) {
 
 fn bench_array_has_all_strings(c: &mut Criterion) {
     let mut group = c.benchmark_group("array_has_all_strings");
-    let config_options = Arc::new(ConfigOptions::default());
+    let config_options = ConfigOptions::default_arc();
     let return_field: Arc<Field> = Field::new("result", DataType::Boolean, true).into();
 
     let sizes = vec![10, 100, 500];
@@ -433,7 +433,7 @@ fn bench_array_has_all_strings(c: &mut Criterion) {
 
 fn bench_array_has_any_strings(c: &mut Criterion) {
     let mut group = c.benchmark_group("array_has_any_strings");
-    let config_options = Arc::new(ConfigOptions::default());
+    let config_options = ConfigOptions::default_arc();
     let return_field: Arc<Field> = Field::new("result", DataType::Boolean, true).into();
 
     let sizes = vec![10, 100, 500];
@@ -550,7 +550,7 @@ fn bench_array_has_any_strings(c: &mut Criterion) {
 /// size while keeping the columnar array small (3 elements per row).
 fn bench_array_has_any_scalar(c: &mut Criterion) {
     let mut group = c.benchmark_group("array_has_any_scalar");
-    let config_options = Arc::new(ConfigOptions::default());
+    let config_options = ConfigOptions::default_arc();
     let return_field: Arc<Field> = Field::new("result", DataType::Boolean, true).into();
 
     let array_size = 3;

datafusion/functions-nested/benches/array_position.rs

@@ -66,7 +66,7 @@ fn bench_array_position(c: &mut Criterion, array_size: usize) {
         Field::new("needle", DataType::Int64, false).into(),
     ];
     let return_field: Arc<Field> = Field::new("result", DataType::UInt64, true).into();
-    let config_options = Arc::new(ConfigOptions::default());
+    let config_options = ConfigOptions::default_arc();
     let needle = ScalarValue::Int64(Some(SENTINEL_NEEDLE));
 
     // Benchmark: one match per row.
@@ -175,7 +175,7 @@ fn bench_array_positions(c: &mut Criterion, array_size: usize) {
         true,
     )
     .into();
-    let config_options = Arc::new(ConfigOptions::default());
+    let config_options = ConfigOptions::default_arc();
     let needle = ScalarValue::Int64(Some(SENTINEL_NEEDLE));
 
     let args_found_once = vec![