diff --git a/datafusion-examples/examples/dataframe_in_memory.rs b/datafusion-examples/examples/dataframe_in_memory.rs index e76d65fc951b..0702573e4fa0 100644 --- a/datafusion-examples/examples/dataframe_in_memory.rs +++ b/datafusion-examples/examples/dataframe_in_memory.rs @@ -37,8 +37,8 @@ async fn main() -> Result<()> { let batch = RecordBatch::try_new( schema, vec![ - Arc::new(StringArray::from_slice(&["a", "b", "c", "d"])), - Arc::new(Int32Array::from_slice(&[1, 10, 10, 100])), + Arc::new(StringArray::from_slice(["a", "b", "c", "d"])), + Arc::new(Int32Array::from_slice([1, 10, 10, 100])), ], )?; diff --git a/datafusion-examples/examples/simple_udaf.rs b/datafusion-examples/examples/simple_udaf.rs index c35c214059a4..c71b1d7b0b63 100644 --- a/datafusion-examples/examples/simple_udaf.rs +++ b/datafusion-examples/examples/simple_udaf.rs @@ -38,11 +38,11 @@ fn create_context() -> Result { // define data in two partitions let batch1 = RecordBatch::try_new( schema.clone(), - vec![Arc::new(Float32Array::from_slice(&[2.0, 4.0, 8.0]))], + vec![Arc::new(Float32Array::from_slice([2.0, 4.0, 8.0]))], )?; let batch2 = RecordBatch::try_new( schema.clone(), - vec![Arc::new(Float32Array::from_slice(&[64.0]))], + vec![Arc::new(Float32Array::from_slice([64.0]))], )?; // declare a new context. In spark API, this corresponds to a new spark SQLsession diff --git a/datafusion-examples/examples/simple_udf.rs b/datafusion-examples/examples/simple_udf.rs index c0954d605e18..080e5ae6ef79 100644 --- a/datafusion-examples/examples/simple_udf.rs +++ b/datafusion-examples/examples/simple_udf.rs @@ -42,8 +42,8 @@ fn create_context() -> Result { let batch = RecordBatch::try_new( schema, vec![ - Arc::new(Float32Array::from_slice(&[2.1, 3.1, 4.1, 5.1])), - Arc::new(Float64Array::from_slice(&[1.0, 2.0, 3.0, 4.0])), + Arc::new(Float32Array::from_slice([2.1, 3.1, 4.1, 5.1])), + Arc::new(Float64Array::from_slice([1.0, 2.0, 3.0, 4.0])), ], )?; diff --git a/datafusion/common/src/bisect.rs b/datafusion/common/src/bisect.rs index 67fb003d0951..5060bf013120 100644 --- a/datafusion/common/src/bisect.rs +++ b/datafusion/common/src/bisect.rs @@ -98,10 +98,10 @@ mod tests { #[test] fn test_bisect_left_and_right() { let arrays: Vec = vec![ - Arc::new(Float64Array::from_slice(&[5.0, 7.0, 8.0, 9., 10.])), - Arc::new(Float64Array::from_slice(&[2.0, 3.0, 3.0, 4.0, 5.0])), - Arc::new(Float64Array::from_slice(&[5.0, 7.0, 8.0, 10., 11.0])), - Arc::new(Float64Array::from_slice(&[15.0, 13.0, 8.0, 5., 0.0])), + Arc::new(Float64Array::from_slice([5.0, 7.0, 8.0, 9., 10.])), + Arc::new(Float64Array::from_slice([2.0, 3.0, 3.0, 4.0, 5.0])), + Arc::new(Float64Array::from_slice([5.0, 7.0, 8.0, 10., 11.0])), + Arc::new(Float64Array::from_slice([15.0, 13.0, 8.0, 5., 0.0])), ]; let search_tuple: Vec = vec![ ScalarValue::Float64(Some(8.0)), @@ -169,7 +169,7 @@ mod tests { #[test] fn test_bisect_left_and_right_diff_sort() { // Descending, left - let arrays: Vec = vec![Arc::new(Float64Array::from_slice(&[ + let arrays: Vec = vec![Arc::new(Float64Array::from_slice([ 4.0, 3.0, 2.0, 1.0, 0.0, ]))]; let search_tuple: Vec = vec![ScalarValue::Float64(Some(4.0))]; @@ -181,7 +181,7 @@ mod tests { assert_eq!(res, 0); // Descending, right - let arrays: Vec = vec![Arc::new(Float64Array::from_slice(&[ + let arrays: Vec = vec![Arc::new(Float64Array::from_slice([ 4.0, 3.0, 2.0, 1.0, 0.0, ]))]; let search_tuple: Vec = vec![ScalarValue::Float64(Some(4.0))]; @@ -193,9 +193,8 @@ mod tests { assert_eq!(res, 1); // Ascending, left - let arrays: Vec = vec![Arc::new(Float64Array::from_slice(&[ - 5.0, 7.0, 8.0, 9., 10., - ]))]; + let arrays: Vec = + vec![Arc::new(Float64Array::from_slice([5.0, 7.0, 8.0, 9., 10.]))]; let search_tuple: Vec = vec![ScalarValue::Float64(Some(7.0))]; let ords = [SortOptions { descending: false, @@ -205,9 +204,8 @@ mod tests { assert_eq!(res, 1); // Ascending, right - let arrays: Vec = vec![Arc::new(Float64Array::from_slice(&[ - 5.0, 7.0, 8.0, 9., 10., - ]))]; + let arrays: Vec = + vec![Arc::new(Float64Array::from_slice([5.0, 7.0, 8.0, 9., 10.]))]; let search_tuple: Vec = vec![ScalarValue::Float64(Some(7.0))]; let ords = [SortOptions { descending: false, @@ -217,8 +215,8 @@ mod tests { assert_eq!(res, 2); let arrays: Vec = vec![ - Arc::new(Float64Array::from_slice(&[5.0, 7.0, 8.0, 8.0, 9., 10.])), - Arc::new(Float64Array::from_slice(&[10.0, 9.0, 8.0, 7.5, 7., 6.])), + Arc::new(Float64Array::from_slice([5.0, 7.0, 8.0, 8.0, 9., 10.])), + Arc::new(Float64Array::from_slice([10.0, 9.0, 8.0, 7.5, 7., 6.])), ]; let search_tuple: Vec = vec![ ScalarValue::Float64(Some(8.0)), diff --git a/datafusion/common/src/pyarrow.rs b/datafusion/common/src/pyarrow.rs index 6d9cab44cc9d..f88fd50d3ef7 100644 --- a/datafusion/common/src/pyarrow.rs +++ b/datafusion/common/src/pyarrow.rs @@ -39,7 +39,7 @@ impl PyArrowConvert for ScalarValue { // construct pyarrow array from the python value and pyarrow type let factory = py.import("pyarrow")?.getattr("array")?; - let args = PyList::new(py, &[val]); + let args = PyList::new(py, [val]); let array = factory.call1((args, typ))?; // convert the pyarrow array to rust array using C data interface diff --git a/datafusion/common/src/scalar.rs b/datafusion/common/src/scalar.rs index 7cb90fd64352..facc9ed427f0 100644 --- a/datafusion/common/src/scalar.rs +++ b/datafusion/common/src/scalar.rs @@ -3432,26 +3432,26 @@ mod tests { let expected = Arc::new(StructArray::from(vec![ ( field_a.clone(), - Arc::new(Int32Array::from_slice(&[23, 23])) as ArrayRef, + Arc::new(Int32Array::from_slice([23, 23])) as ArrayRef, ), ( field_b.clone(), - Arc::new(BooleanArray::from_slice(&[false, false])) as ArrayRef, + Arc::new(BooleanArray::from_slice([false, false])) as ArrayRef, ), ( field_c.clone(), - Arc::new(StringArray::from_slice(&["Hello", "Hello"])) as ArrayRef, + Arc::new(StringArray::from_slice(["Hello", "Hello"])) as ArrayRef, ), ( field_d.clone(), Arc::new(StructArray::from(vec![ ( field_e.clone(), - Arc::new(Int16Array::from_slice(&[2, 2])) as ArrayRef, + Arc::new(Int16Array::from_slice([2, 2])) as ArrayRef, ), ( field_f.clone(), - Arc::new(Int64Array::from_slice(&[3, 3])) as ArrayRef, + Arc::new(Int64Array::from_slice([3, 3])) as ArrayRef, ), ])) as ArrayRef, ), @@ -3527,15 +3527,15 @@ mod tests { let expected = Arc::new(StructArray::from(vec![ ( field_a, - Arc::new(Int32Array::from_slice(&[23, 7, -1000])) as ArrayRef, + Arc::new(Int32Array::from_slice([23, 7, -1000])) as ArrayRef, ), ( field_b, - Arc::new(BooleanArray::from_slice(&[false, true, true])) as ArrayRef, + Arc::new(BooleanArray::from_slice([false, true, true])) as ArrayRef, ), ( field_c, - Arc::new(StringArray::from_slice(&["Hello", "World", "!!!!!"])) + Arc::new(StringArray::from_slice(["Hello", "World", "!!!!!"])) as ArrayRef, ), ( @@ -3543,11 +3543,11 @@ mod tests { Arc::new(StructArray::from(vec![ ( field_e, - Arc::new(Int16Array::from_slice(&[2, 4, 6])) as ArrayRef, + Arc::new(Int16Array::from_slice([2, 4, 6])) as ArrayRef, ), ( field_f, - Arc::new(Int64Array::from_slice(&[3, 5, 7])) as ArrayRef, + Arc::new(Int64Array::from_slice([3, 5, 7])) as ArrayRef, ), ])) as ArrayRef, ), @@ -3608,7 +3608,7 @@ mod tests { let expected = StructArray::from(vec![ ( field_a.clone(), - Arc::new(StringArray::from_slice(&["First", "Second", "Third"])) + Arc::new(StringArray::from_slice(["First", "Second", "Third"])) as ArrayRef, ), ( diff --git a/datafusion/core/src/datasource/listing/table.rs b/datafusion/core/src/datasource/listing/table.rs index deaa09249e11..61ee1a0287b6 100644 --- a/datafusion/core/src/datasource/listing/table.rs +++ b/datafusion/core/src/datasource/listing/table.rs @@ -143,7 +143,7 @@ impl ListingTableConfig { pub async fn infer_options(self, ctx: &SessionState) -> Result { let store = ctx .runtime_env - .object_store(&self.table_paths.get(0).unwrap())?; + .object_store(self.table_paths.get(0).unwrap())?; let file = self .table_paths @@ -442,7 +442,7 @@ impl ListingTable { ) -> Result<(Vec>, Statistics)> { let store = ctx .runtime_env - .object_store(&self.table_paths.get(0).unwrap())?; + .object_store(self.table_paths.get(0).unwrap())?; // list files (with partitions) let file_list = future::try_join_all(self.table_paths.iter().map(|table_path| { pruned_partition_list( diff --git a/datafusion/core/src/datasource/memory.rs b/datafusion/core/src/datasource/memory.rs index d965324d818f..4e5238ed2ecc 100644 --- a/datafusion/core/src/datasource/memory.rs +++ b/datafusion/core/src/datasource/memory.rs @@ -172,9 +172,9 @@ mod tests { let batch = RecordBatch::try_new( schema.clone(), vec![ - Arc::new(Int32Array::from_slice(&[1, 2, 3])), - Arc::new(Int32Array::from_slice(&[4, 5, 6])), - Arc::new(Int32Array::from_slice(&[7, 8, 9])), + Arc::new(Int32Array::from_slice([1, 2, 3])), + Arc::new(Int32Array::from_slice([4, 5, 6])), + Arc::new(Int32Array::from_slice([7, 8, 9])), Arc::new(Int32Array::from(vec![None, None, Some(9)])), ], )?; @@ -209,9 +209,9 @@ mod tests { let batch = RecordBatch::try_new( schema.clone(), vec![ - Arc::new(Int32Array::from_slice(&[1, 2, 3])), - Arc::new(Int32Array::from_slice(&[4, 5, 6])), - Arc::new(Int32Array::from_slice(&[7, 8, 9])), + Arc::new(Int32Array::from_slice([1, 2, 3])), + Arc::new(Int32Array::from_slice([4, 5, 6])), + Arc::new(Int32Array::from_slice([7, 8, 9])), ], )?; @@ -241,9 +241,9 @@ mod tests { let batch = RecordBatch::try_new( schema.clone(), vec![ - Arc::new(Int32Array::from_slice(&[1, 2, 3])), - Arc::new(Int32Array::from_slice(&[4, 5, 6])), - Arc::new(Int32Array::from_slice(&[7, 8, 9])), + Arc::new(Int32Array::from_slice([1, 2, 3])), + Arc::new(Int32Array::from_slice([4, 5, 6])), + Arc::new(Int32Array::from_slice([7, 8, 9])), ], )?; @@ -284,9 +284,9 @@ mod tests { let batch = RecordBatch::try_new( schema1, vec![ - Arc::new(Int32Array::from_slice(&[1, 2, 3])), - Arc::new(Int32Array::from_slice(&[4, 5, 6])), - Arc::new(Int32Array::from_slice(&[7, 8, 9])), + Arc::new(Int32Array::from_slice([1, 2, 3])), + Arc::new(Int32Array::from_slice([4, 5, 6])), + Arc::new(Int32Array::from_slice([7, 8, 9])), ], )?; @@ -317,8 +317,8 @@ mod tests { let batch = RecordBatch::try_new( schema1, vec![ - Arc::new(Int32Array::from_slice(&[1, 2, 3])), - Arc::new(Int32Array::from_slice(&[7, 5, 9])), + Arc::new(Int32Array::from_slice([1, 2, 3])), + Arc::new(Int32Array::from_slice([7, 5, 9])), ], )?; @@ -362,18 +362,18 @@ mod tests { let batch1 = RecordBatch::try_new( Arc::new(schema1), vec![ - Arc::new(Int32Array::from_slice(&[1, 2, 3])), - Arc::new(Int32Array::from_slice(&[4, 5, 6])), - Arc::new(Int32Array::from_slice(&[7, 8, 9])), + Arc::new(Int32Array::from_slice([1, 2, 3])), + Arc::new(Int32Array::from_slice([4, 5, 6])), + Arc::new(Int32Array::from_slice([7, 8, 9])), ], )?; let batch2 = RecordBatch::try_new( Arc::new(schema2), vec![ - Arc::new(Int32Array::from_slice(&[1, 2, 3])), - Arc::new(Int32Array::from_slice(&[4, 5, 6])), - Arc::new(Int32Array::from_slice(&[7, 8, 9])), + Arc::new(Int32Array::from_slice([1, 2, 3])), + Arc::new(Int32Array::from_slice([4, 5, 6])), + Arc::new(Int32Array::from_slice([7, 8, 9])), ], )?; diff --git a/datafusion/core/src/physical_optimizer/coalesce_batches.rs b/datafusion/core/src/physical_optimizer/coalesce_batches.rs index 9f7e22dbb085..913046e954c1 100644 --- a/datafusion/core/src/physical_optimizer/coalesce_batches.rs +++ b/datafusion/core/src/physical_optimizer/coalesce_batches.rs @@ -46,7 +46,7 @@ impl PhysicalOptimizerRule for CoalesceBatches { fn optimize( &self, plan: Arc, - config: &crate::execution::context::SessionConfig, + _config: &crate::execution::context::SessionConfig, ) -> Result> { if plan.children().is_empty() { // leaf node, children cannot be replaced @@ -56,7 +56,7 @@ impl PhysicalOptimizerRule for CoalesceBatches { let children = plan .children() .iter() - .map(|child| self.optimize(child.clone(), config)) + .map(|child| self.optimize(child.clone(), _config)) .collect::>>()?; let plan = with_new_children_if_necessary(plan, children)?; // The goal here is to detect operators that could produce small batches and only diff --git a/datafusion/core/src/physical_optimizer/merge_exec.rs b/datafusion/core/src/physical_optimizer/merge_exec.rs index f614673f500e..960d0582fd81 100644 --- a/datafusion/core/src/physical_optimizer/merge_exec.rs +++ b/datafusion/core/src/physical_optimizer/merge_exec.rs @@ -41,7 +41,7 @@ impl PhysicalOptimizerRule for AddCoalescePartitionsExec { fn optimize( &self, plan: Arc, - config: &crate::execution::context::SessionConfig, + _config: &crate::execution::context::SessionConfig, ) -> Result> { if plan.children().is_empty() { // leaf node, children cannot be replaced @@ -50,7 +50,7 @@ impl PhysicalOptimizerRule for AddCoalescePartitionsExec { let children = plan .children() .iter() - .map(|child| self.optimize(child.clone(), config)) + .map(|child| self.optimize(child.clone(), _config)) .collect::>>()?; match plan.required_child_distribution() { Distribution::UnspecifiedDistribution => { diff --git a/datafusion/core/src/physical_optimizer/pruning.rs b/datafusion/core/src/physical_optimizer/pruning.rs index d33082cd87b8..0907efc9c04f 100644 --- a/datafusion/core/src/physical_optimizer/pruning.rs +++ b/datafusion/core/src/physical_optimizer/pruning.rs @@ -1219,7 +1219,7 @@ mod tests { // Note the statistics return binary (which can't be cast to string) let statistics = OneContainerStats { - min_values: Some(Arc::new(BinaryArray::from_slice(&[&[255u8] as &[u8]]))), + min_values: Some(Arc::new(BinaryArray::from_slice([&[255u8] as &[u8]]))), max_values: None, num_containers: 1, }; diff --git a/datafusion/core/src/physical_plan/aggregates/mod.rs b/datafusion/core/src/physical_plan/aggregates/mod.rs index 2c4a9b26c399..e453b65cc94c 100644 --- a/datafusion/core/src/physical_plan/aggregates/mod.rs +++ b/datafusion/core/src/physical_plan/aggregates/mod.rs @@ -683,16 +683,16 @@ mod tests { RecordBatch::try_new( schema.clone(), vec![ - Arc::new(UInt32Array::from_slice(&[2, 3, 4, 4])), - Arc::new(Float64Array::from_slice(&[1.0, 2.0, 3.0, 4.0])), + Arc::new(UInt32Array::from_slice([2, 3, 4, 4])), + Arc::new(Float64Array::from_slice([1.0, 2.0, 3.0, 4.0])), ], ) .unwrap(), RecordBatch::try_new( schema, vec![ - Arc::new(UInt32Array::from_slice(&[2, 3, 3, 4])), - Arc::new(Float64Array::from_slice(&[1.0, 2.0, 3.0, 4.0])), + Arc::new(UInt32Array::from_slice([2, 3, 3, 4])), + Arc::new(Float64Array::from_slice([1.0, 2.0, 3.0, 4.0])), ], ) .unwrap(), diff --git a/datafusion/core/src/physical_plan/common.rs b/datafusion/core/src/physical_plan/common.rs index eab4f25eefc7..4c6a624e7e93 100644 --- a/datafusion/core/src/physical_plan/common.rs +++ b/datafusion/core/src/physical_plan/common.rs @@ -366,8 +366,8 @@ mod tests { let batch = RecordBatch::try_new( Arc::clone(&schema), vec![ - Arc::new(Float32Array::from_slice(&[1., 2., 3.])), - Arc::new(Float64Array::from_slice(&[9., 8., 7.])), + Arc::new(Float32Array::from_slice([1., 2., 3.])), + Arc::new(Float64Array::from_slice([9., 8., 7.])), ], )?; let actual = diff --git a/datafusion/core/src/physical_plan/memory.rs b/datafusion/core/src/physical_plan/memory.rs index d2dbe0d738c3..698eaf12a273 100644 --- a/datafusion/core/src/physical_plan/memory.rs +++ b/datafusion/core/src/physical_plan/memory.rs @@ -238,10 +238,10 @@ mod tests { let batch = RecordBatch::try_new( schema.clone(), vec![ - Arc::new(Int32Array::from_slice(&[1, 2, 3])), - Arc::new(Int32Array::from_slice(&[4, 5, 6])), + Arc::new(Int32Array::from_slice([1, 2, 3])), + Arc::new(Int32Array::from_slice([4, 5, 6])), Arc::new(Int32Array::from(vec![None, None, Some(9)])), - Arc::new(Int32Array::from_slice(&[7, 8, 9])), + Arc::new(Int32Array::from_slice([7, 8, 9])), ], )?; diff --git a/datafusion/core/src/physical_plan/repartition.rs b/datafusion/core/src/physical_plan/repartition.rs index 5611989f0ea9..4c057b1d6c52 100644 --- a/datafusion/core/src/physical_plan/repartition.rs +++ b/datafusion/core/src/physical_plan/repartition.rs @@ -729,7 +729,7 @@ mod tests { // have to send at least one batch through to provoke error let batch = RecordBatch::try_from_iter(vec![( "my_awesome_field", - Arc::new(StringArray::from_slice(&["foo", "bar"])) as ArrayRef, + Arc::new(StringArray::from_slice(["foo", "bar"])) as ArrayRef, )]) .unwrap(); @@ -788,7 +788,7 @@ mod tests { let task_ctx = session_ctx.task_ctx(); let batch = RecordBatch::try_from_iter(vec![( "my_awesome_field", - Arc::new(StringArray::from_slice(&["foo", "bar"])) as ArrayRef, + Arc::new(StringArray::from_slice(["foo", "bar"])) as ArrayRef, )]) .unwrap(); @@ -823,13 +823,13 @@ mod tests { let task_ctx = session_ctx.task_ctx(); let batch1 = RecordBatch::try_from_iter(vec![( "my_awesome_field", - Arc::new(StringArray::from_slice(&["foo", "bar"])) as ArrayRef, + Arc::new(StringArray::from_slice(["foo", "bar"])) as ArrayRef, )]) .unwrap(); let batch2 = RecordBatch::try_from_iter(vec![( "my_awesome_field", - Arc::new(StringArray::from_slice(&["frob", "baz"])) as ArrayRef, + Arc::new(StringArray::from_slice(["frob", "baz"])) as ArrayRef, )]) .unwrap(); @@ -978,25 +978,25 @@ mod tests { fn make_barrier_exec() -> BarrierExec { let batch1 = RecordBatch::try_from_iter(vec![( "my_awesome_field", - Arc::new(StringArray::from_slice(&["foo", "bar"])) as ArrayRef, + Arc::new(StringArray::from_slice(["foo", "bar"])) as ArrayRef, )]) .unwrap(); let batch2 = RecordBatch::try_from_iter(vec![( "my_awesome_field", - Arc::new(StringArray::from_slice(&["frob", "baz"])) as ArrayRef, + Arc::new(StringArray::from_slice(["frob", "baz"])) as ArrayRef, )]) .unwrap(); let batch3 = RecordBatch::try_from_iter(vec![( "my_awesome_field", - Arc::new(StringArray::from_slice(&["goo", "gar"])) as ArrayRef, + Arc::new(StringArray::from_slice(["goo", "gar"])) as ArrayRef, )]) .unwrap(); let batch4 = RecordBatch::try_from_iter(vec![( "my_awesome_field", - Arc::new(StringArray::from_slice(&["grob", "gaz"])) as ArrayRef, + Arc::new(StringArray::from_slice(["grob", "gaz"])) as ArrayRef, )]) .unwrap(); @@ -1036,7 +1036,7 @@ mod tests { let task_ctx = session_ctx.task_ctx(); let batch = RecordBatch::try_from_iter(vec![( "a", - Arc::new(StringArray::from_slice(&["foo"])) as ArrayRef, + Arc::new(StringArray::from_slice(["foo"])) as ArrayRef, )]) .unwrap(); let partitioning = Partitioning::Hash( diff --git a/datafusion/core/src/physical_plan/sorts/sort.rs b/datafusion/core/src/physical_plan/sorts/sort.rs index 763c7c553f41..cd14f27b6b23 100644 --- a/datafusion/core/src/physical_plan/sorts/sort.rs +++ b/datafusion/core/src/physical_plan/sorts/sort.rs @@ -652,7 +652,7 @@ fn write_sorted( } fn read_spill(sender: Sender>, path: &Path) -> Result<()> { - let file = BufReader::new(File::open(&path)?); + let file = BufReader::new(File::open(path)?); let reader = FileReader::try_new(file, None)?; for batch in reader { sender diff --git a/datafusion/core/src/physical_plan/sorts/sort_preserving_merge.rs b/datafusion/core/src/physical_plan/sorts/sort_preserving_merge.rs index 22bd83ec9ae8..a8c6fe4e6a93 100644 --- a/datafusion/core/src/physical_plan/sorts/sort_preserving_merge.rs +++ b/datafusion/core/src/physical_plan/sorts/sort_preserving_merge.rs @@ -644,7 +644,7 @@ mod tests { async fn test_merge_interleave() { let session_ctx = SessionContext::new(); let task_ctx = session_ctx.task_ctx(); - let a: ArrayRef = Arc::new(Int32Array::from_slice(&[1, 2, 7, 9, 3])); + let a: ArrayRef = Arc::new(Int32Array::from_slice([1, 2, 7, 9, 3])); let b: ArrayRef = Arc::new(StringArray::from_iter(vec![ Some("a"), Some("c"), @@ -655,7 +655,7 @@ mod tests { let c: ArrayRef = Arc::new(TimestampNanosecondArray::from(vec![8, 7, 6, 5, 8])); let b1 = RecordBatch::try_from_iter(vec![("a", a), ("b", b), ("c", c)]).unwrap(); - let a: ArrayRef = Arc::new(Int32Array::from_slice(&[10, 20, 70, 90, 30])); + let a: ArrayRef = Arc::new(Int32Array::from_slice([10, 20, 70, 90, 30])); let b: ArrayRef = Arc::new(StringArray::from_iter(vec![ Some("b"), Some("d"), @@ -693,7 +693,7 @@ mod tests { async fn test_merge_some_overlap() { let session_ctx = SessionContext::new(); let task_ctx = session_ctx.task_ctx(); - let a: ArrayRef = Arc::new(Int32Array::from_slice(&[1, 2, 7, 9, 3])); + let a: ArrayRef = Arc::new(Int32Array::from_slice([1, 2, 7, 9, 3])); let b: ArrayRef = Arc::new(StringArray::from_iter(vec![ Some("a"), Some("b"), @@ -704,7 +704,7 @@ mod tests { let c: ArrayRef = Arc::new(TimestampNanosecondArray::from(vec![8, 7, 6, 5, 8])); let b1 = RecordBatch::try_from_iter(vec![("a", a), ("b", b), ("c", c)]).unwrap(); - let a: ArrayRef = Arc::new(Int32Array::from_slice(&[70, 90, 30, 100, 110])); + let a: ArrayRef = Arc::new(Int32Array::from_slice([70, 90, 30, 100, 110])); let b: ArrayRef = Arc::new(StringArray::from_iter(vec![ Some("c"), Some("d"), @@ -742,7 +742,7 @@ mod tests { async fn test_merge_no_overlap() { let session_ctx = SessionContext::new(); let task_ctx = session_ctx.task_ctx(); - let a: ArrayRef = Arc::new(Int32Array::from_slice(&[1, 2, 7, 9, 3])); + let a: ArrayRef = Arc::new(Int32Array::from_slice([1, 2, 7, 9, 3])); let b: ArrayRef = Arc::new(StringArray::from_iter(vec![ Some("a"), Some("b"), @@ -753,7 +753,7 @@ mod tests { let c: ArrayRef = Arc::new(TimestampNanosecondArray::from(vec![8, 7, 6, 5, 8])); let b1 = RecordBatch::try_from_iter(vec![("a", a), ("b", b), ("c", c)]).unwrap(); - let a: ArrayRef = Arc::new(Int32Array::from_slice(&[10, 20, 70, 90, 30])); + let a: ArrayRef = Arc::new(Int32Array::from_slice([10, 20, 70, 90, 30])); let b: ArrayRef = Arc::new(StringArray::from_iter(vec![ Some("f"), Some("g"), @@ -791,7 +791,7 @@ mod tests { async fn test_merge_three_partitions() { let session_ctx = SessionContext::new(); let task_ctx = session_ctx.task_ctx(); - let a: ArrayRef = Arc::new(Int32Array::from_slice(&[1, 2, 7, 9, 3])); + let a: ArrayRef = Arc::new(Int32Array::from_slice([1, 2, 7, 9, 3])); let b: ArrayRef = Arc::new(StringArray::from_iter(vec![ Some("a"), Some("b"), @@ -802,7 +802,7 @@ mod tests { let c: ArrayRef = Arc::new(TimestampNanosecondArray::from(vec![8, 7, 6, 5, 8])); let b1 = RecordBatch::try_from_iter(vec![("a", a), ("b", b), ("c", c)]).unwrap(); - let a: ArrayRef = Arc::new(Int32Array::from_slice(&[10, 20, 70, 90, 30])); + let a: ArrayRef = Arc::new(Int32Array::from_slice([10, 20, 70, 90, 30])); let b: ArrayRef = Arc::new(StringArray::from_iter(vec![ Some("e"), Some("g"), @@ -814,7 +814,7 @@ mod tests { Arc::new(TimestampNanosecondArray::from(vec![40, 60, 20, 20, 60])); let b2 = RecordBatch::try_from_iter(vec![("a", a), ("b", b), ("c", c)]).unwrap(); - let a: ArrayRef = Arc::new(Int32Array::from_slice(&[100, 200, 700, 900, 300])); + let a: ArrayRef = Arc::new(Int32Array::from_slice([100, 200, 700, 900, 300])); let b: ArrayRef = Arc::new(StringArray::from_iter(vec![ Some("f"), Some("g"), @@ -1093,7 +1093,7 @@ mod tests { async fn test_nulls() { let session_ctx = SessionContext::new(); let task_ctx = session_ctx.task_ctx(); - let a: ArrayRef = Arc::new(Int32Array::from_slice(&[1, 2, 7, 9, 3])); + let a: ArrayRef = Arc::new(Int32Array::from_slice([1, 2, 7, 9, 3])); let b: ArrayRef = Arc::new(StringArray::from_iter(vec![ None, Some("a"), @@ -1110,7 +1110,7 @@ mod tests { ])); let b1 = RecordBatch::try_from_iter(vec![("a", a), ("b", b), ("c", c)]).unwrap(); - let a: ArrayRef = Arc::new(Int32Array::from_slice(&[1, 2, 3, 4, 5])); + let a: ArrayRef = Arc::new(Int32Array::from_slice([1, 2, 3, 4, 5])); let b: ArrayRef = Arc::new(StringArray::from_iter(vec![ None, Some("b"), @@ -1240,11 +1240,11 @@ mod tests { async fn test_merge_metrics() { let session_ctx = SessionContext::new(); let task_ctx = session_ctx.task_ctx(); - let a: ArrayRef = Arc::new(Int32Array::from_slice(&[1, 2])); + let a: ArrayRef = Arc::new(Int32Array::from_slice([1, 2])); let b: ArrayRef = Arc::new(StringArray::from_iter(vec![Some("a"), Some("c")])); let b1 = RecordBatch::try_from_iter(vec![("a", a), ("b", b)]).unwrap(); - let a: ArrayRef = Arc::new(Int32Array::from_slice(&[10, 20])); + let a: ArrayRef = Arc::new(Int32Array::from_slice([10, 20])); let b: ArrayRef = Arc::new(StringArray::from_iter(vec![Some("b"), Some("d")])); let b2 = RecordBatch::try_from_iter(vec![("a", a), ("b", b)]).unwrap(); diff --git a/datafusion/core/src/test/mod.rs b/datafusion/core/src/test/mod.rs index bce277676dea..f5c37eb053f0 100644 --- a/datafusion/core/src/test/mod.rs +++ b/datafusion/core/src/test/mod.rs @@ -53,8 +53,8 @@ pub fn create_table_dual() -> Arc { let batch = RecordBatch::try_new( dual_schema.clone(), vec![ - Arc::new(array::Int32Array::from_slice(&[1])), - Arc::new(array::StringArray::from_slice(&["a"])), + Arc::new(array::Int32Array::from_slice([1])), + Arc::new(array::StringArray::from_slice(["a"])), ], ) .unwrap(); @@ -282,7 +282,7 @@ pub fn create_vec_batches(schema: &Schema, n: usize) -> Vec { fn create_batch(schema: &Schema) -> RecordBatch { RecordBatch::try_new( Arc::new(schema.clone()), - vec![Arc::new(UInt32Array::from_slice(&[1, 2, 3, 4, 5, 6, 7, 8]))], + vec![Arc::new(UInt32Array::from_slice([1, 2, 3, 4, 5, 6, 7, 8]))], ) .unwrap() } diff --git a/datafusion/core/tests/custom_sources.rs b/datafusion/core/tests/custom_sources.rs index 14daf7b6d60f..317f2983be55 100644 --- a/datafusion/core/tests/custom_sources.rs +++ b/datafusion/core/tests/custom_sources.rs @@ -287,9 +287,9 @@ async fn optimizers_catch_all_statistics() { Field::new("MAX(test.c1)", DataType::Int32, false), ])), vec![ - Arc::new(Int64Array::from_slice(&[4])), - Arc::new(Int32Array::from_slice(&[1])), - Arc::new(Int32Array::from_slice(&[100])), + Arc::new(Int64Array::from_slice([4])), + Arc::new(Int32Array::from_slice([1])), + Arc::new(Int32Array::from_slice([100])), ], ) .unwrap(); diff --git a/datafusion/core/tests/dataframe.rs b/datafusion/core/tests/dataframe.rs index 2925320e064d..57df7e32afdb 100644 --- a/datafusion/core/tests/dataframe.rs +++ b/datafusion/core/tests/dataframe.rs @@ -48,16 +48,16 @@ async fn join() -> Result<()> { let batch1 = RecordBatch::try_new( schema1.clone(), vec![ - Arc::new(StringArray::from_slice(&["a", "b", "c", "d"])), - Arc::new(Int32Array::from_slice(&[1, 10, 10, 100])), + Arc::new(StringArray::from_slice(["a", "b", "c", "d"])), + Arc::new(Int32Array::from_slice([1, 10, 10, 100])), ], )?; // define data. let batch2 = RecordBatch::try_new( schema2.clone(), vec![ - Arc::new(StringArray::from_slice(&["a", "b", "c", "d"])), - Arc::new(Int32Array::from_slice(&[1, 10, 10, 100])), + Arc::new(StringArray::from_slice(["a", "b", "c", "d"])), + Arc::new(Int32Array::from_slice([1, 10, 10, 100])), ], )?; @@ -90,8 +90,8 @@ async fn sort_on_unprojected_columns() -> Result<()> { let batch = RecordBatch::try_new( Arc::new(schema.clone()), vec![ - Arc::new(Int32Array::from_slice(&[1, 10, 10, 100])), - Arc::new(Int32Array::from_slice(&[2, 12, 12, 120])), + Arc::new(Int32Array::from_slice([1, 10, 10, 100])), + Arc::new(Int32Array::from_slice([2, 12, 12, 120])), ], ) .unwrap(); @@ -134,7 +134,7 @@ async fn filter_with_alias_overwrite() -> Result<()> { let batch = RecordBatch::try_new( Arc::new(schema.clone()), - vec![Arc::new(Int32Array::from_slice(&[1, 10, 10, 100]))], + vec![Arc::new(Int32Array::from_slice([1, 10, 10, 100]))], ) .unwrap(); @@ -170,7 +170,7 @@ async fn select_with_alias_overwrite() -> Result<()> { let batch = RecordBatch::try_new( Arc::new(schema.clone()), - vec![Arc::new(Int32Array::from_slice(&[1, 10, 10, 100]))], + vec![Arc::new(Int32Array::from_slice([1, 10, 10, 100]))], ) .unwrap(); @@ -390,13 +390,13 @@ fn create_test_table() -> Result> { let batch = RecordBatch::try_new( schema, vec![ - Arc::new(StringArray::from_slice(&[ + Arc::new(StringArray::from_slice([ "abcDEF", "abc123", "CBAdef", "123AbcDef", ])), - Arc::new(Int32Array::from_slice(&[1, 10, 10, 100])), + Arc::new(Int32Array::from_slice([1, 10, 10, 100])), ], )?; diff --git a/datafusion/core/tests/dataframe_functions.rs b/datafusion/core/tests/dataframe_functions.rs index 92322653dddd..276aa4e16342 100644 --- a/datafusion/core/tests/dataframe_functions.rs +++ b/datafusion/core/tests/dataframe_functions.rs @@ -44,13 +44,13 @@ fn create_test_table() -> Result> { let batch = RecordBatch::try_new( schema, vec![ - Arc::new(StringArray::from_slice(&[ + Arc::new(StringArray::from_slice([ "abcDEF", "abc123", "CBAdef", "123AbcDef", ])), - Arc::new(Int32Array::from_slice(&[1, 10, 10, 100])), + Arc::new(Int32Array::from_slice([1, 10, 10, 100])), ], )?; diff --git a/datafusion/core/tests/sql/aggregates.rs b/datafusion/core/tests/sql/aggregates.rs index 4a728a0091f6..1d2e41254b1a 100644 --- a/datafusion/core/tests/sql/aggregates.rs +++ b/datafusion/core/tests/sql/aggregates.rs @@ -2016,11 +2016,11 @@ async fn simple_avg() -> Result<()> { let batch1 = RecordBatch::try_new( Arc::new(schema.clone()), - vec![Arc::new(Int32Array::from_slice(&[1, 2, 3]))], + vec![Arc::new(Int32Array::from_slice([1, 2, 3]))], )?; let batch2 = RecordBatch::try_new( Arc::new(schema.clone()), - vec![Arc::new(Int32Array::from_slice(&[4, 5]))], + vec![Arc::new(Int32Array::from_slice([4, 5]))], )?; let ctx = SessionContext::new(); @@ -2051,11 +2051,11 @@ async fn simple_mean() -> Result<()> { let batch1 = RecordBatch::try_new( Arc::new(schema.clone()), - vec![Arc::new(Int32Array::from_slice(&[1, 2, 3]))], + vec![Arc::new(Int32Array::from_slice([1, 2, 3]))], )?; let batch2 = RecordBatch::try_new( Arc::new(schema.clone()), - vec![Arc::new(Int32Array::from_slice(&[4, 5]))], + vec![Arc::new(Int32Array::from_slice([4, 5]))], )?; let ctx = SessionContext::new(); diff --git a/datafusion/core/tests/sql/functions.rs b/datafusion/core/tests/sql/functions.rs index 2b47d893af5b..615871076e3b 100644 --- a/datafusion/core/tests/sql/functions.rs +++ b/datafusion/core/tests/sql/functions.rs @@ -86,7 +86,7 @@ async fn query_concat() -> Result<()> { let data = RecordBatch::try_new( schema.clone(), vec![ - Arc::new(StringArray::from_slice(&["", "a", "aa", "aaa"])), + Arc::new(StringArray::from_slice(["", "a", "aa", "aaa"])), Arc::new(Int32Array::from(vec![Some(0), Some(1), None, Some(3)])), ], )?; @@ -119,7 +119,7 @@ async fn query_array() -> Result<()> { let data = RecordBatch::try_new( schema.clone(), vec![ - Arc::new(StringArray::from_slice(&["", "a", "aa", "aaa"])), + Arc::new(StringArray::from_slice(["", "a", "aa", "aaa"])), Arc::new(Int32Array::from(vec![Some(0), Some(1), None, Some(3)])), ], )?; @@ -381,43 +381,43 @@ async fn case_builtin_math_expression() { let type_values = vec![ ( DataType::Int8, - Arc::new(Int8Array::from_slice(&[1])) as ArrayRef, + Arc::new(Int8Array::from_slice([1])) as ArrayRef, ), ( DataType::Int16, - Arc::new(Int16Array::from_slice(&[1])) as ArrayRef, + Arc::new(Int16Array::from_slice([1])) as ArrayRef, ), ( DataType::Int32, - Arc::new(Int32Array::from_slice(&[1])) as ArrayRef, + Arc::new(Int32Array::from_slice([1])) as ArrayRef, ), ( DataType::Int64, - Arc::new(Int64Array::from_slice(&[1])) as ArrayRef, + Arc::new(Int64Array::from_slice([1])) as ArrayRef, ), ( DataType::UInt8, - Arc::new(UInt8Array::from_slice(&[1])) as ArrayRef, + Arc::new(UInt8Array::from_slice([1])) as ArrayRef, ), ( DataType::UInt16, - Arc::new(UInt16Array::from_slice(&[1])) as ArrayRef, + Arc::new(UInt16Array::from_slice([1])) as ArrayRef, ), ( DataType::UInt32, - Arc::new(UInt32Array::from_slice(&[1])) as ArrayRef, + Arc::new(UInt32Array::from_slice([1])) as ArrayRef, ), ( DataType::UInt64, - Arc::new(UInt64Array::from_slice(&[1])) as ArrayRef, + Arc::new(UInt64Array::from_slice([1])) as ArrayRef, ), ( DataType::Float32, - Arc::new(Float32Array::from_slice(&[1.0_f32])) as ArrayRef, + Arc::new(Float32Array::from_slice([1.0_f32])) as ArrayRef, ), ( DataType::Float64, - Arc::new(Float64Array::from_slice(&[1.0_f64])) as ArrayRef, + Arc::new(Float64Array::from_slice([1.0_f64])) as ArrayRef, ), ]; diff --git a/datafusion/core/tests/sql/information_schema.rs b/datafusion/core/tests/sql/information_schema.rs index ce318e6c2625..8d0563717040 100644 --- a/datafusion/core/tests/sql/information_schema.rs +++ b/datafusion/core/tests/sql/information_schema.rs @@ -513,12 +513,12 @@ fn table_with_many_types() -> Arc { let batch = RecordBatch::try_new( Arc::new(schema.clone()), vec![ - Arc::new(Int32Array::from_slice(&[1])), - Arc::new(Float64Array::from_slice(&[1.0])), + Arc::new(Int32Array::from_slice([1])), + Arc::new(Float64Array::from_slice([1.0])), Arc::new(StringArray::from(vec![Some("foo")])), Arc::new(LargeStringArray::from(vec![Some("bar")])), - Arc::new(BinaryArray::from_slice(&[b"foo" as &[u8]])), - Arc::new(LargeBinaryArray::from_slice(&[b"foo" as &[u8]])), + Arc::new(BinaryArray::from_slice([b"foo" as &[u8]])), + Arc::new(LargeBinaryArray::from_slice([b"foo" as &[u8]])), Arc::new(TimestampNanosecondArray::from_opt_vec( vec![Some(123)], None, diff --git a/datafusion/core/tests/sql/joins.rs b/datafusion/core/tests/sql/joins.rs index 1ba8cf7ac42e..3f939e353740 100644 --- a/datafusion/core/tests/sql/joins.rs +++ b/datafusion/core/tests/sql/joins.rs @@ -791,7 +791,7 @@ async fn test_join_float32() -> Result<()> { population_schema.clone(), vec![ Arc::new(StringArray::from(vec![Some("a"), Some("b"), Some("c")])), - Arc::new(Float32Array::from_slice(&[838.698, 1778.934, 626.443])), + Arc::new(Float32Array::from_slice([838.698, 1778.934, 626.443])), ], )?; ctx.register_batch("population", population_data)?; @@ -830,7 +830,7 @@ async fn test_join_float64() -> Result<()> { population_schema.clone(), vec![ Arc::new(StringArray::from(vec![Some("a"), Some("b"), Some("c")])), - Arc::new(Float64Array::from_slice(&[838.698, 1778.934, 626.443])), + Arc::new(Float64Array::from_slice([838.698, 1778.934, 626.443])), ], )?; ctx.register_batch("population", population_data)?; @@ -959,10 +959,10 @@ async fn inner_join_nulls() { async fn join_tables_with_duplicated_column_name_not_in_on_constraint() -> Result<()> { let ctx = SessionContext::new(); let batch = RecordBatch::try_from_iter(vec![ - ("id", Arc::new(Int32Array::from_slice(&[1, 2, 3])) as _), + ("id", Arc::new(Int32Array::from_slice([1, 2, 3])) as _), ( "country", - Arc::new(StringArray::from_slice(&["Germany", "Sweden", "Japan"])) as _, + Arc::new(StringArray::from_slice(["Germany", "Sweden", "Japan"])) as _, ), ]) .unwrap(); @@ -971,11 +971,11 @@ async fn join_tables_with_duplicated_column_name_not_in_on_constraint() -> Resul let batch = RecordBatch::try_from_iter(vec![ ( "id", - Arc::new(Int32Array::from_slice(&[1, 2, 3, 4, 5, 6, 7])) as _, + Arc::new(Int32Array::from_slice([1, 2, 3, 4, 5, 6, 7])) as _, ), ( "city", - Arc::new(StringArray::from_slice(&[ + Arc::new(StringArray::from_slice([ "Hamburg", "Stockholm", "Osaka", @@ -987,7 +987,7 @@ async fn join_tables_with_duplicated_column_name_not_in_on_constraint() -> Resul ), ( "country_id", - Arc::new(Int32Array::from_slice(&[1, 2, 3, 1, 2, 3, 3])) as _, + Arc::new(Int32Array::from_slice([1, 2, 3, 1, 2, 3, 3])) as _, ), ]) .unwrap(); @@ -1075,8 +1075,8 @@ async fn left_join_should_not_panic_with_empty_side() -> Result<()> { let t1_data = RecordBatch::try_new( Arc::new(t1_schema), vec![ - Arc::new(Int64Array::from_slice(&[5247, 3821, 6321, 8821, 7748])), - Arc::new(StringArray::from_slice(&["a", "b", "c", "d", "e"])), + Arc::new(Int64Array::from_slice([5247, 3821, 6321, 8821, 7748])), + Arc::new(StringArray::from_slice(["a", "b", "c", "d", "e"])), ], )?; ctx.register_batch("t1", t1_data)?; @@ -1088,7 +1088,7 @@ async fn left_join_should_not_panic_with_empty_side() -> Result<()> { let t2_data = RecordBatch::try_new( Arc::new(t2_schema), vec![ - Arc::new(Int64Array::from_slice(&[358, 2820, 3804, 7748])), + Arc::new(Int64Array::from_slice([358, 2820, 3804, 7748])), Arc::new(BooleanArray::from(vec![ Some(true), Some(false), diff --git a/datafusion/core/tests/sql/mod.rs b/datafusion/core/tests/sql/mod.rs index 1562574dcfbe..be86d25c7a73 100644 --- a/datafusion/core/tests/sql/mod.rs +++ b/datafusion/core/tests/sql/mod.rs @@ -192,14 +192,14 @@ fn create_join_context(column_left: &str, column_right: &str) -> Result Result) { let mut writer = ArrowWriter::try_new(file, schema.clone(), None).unwrap(); // create mock record batch - let ids = Arc::new(Int32Array::from_slice(&[i as i32])); - let names = Arc::new(StringArray::from_slice(&["test"])); + let ids = Arc::new(Int32Array::from_slice([i as i32])); + let names = Arc::new(StringArray::from_slice(["test"])); let rec_batch = RecordBatch::try_new(schema.clone(), vec![ids, names]).unwrap(); writer.write(&rec_batch).unwrap(); diff --git a/datafusion/core/tests/sql/projection.rs b/datafusion/core/tests/sql/projection.rs index fdc0949997a2..3163482e8b4e 100644 --- a/datafusion/core/tests/sql/projection.rs +++ b/datafusion/core/tests/sql/projection.rs @@ -275,9 +275,9 @@ async fn projection_on_memory_scan() -> Result<()> { let partitions = vec![vec![RecordBatch::try_new( schema.clone(), vec![ - Arc::new(Int32Array::from_slice(&[1, 10, 10, 100])), - Arc::new(Int32Array::from_slice(&[2, 12, 12, 120])), - Arc::new(Int32Array::from_slice(&[3, 12, 12, 120])), + Arc::new(Int32Array::from_slice([1, 10, 10, 100])), + Arc::new(Int32Array::from_slice([2, 12, 12, 120])), + Arc::new(Int32Array::from_slice([3, 12, 12, 120])), ], )?]]; diff --git a/datafusion/core/tests/sql/select.rs b/datafusion/core/tests/sql/select.rs index e111b21ad4e5..c3890fac4061 100644 --- a/datafusion/core/tests/sql/select.rs +++ b/datafusion/core/tests/sql/select.rs @@ -497,7 +497,7 @@ async fn use_between_expression_in_select_query() -> Result<()> { ]; assert_batches_eq!(expected, &actual); - let input = Int64Array::from_slice(&[1, 2, 3, 4]); + let input = Int64Array::from_slice([1, 2, 3, 4]); let batch = RecordBatch::try_from_iter(vec![("c1", Arc::new(input) as _)]).unwrap(); ctx.register_batch("test", batch)?; diff --git a/datafusion/core/tests/sql/timestamp.rs b/datafusion/core/tests/sql/timestamp.rs index 5192b6cb5677..e2ee43332cd2 100644 --- a/datafusion/core/tests/sql/timestamp.rs +++ b/datafusion/core/tests/sql/timestamp.rs @@ -904,7 +904,7 @@ async fn group_by_timestamp_millis() -> Result<()> { schema.clone(), vec![ Arc::new(TimestampMillisecondArray::from(timestamps)), - Arc::new(Int32Array::from_slice(&[10, 20, 30, 40, 50, 60])), + Arc::new(Int32Array::from_slice([10, 20, 30, 40, 50, 60])), ], )?; ctx.register_batch("t1", data).unwrap(); diff --git a/datafusion/core/tests/sql/udf.rs b/datafusion/core/tests/sql/udf.rs index 6799421922fa..31c5969b8af5 100644 --- a/datafusion/core/tests/sql/udf.rs +++ b/datafusion/core/tests/sql/udf.rs @@ -47,8 +47,8 @@ async fn scalar_udf() -> Result<()> { let batch = RecordBatch::try_new( Arc::new(schema.clone()), vec![ - Arc::new(Int32Array::from_slice(&[1, 10, 10, 100])), - Arc::new(Int32Array::from_slice(&[2, 12, 12, 120])), + Arc::new(Int32Array::from_slice([1, 10, 10, 100])), + Arc::new(Int32Array::from_slice([2, 12, 12, 120])), ], )?; @@ -148,11 +148,11 @@ async fn simple_udaf() -> Result<()> { let batch1 = RecordBatch::try_new( Arc::new(schema.clone()), - vec![Arc::new(Int32Array::from_slice(&[1, 2, 3]))], + vec![Arc::new(Int32Array::from_slice([1, 2, 3]))], )?; let batch2 = RecordBatch::try_new( Arc::new(schema.clone()), - vec![Arc::new(Int32Array::from_slice(&[4, 5]))], + vec![Arc::new(Int32Array::from_slice([4, 5]))], )?; let mut ctx = SessionContext::new(); diff --git a/datafusion/core/tests/sql/window.rs b/datafusion/core/tests/sql/window.rs index 48f5a08dd55c..af84262065a8 100644 --- a/datafusion/core/tests/sql/window.rs +++ b/datafusion/core/tests/sql/window.rs @@ -1113,7 +1113,7 @@ async fn window_frame_ranges_timestamp() -> Result<()> { // define data in two partitions let batch = RecordBatch::try_new( schema.clone(), - vec![Arc::new(TimestampNanosecondArray::from_slice(&[ + vec![Arc::new(TimestampNanosecondArray::from_slice([ 1664264591000000000, 1664264592000000000, 1664264592000000000, diff --git a/datafusion/expr/src/logical_plan/builder.rs b/datafusion/expr/src/logical_plan/builder.rs index 30b13c2f0dc8..6b83e449b490 100644 --- a/datafusion/expr/src/logical_plan/builder.rs +++ b/datafusion/expr/src/logical_plan/builder.rs @@ -323,7 +323,6 @@ impl LogicalPlanBuilder { /// Add missing sort columns to all downstream projection fn add_missing_columns( - &self, curr_plan: LogicalPlan, missing_cols: &[Column], ) -> Result { @@ -354,7 +353,7 @@ impl LogicalPlanBuilder { .inputs() .into_iter() .map(|input_plan| { - self.add_missing_columns((*input_plan).clone(), missing_cols) + Self::add_missing_columns((*input_plan).clone(), missing_cols) }) .collect::>>()?; @@ -399,7 +398,7 @@ impl LogicalPlanBuilder { }))); } - let plan = self.add_missing_columns(self.plan.clone(), &missing_cols)?; + let plan = Self::add_missing_columns(self.plan.clone(), &missing_cols)?; let sort_plan = LogicalPlan::Sort(Sort { expr: normalize_cols(exprs, &plan)?, input: Arc::new(plan.clone()), diff --git a/datafusion/expr/src/logical_plan/plan.rs b/datafusion/expr/src/logical_plan/plan.rs index 27586d702f99..60d9faedeb69 100644 --- a/datafusion/expr/src/logical_plan/plan.rs +++ b/datafusion/expr/src/logical_plan/plan.rs @@ -494,7 +494,7 @@ impl LogicalPlan { fn all_inputs(&self) -> Vec> { let mut inputs = vec![]; for expr in self.expressions() { - self.collect_subqueries(&expr, &mut inputs); + Self::collect_subqueries(&expr, &mut inputs); } for input in self.inputs() { inputs.push(Arc::new(input.clone())); @@ -502,11 +502,11 @@ impl LogicalPlan { inputs } - fn collect_subqueries(&self, expr: &Expr, sub: &mut Vec>) { + fn collect_subqueries(expr: &Expr, sub: &mut Vec>) { match expr { Expr::BinaryExpr(BinaryExpr { left, right, .. }) => { - self.collect_subqueries(left, sub); - self.collect_subqueries(right, sub); + Self::collect_subqueries(left, sub); + Self::collect_subqueries(right, sub); } Expr::Exists { subquery, .. } => { sub.push(Arc::new(LogicalPlan::Subquery(subquery.clone()))); diff --git a/datafusion/optimizer/src/decorrelate_where_exists.rs b/datafusion/optimizer/src/decorrelate_where_exists.rs index c8102debe721..b52c174b5921 100644 --- a/datafusion/optimizer/src/decorrelate_where_exists.rs +++ b/datafusion/optimizer/src/decorrelate_where_exists.rs @@ -136,15 +136,13 @@ fn optimize_exists( let subqry_filter = match query_info.query.subquery.as_ref() { LogicalPlan::Distinct(subqry_distinct) => match subqry_distinct.input.as_ref() { LogicalPlan::Projection(subqry_proj) => { - Filter::try_from_plan(&*subqry_proj.input) + Filter::try_from_plan(&subqry_proj.input) } _ => Err(DataFusionError::NotImplemented( "Subquery currently only supports distinct or projection".to_string(), )), }, - LogicalPlan::Projection(subqry_proj) => { - Filter::try_from_plan(&*subqry_proj.input) - } + LogicalPlan::Projection(subqry_proj) => Filter::try_from_plan(&subqry_proj.input), _ => Err(DataFusionError::NotImplemented( "Subquery currently only supports distinct or projection".to_string(), )), diff --git a/datafusion/optimizer/src/eliminate_filter.rs b/datafusion/optimizer/src/eliminate_filter.rs index 862ca195ebab..a5d92f55f3b6 100644 --- a/datafusion/optimizer/src/eliminate_filter.rs +++ b/datafusion/optimizer/src/eliminate_filter.rs @@ -41,7 +41,7 @@ impl OptimizerRule for EliminateFilter { fn optimize( &self, plan: &LogicalPlan, - optimizer_config: &mut OptimizerConfig, + _optimizer_config: &mut OptimizerConfig, ) -> Result { let predicate_and_input = match plan { LogicalPlan::Filter(filter) => match filter.predicate() { @@ -54,7 +54,7 @@ impl OptimizerRule for EliminateFilter { }; match predicate_and_input { - Some((true, input)) => self.optimize(input, optimizer_config), + Some((true, input)) => self.optimize(input, _optimizer_config), Some((false, input)) => Ok(LogicalPlan::EmptyRelation(EmptyRelation { produce_one_row: false, schema: input.schema().clone(), @@ -64,7 +64,7 @@ impl OptimizerRule for EliminateFilter { let inputs = plan.inputs(); let new_inputs = inputs .iter() - .map(|plan| self.optimize(plan, optimizer_config)) + .map(|plan| self.optimize(plan, _optimizer_config)) .collect::>>()?; from_plan(plan, &plan.expressions(), &new_inputs) diff --git a/datafusion/optimizer/src/rewrite_disjunctive_predicate.rs b/datafusion/optimizer/src/rewrite_disjunctive_predicate.rs index 79f0d0ec2576..65b35abb229a 100644 --- a/datafusion/optimizer/src/rewrite_disjunctive_predicate.rs +++ b/datafusion/optimizer/src/rewrite_disjunctive_predicate.rs @@ -122,11 +122,7 @@ impl RewriteDisjunctivePredicate { pub fn new() -> Self { Self::default() } - fn rewrite_disjunctive_predicate( - &self, - plan: &LogicalPlan, - _optimizer_config: &OptimizerConfig, - ) -> Result { + fn rewrite_disjunctive_predicate(plan: &LogicalPlan) -> Result { match plan { LogicalPlan::Filter(filter) => { let predicate = predicate(filter.predicate())?; @@ -134,10 +130,7 @@ impl RewriteDisjunctivePredicate { let rewritten_expr = normalize_predicate(rewritten_predicate); Ok(LogicalPlan::Filter(Filter::try_new( rewritten_expr, - Arc::new(self.rewrite_disjunctive_predicate( - filter.input(), - _optimizer_config, - )?), + Arc::new(Self::rewrite_disjunctive_predicate(filter.input())?), )?)) } _ => { @@ -145,9 +138,7 @@ impl RewriteDisjunctivePredicate { let inputs = plan.inputs(); let new_inputs = inputs .iter() - .map(|input| { - self.rewrite_disjunctive_predicate(input, _optimizer_config) - }) + .map(|input| Self::rewrite_disjunctive_predicate(input)) .collect::>>()?; from_plan(plan, &expr, &new_inputs) } @@ -159,9 +150,9 @@ impl OptimizerRule for RewriteDisjunctivePredicate { fn optimize( &self, plan: &LogicalPlan, - optimizer_config: &mut OptimizerConfig, + _optimizer_config: &mut OptimizerConfig, ) -> Result { - self.rewrite_disjunctive_predicate(plan, optimizer_config) + Self::rewrite_disjunctive_predicate(plan) } fn name(&self) -> &str { diff --git a/datafusion/optimizer/src/simplify_expressions/simplify_exprs.rs b/datafusion/optimizer/src/simplify_expressions/simplify_exprs.rs index f5ace71b8e51..af0da6b416b2 100644 --- a/datafusion/optimizer/src/simplify_expressions/simplify_exprs.rs +++ b/datafusion/optimizer/src/simplify_expressions/simplify_exprs.rs @@ -51,13 +51,12 @@ impl OptimizerRule for SimplifyExpressions { let mut execution_props = ExecutionProps::new(); execution_props.query_execution_start_time = optimizer_config.query_execution_start_time(); - self.optimize_internal(plan, &execution_props) + Self::optimize_internal(plan, &execution_props) } } impl SimplifyExpressions { fn optimize_internal( - &self, plan: &LogicalPlan, execution_props: &ExecutionProps, ) -> Result { @@ -78,7 +77,7 @@ impl SimplifyExpressions { let new_inputs = plan .inputs() .iter() - .map(|input| self.optimize_internal(input, execution_props)) + .map(|input| Self::optimize_internal(input, execution_props)) .collect::>>()?; let expr = plan diff --git a/datafusion/optimizer/src/type_coercion.rs b/datafusion/optimizer/src/type_coercion.rs index ae1327ed1888..4e3ea172485f 100644 --- a/datafusion/optimizer/src/type_coercion.rs +++ b/datafusion/optimizer/src/type_coercion.rs @@ -58,9 +58,9 @@ impl OptimizerRule for TypeCoercion { fn optimize( &self, plan: &LogicalPlan, - optimizer_config: &mut OptimizerConfig, + _optimizer_config: &mut OptimizerConfig, ) -> Result { - optimize_internal(&DFSchema::empty(), plan, optimizer_config) + optimize_internal(&DFSchema::empty(), plan) } } @@ -68,13 +68,12 @@ fn optimize_internal( // use the external schema to handle the correlated subqueries case external_schema: &DFSchema, plan: &LogicalPlan, - optimizer_config: &mut OptimizerConfig, ) -> Result { // optimize child plans first let new_inputs = plan .inputs() .iter() - .map(|p| optimize_internal(external_schema, p, optimizer_config)) + .map(|p| optimize_internal(external_schema, p)) .collect::>>()?; // get schema representing all available input fields. This is used for data type // resolution only, so order does not matter here @@ -120,18 +119,11 @@ impl ExprRewriter for TypeCoercionRewriter { fn mutate(&mut self, expr: Expr) -> Result { match expr { Expr::ScalarSubquery(Subquery { subquery }) => { - let mut optimizer_config = OptimizerConfig::new(); - let new_plan = - optimize_internal(&self.schema, &subquery, &mut optimizer_config)?; + let new_plan = optimize_internal(&self.schema, &subquery)?; Ok(Expr::ScalarSubquery(Subquery::new(new_plan))) } Expr::Exists { subquery, negated } => { - let mut optimizer_config = OptimizerConfig::new(); - let new_plan = optimize_internal( - &self.schema, - &subquery.subquery, - &mut optimizer_config, - )?; + let new_plan = optimize_internal(&self.schema, &subquery.subquery)?; Ok(Expr::Exists { subquery: Subquery::new(new_plan), negated, @@ -142,12 +134,7 @@ impl ExprRewriter for TypeCoercionRewriter { subquery, negated, } => { - let mut optimizer_config = OptimizerConfig::new(); - let new_plan = optimize_internal( - &self.schema, - &subquery.subquery, - &mut optimizer_config, - )?; + let new_plan = optimize_internal(&self.schema, &subquery.subquery)?; Ok(Expr::InSubquery { expr, subquery: Subquery::new(new_plan), diff --git a/datafusion/physical-expr/src/aggregate/covariance.rs b/datafusion/physical-expr/src/aggregate/covariance.rs index 63a8137c2371..7797e008d9fe 100644 --- a/datafusion/physical-expr/src/aggregate/covariance.rs +++ b/datafusion/physical-expr/src/aggregate/covariance.rs @@ -257,8 +257,8 @@ impl Accumulator for CovarianceAccumulator { let value1 = arr1.next(); let value2 = arr2.next(); - if value1 == None || value2 == None { - if value1 == None && value2 == None { + if value1.is_none() || value2.is_none() { + if value1.is_none() && value2.is_none() { continue; } else { return Err(DataFusionError::Internal( @@ -295,8 +295,8 @@ impl Accumulator for CovarianceAccumulator { let value1 = arr1.next(); let value2 = arr2.next(); - if value1 == None || value2 == None { - if value1 == None && value2 == None { + if value1.is_none() || value2.is_none() { + if value1.is_none() && value2.is_none() { continue; } else { return Err(DataFusionError::Internal( diff --git a/datafusion/physical-expr/src/aggregate/stddev.rs b/datafusion/physical-expr/src/aggregate/stddev.rs index 5197018a568b..639971811f51 100644 --- a/datafusion/physical-expr/src/aggregate/stddev.rs +++ b/datafusion/physical-expr/src/aggregate/stddev.rs @@ -200,7 +200,7 @@ impl Accumulator for StddevAccumulator { let variance = self.variance.evaluate()?; match variance { ScalarValue::Float64(e) => { - if e == None { + if e.is_none() { Ok(ScalarValue::Float64(None)) } else { Ok(ScalarValue::Float64(e.map(|f| f.sqrt()))) diff --git a/datafusion/physical-expr/src/functions.rs b/datafusion/physical-expr/src/functions.rs index 000991d07939..0174d3d60ed5 100644 --- a/datafusion/physical-expr/src/functions.rs +++ b/datafusion/physical-expr/src/functions.rs @@ -2820,24 +2820,24 @@ mod tests { #[test] fn test_array() -> Result<()> { generic_test_array( - Arc::new(StringArray::from_slice(&["aa"])), - Arc::new(StringArray::from_slice(&["bb"])), + Arc::new(StringArray::from_slice(["aa"])), + Arc::new(StringArray::from_slice(["bb"])), DataType::Utf8, "StringArray\n[\n \"aa\",\n \"bb\",\n]", )?; // different types, to validate that casting happens generic_test_array( - Arc::new(UInt32Array::from_slice(&[1u32])), - Arc::new(UInt64Array::from_slice(&[1u64])), + Arc::new(UInt32Array::from_slice([1u32])), + Arc::new(UInt64Array::from_slice([1u64])), DataType::UInt64, "PrimitiveArray\n[\n 1,\n 1,\n]", )?; // different types (another order), to validate that casting happens generic_test_array( - Arc::new(UInt64Array::from_slice(&[1u64])), - Arc::new(UInt32Array::from_slice(&[1u32])), + Arc::new(UInt64Array::from_slice([1u64])), + Arc::new(UInt32Array::from_slice([1u32])), DataType::UInt64, "PrimitiveArray\n[\n 1,\n 1,\n]", ) @@ -2850,7 +2850,7 @@ mod tests { let schema = Schema::new(vec![Field::new("a", DataType::Utf8, false)]); let execution_props = ExecutionProps::new(); - let col_value: ArrayRef = Arc::new(StringArray::from_slice(&["aaa-555"])); + let col_value: ArrayRef = Arc::new(StringArray::from_slice(["aaa-555"])); let pattern = lit(r".*-(\d*)"); let columns: Vec = vec![col_value]; let expr = create_physical_expr_with_type_coercion( @@ -2891,7 +2891,7 @@ mod tests { let col_value = lit("aaa-555"); let pattern = lit(r".*-(\d*)"); - let columns: Vec = vec![Arc::new(Int32Array::from_slice(&[1]))]; + let columns: Vec = vec![Arc::new(Int32Array::from_slice([1]))]; let expr = create_physical_expr_with_type_coercion( &BuiltinScalarFunction::RegexpMatch, &[col_value, pattern], diff --git a/datafusion/physical-expr/src/hash_utils.rs b/datafusion/physical-expr/src/hash_utils.rs index 4b1cb23d0959..79a6cc167750 100644 --- a/datafusion/physical-expr/src/hash_utils.rs +++ b/datafusion/physical-expr/src/hash_utils.rs @@ -36,11 +36,11 @@ fn hash_null(random_state: &RandomState, hashes_buffer: &'_ mut [u64], mul_col: if mul_col { hashes_buffer.iter_mut().for_each(|hash| { // stable hash for null value - *hash = combine_hashes(random_state.hash_one(&1), *hash); + *hash = combine_hashes(random_state.hash_one(1), *hash); }) } else { hashes_buffer.iter_mut().for_each(|hash| { - *hash = random_state.hash_one(&1); + *hash = random_state.hash_one(1); }) } } @@ -270,8 +270,8 @@ mod tests { #[test] fn create_hashes_for_float_arrays() -> Result<()> { - let f32_arr = Arc::new(Float32Array::from_slice(&[0.12, 0.5, 1f32, 444.7])); - let f64_arr = Arc::new(Float64Array::from_slice(&[0.12, 0.5, 1f64, 444.7])); + let f32_arr = Arc::new(Float32Array::from_slice([0.12, 0.5, 1f32, 444.7])); + let f64_arr = Arc::new(Float64Array::from_slice([0.12, 0.5, 1f64, 444.7])); let random_state = RandomState::with_seeds(0, 0, 0, 0); let hashes_buff = &mut vec![0; f32_arr.len()]; diff --git a/datafusion/proto/build.rs b/datafusion/proto/build.rs index 87ee9589c004..c9b4e25fde3e 100644 --- a/datafusion/proto/build.rs +++ b/datafusion/proto/build.rs @@ -48,14 +48,13 @@ fn build() -> Result<(), String> { .map_err(|e| format!("protobuf compilation failed: {}", e))?; let descriptor_set = std::fs::read(&descriptor_path) - .expect(&*format!("Cannot read {:?}", &descriptor_path)); + .unwrap_or_else(|e| panic!("Cannot read {:?}: {}", &descriptor_path, e)); pbjson_build::Builder::new() .register_descriptors(&descriptor_set) - .expect(&*format!( - "Cannot register descriptors {:?}", - &descriptor_set - )) + .unwrap_or_else(|e| { + panic!("Cannot register descriptors {:?}: {}", &descriptor_set, e) + }) .build(&[".datafusion"]) .map_err(|e| format!("pbjson compilation failed: {}", e))?; diff --git a/datafusion/proto/src/logical_plan.rs b/datafusion/proto/src/logical_plan.rs index 552045044e60..4f71bdac5650 100644 --- a/datafusion/proto/src/logical_plan.rs +++ b/datafusion/proto/src/logical_plan.rs @@ -915,7 +915,7 @@ impl AsLogicalPlan for LogicalPlanNode { definition: view_table .definition() .clone() - .unwrap_or_else(|| "".to_string()), + .unwrap_or_default(), }, ))), }) @@ -1208,7 +1208,7 @@ impl AsLogicalPlan for LogicalPlanNode { table_partition_cols: table_partition_cols.clone(), if_not_exists: *if_not_exists, delimiter: String::from(*delimiter), - definition: definition.clone().unwrap_or_else(|| "".to_string()), + definition: definition.clone().unwrap_or_default(), file_compression_type: file_compression_type.to_string(), }, )), @@ -1227,7 +1227,7 @@ impl AsLogicalPlan for LogicalPlanNode { extension_codec, )?)), or_replace: *or_replace, - definition: definition.clone().unwrap_or_else(|| "".to_string()), + definition: definition.clone().unwrap_or_default(), }, ))), }), diff --git a/datafusion/proto/src/to_proto.rs b/datafusion/proto/src/to_proto.rs index 44f27429afb4..96c9d983a5db 100644 --- a/datafusion/proto/src/to_proto.rs +++ b/datafusion/proto/src/to_proto.rs @@ -471,7 +471,7 @@ impl TryFrom<&Expr> for protobuf::LogicalExprNode { pattern: Some(Box::new(pattern.as_ref().try_into()?)), escape_char: escape_char .map(|ch| ch.to_string()) - .unwrap_or_else(|| "".to_string()), + .unwrap_or_default() }); Self { expr_type: Some(ExprType::Like(pb)), @@ -484,7 +484,7 @@ impl TryFrom<&Expr> for protobuf::LogicalExprNode { pattern: Some(Box::new(pattern.as_ref().try_into()?)), escape_char: escape_char .map(|ch| ch.to_string()) - .unwrap_or_else(|| "".to_string()), + .unwrap_or_default(), }); Self { expr_type: Some(ExprType::Ilike(pb)), @@ -497,7 +497,7 @@ impl TryFrom<&Expr> for protobuf::LogicalExprNode { pattern: Some(Box::new(pattern.as_ref().try_into()?)), escape_char: escape_char .map(|ch| ch.to_string()) - .unwrap_or_else(|| "".to_string()), + .unwrap_or_default(), }); Self { expr_type: Some(ExprType::SimilarTo(pb)), diff --git a/parquet-test-utils/src/lib.rs b/parquet-test-utils/src/lib.rs index 6c1454016902..6a3e6e0ec1c2 100644 --- a/parquet-test-utils/src/lib.rs +++ b/parquet-test-utils/src/lib.rs @@ -189,13 +189,13 @@ impl TestParquetFile { /// /// Recursively searches for ParquetExec and returns the metrics /// on the first one it finds - pub fn parquet_metrics(&self, plan: Arc) -> Option { + pub fn parquet_metrics(plan: Arc) -> Option { if let Some(parquet) = plan.as_any().downcast_ref::() { return parquet.metrics(); } for child in plan.children() { - if let Some(metrics) = self.parquet_metrics(child) { + if let Some(metrics) = Self::parquet_metrics(child) { return Some(metrics); } }