diff --git a/datafusion-cli/src/print_format.rs b/datafusion-cli/src/print_format.rs index e05d8bd074d1..0320166bcbe9 100644 --- a/datafusion-cli/src/print_format.rs +++ b/datafusion-cli/src/print_format.rs @@ -120,6 +120,7 @@ mod tests { use super::*; use arrow::array::Int32Array; use arrow::datatypes::{DataType, Field, Schema}; + use datafusion::from_slice::FromSlice; use std::sync::Arc; #[test] @@ -168,9 +169,9 @@ mod tests { let batch = RecordBatch::try_new( schema, vec![ - Arc::new(Int32Array::from(vec![1, 2, 3])), - Arc::new(Int32Array::from(vec![4, 5, 6])), - Arc::new(Int32Array::from(vec![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])), ], ) .unwrap(); @@ -198,9 +199,9 @@ mod tests { let batch = RecordBatch::try_new( schema, vec![ - Arc::new(Int32Array::from(vec![1, 2, 3])), - Arc::new(Int32Array::from(vec![4, 5, 6])), - Arc::new(Int32Array::from(vec![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])), ], ) .unwrap(); diff --git a/datafusion-examples/examples/dataframe_in_memory.rs b/datafusion-examples/examples/dataframe_in_memory.rs index 27ac079ea894..2b4bbea6ac2e 100644 --- a/datafusion-examples/examples/dataframe_in_memory.rs +++ b/datafusion-examples/examples/dataframe_in_memory.rs @@ -20,9 +20,9 @@ use std::sync::Arc; use datafusion::arrow::array::{Int32Array, StringArray}; use datafusion::arrow::datatypes::{DataType, Field, Schema}; use datafusion::arrow::record_batch::RecordBatch; - use datafusion::datasource::MemTable; use datafusion::error::Result; +use datafusion::from_slice::FromSlice; use datafusion::prelude::*; /// This example demonstrates how to use the DataFrame API against in-memory data. @@ -39,7 +39,7 @@ async fn main() -> Result<()> { schema.clone(), vec![ Arc::new(StringArray::from(vec!["a", "b", "c", "d"])), - Arc::new(Int32Array::from(vec![1, 10, 10, 100])), + 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 5a0e814a720a..08706a37afc9 100644 --- a/datafusion-examples/examples/simple_udaf.rs +++ b/datafusion-examples/examples/simple_udaf.rs @@ -22,6 +22,7 @@ use datafusion::arrow::{ record_batch::RecordBatch, }; +use datafusion::from_slice::FromSlice; use datafusion::physical_plan::functions::Volatility; use datafusion::{error::Result, logical_plan::create_udaf, physical_plan::Accumulator}; use datafusion::{prelude::*, scalar::ScalarValue}; @@ -37,11 +38,11 @@ fn create_context() -> Result { // define data in two partitions let batch1 = RecordBatch::try_new( schema.clone(), - vec![Arc::new(Float32Array::from(vec![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(vec![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 bc26811822a4..33242c7b9870 100644 --- a/datafusion-examples/examples/simple_udf.rs +++ b/datafusion-examples/examples/simple_udf.rs @@ -24,6 +24,7 @@ use datafusion::{ physical_plan::functions::Volatility, }; +use datafusion::from_slice::FromSlice; use datafusion::prelude::*; use datafusion::{error::Result, physical_plan::functions::make_scalar_function}; use std::sync::Arc; @@ -42,8 +43,8 @@ fn create_context() -> Result { let batch = RecordBatch::try_new( schema.clone(), vec![ - Arc::new(Float32Array::from(vec![2.1, 3.1, 4.1, 5.1])), - Arc::new(Float64Array::from(vec![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/benches/data_utils/mod.rs b/datafusion/benches/data_utils/mod.rs index 4fd8f57fa190..6ebeeb77020e 100644 --- a/datafusion/benches/data_utils/mod.rs +++ b/datafusion/benches/data_utils/mod.rs @@ -27,6 +27,7 @@ use arrow::{ }; use datafusion::datasource::MemTable; use datafusion::error::Result; +use datafusion::from_slice::FromSlice; use rand::rngs::StdRng; use rand::seq::SliceRandom; use rand::{Rng, SeedableRng}; @@ -128,7 +129,7 @@ fn create_record_batch( schema, vec![ Arc::new(StringArray::from(keys)), - Arc::new(Float32Array::from(vec![i as f32; batch_size])), + Arc::new(Float32Array::from_slice(&vec![i as f32; batch_size])), Arc::new(Float64Array::from(values)), Arc::new(UInt64Array::from(integer_values_wide)), Arc::new(UInt64Array::from(integer_values_narrow)), diff --git a/datafusion/benches/filter_query_sql.rs b/datafusion/benches/filter_query_sql.rs index c64c52126b0d..9885918de229 100644 --- a/datafusion/benches/filter_query_sql.rs +++ b/datafusion/benches/filter_query_sql.rs @@ -21,6 +21,7 @@ use arrow::{ record_batch::RecordBatch, }; use criterion::{criterion_group, criterion_main, Criterion}; +use datafusion::from_slice::FromSlice; use datafusion::prelude::ExecutionContext; use datafusion::{datasource::MemTable, error::Result}; use futures::executor::block_on; @@ -48,8 +49,8 @@ fn create_context(array_len: usize, batch_size: usize) -> Result>, sql: &str) { let rt = Runtime::new().unwrap(); @@ -60,8 +60,8 @@ fn create_context( RecordBatch::try_new( schema.clone(), vec![ - Arc::new(Float32Array::from(vec![i as f32; batch_size])), - Arc::new(Float64Array::from(vec![i as f64; batch_size])), + Arc::new(Float32Array::from_slice(&vec![i as f32; batch_size])), + Arc::new(Float64Array::from_slice(&vec![i as f64; batch_size])), ], ) .unwrap() diff --git a/datafusion/src/datasource/memory.rs b/datafusion/src/datasource/memory.rs index ada323139ff8..f09e691ec2de 100644 --- a/datafusion/src/datasource/memory.rs +++ b/datafusion/src/datasource/memory.rs @@ -146,6 +146,7 @@ impl TableProvider for MemTable { #[cfg(test)] mod tests { use super::*; + use crate::from_slice::FromSlice; use arrow::array::Int32Array; use arrow::datatypes::{DataType, Field, Schema}; use futures::StreamExt; @@ -164,9 +165,9 @@ mod tests { let batch = RecordBatch::try_new( schema.clone(), vec![ - Arc::new(Int32Array::from(vec![1, 2, 3])), - Arc::new(Int32Array::from(vec![4, 5, 6])), - Arc::new(Int32Array::from(vec![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)])), ], )?; @@ -197,9 +198,9 @@ mod tests { let batch = RecordBatch::try_new( schema.clone(), vec![ - Arc::new(Int32Array::from(vec![1, 2, 3])), - Arc::new(Int32Array::from(vec![4, 5, 6])), - Arc::new(Int32Array::from(vec![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])), ], )?; @@ -225,9 +226,9 @@ mod tests { let batch = RecordBatch::try_new( schema.clone(), vec![ - Arc::new(Int32Array::from(vec![1, 2, 3])), - Arc::new(Int32Array::from(vec![4, 5, 6])), - Arc::new(Int32Array::from(vec![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])), ], )?; @@ -262,9 +263,9 @@ mod tests { let batch = RecordBatch::try_new( schema1, vec![ - Arc::new(Int32Array::from(vec![1, 2, 3])), - Arc::new(Int32Array::from(vec![4, 5, 6])), - Arc::new(Int32Array::from(vec![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])), ], )?; @@ -295,8 +296,8 @@ mod tests { let batch = RecordBatch::try_new( schema1, vec![ - Arc::new(Int32Array::from(vec![1, 2, 3])), - Arc::new(Int32Array::from(vec![7, 5, 9])), + Arc::new(Int32Array::from_slice(&[1, 2, 3])), + Arc::new(Int32Array::from_slice(&[7, 5, 9])), ], )?; @@ -339,18 +340,18 @@ mod tests { let batch1 = RecordBatch::try_new( Arc::new(schema1), vec![ - Arc::new(Int32Array::from(vec![1, 2, 3])), - Arc::new(Int32Array::from(vec![4, 5, 6])), - Arc::new(Int32Array::from(vec![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(vec![1, 2, 3])), - Arc::new(Int32Array::from(vec![4, 5, 6])), - Arc::new(Int32Array::from(vec![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/src/execution/context.rs b/datafusion/src/execution/context.rs index 89ccd7b2b938..03a0b4d2b9b3 100644 --- a/datafusion/src/execution/context.rs +++ b/datafusion/src/execution/context.rs @@ -1214,6 +1214,7 @@ impl FunctionRegistry for ExecutionContextState { #[cfg(test)] mod tests { use super::*; + use crate::from_slice::FromSlice; use crate::logical_plan::plan::Projection; use crate::logical_plan::TableScan; use crate::logical_plan::{binary_expr, lit, Operator}; @@ -1514,9 +1515,9 @@ mod tests { let partitions = vec![vec![RecordBatch::try_new( schema.clone(), vec![ - Arc::new(Int32Array::from(vec![1, 10, 10, 100])), - Arc::new(Int32Array::from(vec![2, 12, 12, 120])), - Arc::new(Int32Array::from(vec![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])), ], )?]]; @@ -2928,43 +2929,43 @@ mod tests { let type_values = vec![ ( DataType::Int8, - Arc::new(Int8Array::from(vec![1])) as ArrayRef, + Arc::new(Int8Array::from_slice(&[1])) as ArrayRef, ), ( DataType::Int16, - Arc::new(Int16Array::from(vec![1])) as ArrayRef, + Arc::new(Int16Array::from_slice(&[1])) as ArrayRef, ), ( DataType::Int32, - Arc::new(Int32Array::from(vec![1])) as ArrayRef, + Arc::new(Int32Array::from_slice(&[1])) as ArrayRef, ), ( DataType::Int64, - Arc::new(Int64Array::from(vec![1])) as ArrayRef, + Arc::new(Int64Array::from_slice(&[1])) as ArrayRef, ), ( DataType::UInt8, - Arc::new(UInt8Array::from(vec![1])) as ArrayRef, + Arc::new(UInt8Array::from_slice(&[1])) as ArrayRef, ), ( DataType::UInt16, - Arc::new(UInt16Array::from(vec![1])) as ArrayRef, + Arc::new(UInt16Array::from_slice(&[1])) as ArrayRef, ), ( DataType::UInt32, - Arc::new(UInt32Array::from(vec![1])) as ArrayRef, + Arc::new(UInt32Array::from_slice(&[1])) as ArrayRef, ), ( DataType::UInt64, - Arc::new(UInt64Array::from(vec![1])) as ArrayRef, + Arc::new(UInt64Array::from_slice(&[1])) as ArrayRef, ), ( DataType::Float32, - Arc::new(Float32Array::from(vec![1.0_f32])) as ArrayRef, + Arc::new(Float32Array::from_slice(&[1.0_f32])) as ArrayRef, ), ( DataType::Float64, - Arc::new(Float64Array::from(vec![1.0_f64])) as ArrayRef, + Arc::new(Float64Array::from_slice(&[1.0_f64])) as ArrayRef, ), ]; @@ -3278,8 +3279,8 @@ mod tests { let batch = RecordBatch::try_new( Arc::new(schema.clone()), vec![ - Arc::new(Int32Array::from(vec![1, 10, 10, 100])), - Arc::new(Int32Array::from(vec![2, 12, 12, 120])), + Arc::new(Int32Array::from_slice(&[1, 10, 10, 100])), + Arc::new(Int32Array::from_slice(&[2, 12, 12, 120])), ], )?; @@ -3379,11 +3380,11 @@ mod tests { let batch1 = RecordBatch::try_new( Arc::new(schema.clone()), - vec![Arc::new(Int32Array::from(vec![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(vec![4, 5]))], + vec![Arc::new(Int32Array::from_slice(&[4, 5]))], )?; let mut ctx = ExecutionContext::new(); @@ -3416,11 +3417,11 @@ mod tests { let batch1 = RecordBatch::try_new( Arc::new(schema.clone()), - vec![Arc::new(Int32Array::from(vec![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(vec![4, 5]))], + vec![Arc::new(Int32Array::from_slice(&[4, 5]))], )?; let mut ctx = ExecutionContext::new(); @@ -3880,8 +3881,8 @@ mod tests { let batch = RecordBatch::try_new( Arc::new(schema.clone()), vec![ - Arc::new(Int32Array::from(vec![1])), - Arc::new(Float64Array::from(vec![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(vec![b"foo" as &[u8]])), @@ -4148,7 +4149,7 @@ mod tests { .unwrap(); // create mock record batch - let ids = Arc::new(Int32Array::from(vec![i as i32])); + let ids = Arc::new(Int32Array::from_slice(&[i as i32])); let names = Arc::new(StringArray::from(vec!["test"])); let rec_batch = RecordBatch::try_new(schema.clone(), vec![ids, names]).unwrap(); diff --git a/datafusion/src/from_slice.rs b/datafusion/src/from_slice.rs new file mode 100644 index 000000000000..f2f8ae560fb6 --- /dev/null +++ b/datafusion/src/from_slice.rs @@ -0,0 +1,45 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +//! A trait to define from_slice functions for arrow types +//! +//! This file essentially exists to ease the transition onto arrow2 + +use arrow::array::{ArrayData, PrimitiveArray}; +use arrow::buffer::Buffer; +use arrow::datatypes::ArrowPrimitiveType; + +/// A trait to define from_slice functions for arrow primitive array types +pub trait FromSlice +where + T: ArrowPrimitiveType, +{ + /// convert a slice of native types into a primitive array (without nulls) + fn from_slice(slice: &[T::Native]) -> PrimitiveArray; +} + +/// default implementation for primitive types +// #[cfg(test)] +impl FromSlice for PrimitiveArray { + fn from_slice(slice: &[T::Native]) -> PrimitiveArray { + let array_data = ArrayData::builder(T::DATA_TYPE) + .len(slice.len()) + .add_buffer(Buffer::from_slice_ref(&slice)); + let array_data = unsafe { array_data.build_unchecked() }; + PrimitiveArray::::from(array_data) + } +} diff --git a/datafusion/src/lib.rs b/datafusion/src/lib.rs index fd574d7d76ae..2eb7d9af2ffd 100644 --- a/datafusion/src/lib.rs +++ b/datafusion/src/lib.rs @@ -227,6 +227,8 @@ pub(crate) mod field_util; #[cfg(feature = "pyarrow")] mod pyarrow; +pub mod from_slice; + #[cfg(test)] pub mod test; pub mod test_util; diff --git a/datafusion/src/physical_plan/coalesce_batches.rs b/datafusion/src/physical_plan/coalesce_batches.rs index 67ef2846e546..586b05219bdf 100644 --- a/datafusion/src/physical_plan/coalesce_batches.rs +++ b/datafusion/src/physical_plan/coalesce_batches.rs @@ -295,6 +295,7 @@ pub fn concat_batches( #[cfg(test)] mod tests { use super::*; + use crate::from_slice::FromSlice; use crate::physical_plan::{memory::MemoryExec, repartition::RepartitionExec}; use arrow::array::UInt32Array; use arrow::datatypes::{DataType, Field, Schema}; @@ -336,7 +337,7 @@ mod tests { fn create_batch(schema: &Arc) -> RecordBatch { RecordBatch::try_new( schema.clone(), - vec![Arc::new(UInt32Array::from(vec![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/src/physical_plan/common.rs b/datafusion/src/physical_plan/common.rs index dd0c8248e459..b199e638c0b9 100644 --- a/datafusion/src/physical_plan/common.rs +++ b/datafusion/src/physical_plan/common.rs @@ -274,6 +274,7 @@ impl Drop for AbortOnDropMany { #[cfg(test)] mod tests { use super::*; + use crate::from_slice::FromSlice; use arrow::{ array::{Float32Array, Float64Array}, datatypes::{DataType, Field, Schema}, @@ -305,8 +306,8 @@ mod tests { RecordBatch::try_new( Arc::clone(&schema), vec![ - Arc::new(Float32Array::from(vec![i as f32; batch_size])), - Arc::new(Float64Array::from(vec![i as f64; batch_size])), + Arc::new(Float32Array::from_slice(&vec![i as f32; batch_size])), + Arc::new(Float64Array::from_slice(&vec![i as f64; batch_size])), ], ) .unwrap() @@ -343,8 +344,8 @@ mod tests { let batch = RecordBatch::try_new( Arc::clone(&schema), vec![ - Arc::new(Float32Array::from(vec![1., 2., 3.])), - Arc::new(Float64Array::from(vec![9., 8., 7.])), + Arc::new(Float32Array::from_slice(&[1., 2., 3.])), + Arc::new(Float64Array::from_slice(&[9., 8., 7.])), ], )?; let result = diff --git a/datafusion/src/physical_plan/distinct_expressions.rs b/datafusion/src/physical_plan/distinct_expressions.rs index ae6025316bda..b84b66bd80aa 100644 --- a/datafusion/src/physical_plan/distinct_expressions.rs +++ b/datafusion/src/physical_plan/distinct_expressions.rs @@ -210,7 +210,7 @@ impl Accumulator for DistinctCountAccumulator { #[cfg(test)] mod tests { use super::*; - + use crate::from_slice::FromSlice; use arrow::array::{ ArrayRef, BooleanArray, Float32Array, Float64Array, Int16Array, Int32Array, Int64Array, Int8Array, ListArray, UInt16Array, UInt32Array, UInt64Array, @@ -564,8 +564,7 @@ mod tests { #[test] fn count_distinct_update_batch_empty() -> Result<()> { - let arrays = - vec![Arc::new(Int32Array::from(vec![] as Vec>)) as ArrayRef]; + let arrays = vec![Arc::new(Int32Array::from_slice(&[])) as ArrayRef]; let (states, result) = run_update_batch(&arrays)?; @@ -578,8 +577,8 @@ mod tests { #[test] fn count_distinct_update_batch_multiple_columns() -> Result<()> { - let array_int8: ArrayRef = Arc::new(Int8Array::from(vec![1, 1, 2])); - let array_int16: ArrayRef = Arc::new(Int16Array::from(vec![3, 3, 4])); + let array_int8: ArrayRef = Arc::new(Int8Array::from_slice(&[1, 1, 2])); + let array_int16: ArrayRef = Arc::new(Int16Array::from_slice(&[3, 3, 4])); let arrays = vec![array_int8, array_int16]; let (states, result) = run_update_batch(&arrays)?; diff --git a/datafusion/src/physical_plan/expressions/array_agg.rs b/datafusion/src/physical_plan/expressions/array_agg.rs index 3139c874004b..f9126154e575 100644 --- a/datafusion/src/physical_plan/expressions/array_agg.rs +++ b/datafusion/src/physical_plan/expressions/array_agg.rs @@ -149,6 +149,7 @@ impl Accumulator for ArrayAggAccumulator { #[cfg(test)] mod tests { use super::*; + use crate::from_slice::FromSlice; use crate::physical_plan::expressions::col; use crate::physical_plan::expressions::tests::aggregate; use crate::{error::Result, generic_test_op}; @@ -159,7 +160,7 @@ mod tests { #[test] fn array_agg_i32() -> Result<()> { - let a: ArrayRef = Arc::new(Int32Array::from(vec![1, 2, 3, 4, 5])); + let a: ArrayRef = Arc::new(Int32Array::from_slice(&[1, 2, 3, 4, 5])); let list = ScalarValue::List( Some(Box::new(vec![ diff --git a/datafusion/src/physical_plan/expressions/average.rs b/datafusion/src/physical_plan/expressions/average.rs index a57c52539417..e05a9ade1993 100644 --- a/datafusion/src/physical_plan/expressions/average.rs +++ b/datafusion/src/physical_plan/expressions/average.rs @@ -223,6 +223,7 @@ impl Accumulator for AvgAccumulator { #[cfg(test)] mod tests { use super::*; + use crate::from_slice::FromSlice; use crate::physical_plan::expressions::col; use crate::{error::Result, generic_test_op}; use arrow::record_batch::RecordBatch; @@ -297,7 +298,7 @@ mod tests { #[test] fn avg_i32() -> Result<()> { - let a: ArrayRef = Arc::new(Int32Array::from(vec![1, 2, 3, 4, 5])); + let a: ArrayRef = Arc::new(Int32Array::from_slice(&[1, 2, 3, 4, 5])); generic_test_op!( a, DataType::Int32, @@ -339,8 +340,9 @@ mod tests { #[test] fn avg_u32() -> Result<()> { - let a: ArrayRef = - Arc::new(UInt32Array::from(vec![1_u32, 2_u32, 3_u32, 4_u32, 5_u32])); + let a: ArrayRef = Arc::new(UInt32Array::from_slice(&[ + 1_u32, 2_u32, 3_u32, 4_u32, 5_u32, + ])); generic_test_op!( a, DataType::UInt32, @@ -352,8 +354,9 @@ mod tests { #[test] fn avg_f32() -> Result<()> { - let a: ArrayRef = - Arc::new(Float32Array::from(vec![1_f32, 2_f32, 3_f32, 4_f32, 5_f32])); + let a: ArrayRef = Arc::new(Float32Array::from_slice(&[ + 1_f32, 2_f32, 3_f32, 4_f32, 5_f32, + ])); generic_test_op!( a, DataType::Float32, @@ -365,8 +368,9 @@ mod tests { #[test] fn avg_f64() -> Result<()> { - let a: ArrayRef = - Arc::new(Float64Array::from(vec![1_f64, 2_f64, 3_f64, 4_f64, 5_f64])); + let a: ArrayRef = Arc::new(Float64Array::from_slice(&[ + 1_f64, 2_f64, 3_f64, 4_f64, 5_f64, + ])); generic_test_op!( a, DataType::Float64, diff --git a/datafusion/src/physical_plan/expressions/binary.rs b/datafusion/src/physical_plan/expressions/binary.rs index cf340b53696a..41715fe62a74 100644 --- a/datafusion/src/physical_plan/expressions/binary.rs +++ b/datafusion/src/physical_plan/expressions/binary.rs @@ -1041,12 +1041,12 @@ pub fn binary( #[cfg(test)] mod tests { - use arrow::datatypes::{ArrowNumericType, Field, Int32Type, SchemaRef}; - use arrow::util::display::array_value_to_string; - use super::*; use crate::error::Result; + use crate::from_slice::FromSlice; use crate::physical_plan::expressions::{col, lit}; + use arrow::datatypes::{ArrowNumericType, Field, Int32Type, SchemaRef}; + use arrow::util::display::array_value_to_string; // Create a binary expression without coercion. Used here when we do not want to coerce the expressions // to valid types. Usage can result in an execution (after plan) error. @@ -1065,8 +1065,8 @@ mod tests { Field::new("a", DataType::Int32, false), Field::new("b", DataType::Int32, false), ]); - let a = Int32Array::from(vec![1, 2, 3, 4, 5]); - let b = Int32Array::from(vec![1, 2, 4, 8, 16]); + let a = Int32Array::from_slice(&[1, 2, 3, 4, 5]); + let b = Int32Array::from_slice(&[1, 2, 4, 8, 16]); // expression: "a < b" let lt = binary_simple( @@ -1099,8 +1099,8 @@ mod tests { Field::new("a", DataType::Int32, false), Field::new("b", DataType::Int32, false), ]); - let a = Int32Array::from(vec![2, 4, 6, 8, 10]); - let b = Int32Array::from(vec![2, 5, 4, 8, 8]); + let a = Int32Array::from_slice(&[2, 4, 6, 8, 10]); + let b = Int32Array::from_slice(&[2, 5, 4, 8, 8]); // expression: "a < b OR a == b" let expr = binary_simple( @@ -1486,14 +1486,14 @@ mod tests { Field::new("a", DataType::Int32, false), Field::new("b", DataType::Int32, false), ]); - let a = Int32Array::from(vec![1, 2, 3, 4, 5]); - let b = Int32Array::from(vec![1, 2, 4, 8, 16]); + let a = Int32Array::from_slice(&[1, 2, 3, 4, 5]); + let b = Int32Array::from_slice(&[1, 2, 4, 8, 16]); apply_arithmetic::( Arc::new(schema), vec![Arc::new(a), Arc::new(b)], Operator::Plus, - Int32Array::from(vec![2, 4, 7, 12, 21]), + Int32Array::from_slice(&[2, 4, 7, 12, 21]), )?; Ok(()) @@ -1505,14 +1505,14 @@ mod tests { Field::new("a", DataType::Int32, false), Field::new("b", DataType::Int32, false), ])); - let a = Arc::new(Int32Array::from(vec![1, 2, 4, 8, 16])); - let b = Arc::new(Int32Array::from(vec![1, 2, 3, 4, 5])); + let a = Arc::new(Int32Array::from_slice(&[1, 2, 4, 8, 16])); + let b = Arc::new(Int32Array::from_slice(&[1, 2, 3, 4, 5])); apply_arithmetic::( schema.clone(), vec![a.clone(), b.clone()], Operator::Minus, - Int32Array::from(vec![0, 0, 1, 4, 11]), + Int32Array::from_slice(&[0, 0, 1, 4, 11]), )?; // should handle have negative values in result (for signed) @@ -1520,7 +1520,7 @@ mod tests { schema, vec![b, a], Operator::Minus, - Int32Array::from(vec![0, 0, -1, -4, -11]), + Int32Array::from_slice(&[0, 0, -1, -4, -11]), )?; Ok(()) @@ -1532,14 +1532,14 @@ mod tests { Field::new("a", DataType::Int32, false), Field::new("b", DataType::Int32, false), ])); - let a = Arc::new(Int32Array::from(vec![4, 8, 16, 32, 64])); - let b = Arc::new(Int32Array::from(vec![2, 4, 8, 16, 32])); + let a = Arc::new(Int32Array::from_slice(&[4, 8, 16, 32, 64])); + let b = Arc::new(Int32Array::from_slice(&[2, 4, 8, 16, 32])); apply_arithmetic::( schema, vec![a, b], Operator::Multiply, - Int32Array::from(vec![8, 32, 128, 512, 2048]), + Int32Array::from_slice(&[8, 32, 128, 512, 2048]), )?; Ok(()) @@ -1551,14 +1551,14 @@ mod tests { Field::new("a", DataType::Int32, false), Field::new("b", DataType::Int32, false), ])); - let a = Arc::new(Int32Array::from(vec![8, 32, 128, 512, 2048])); - let b = Arc::new(Int32Array::from(vec![2, 4, 8, 16, 32])); + let a = Arc::new(Int32Array::from_slice(&[8, 32, 128, 512, 2048])); + let b = Arc::new(Int32Array::from_slice(&[2, 4, 8, 16, 32])); apply_arithmetic::( schema, vec![a, b], Operator::Divide, - Int32Array::from(vec![4, 8, 16, 32, 64]), + Int32Array::from_slice(&[4, 8, 16, 32, 64]), )?; Ok(()) @@ -1570,14 +1570,14 @@ mod tests { Field::new("a", DataType::Int32, false), Field::new("b", DataType::Int32, false), ])); - let a = Arc::new(Int32Array::from(vec![8, 32, 128, 512, 2048])); - let b = Arc::new(Int32Array::from(vec![2, 4, 7, 14, 32])); + let a = Arc::new(Int32Array::from_slice(&[8, 32, 128, 512, 2048])); + let b = Arc::new(Int32Array::from_slice(&[2, 4, 7, 14, 32])); apply_arithmetic::( schema, vec![a, b], Operator::Modulo, - Int32Array::from(vec![0, 0, 2, 8, 0]), + Int32Array::from_slice(&[0, 0, 2, 8, 0]), )?; Ok(()) diff --git a/datafusion/src/physical_plan/expressions/correlation.rs b/datafusion/src/physical_plan/expressions/correlation.rs index 7ac534e3f282..e91712e0a79a 100644 --- a/datafusion/src/physical_plan/expressions/correlation.rs +++ b/datafusion/src/physical_plan/expressions/correlation.rs @@ -236,6 +236,7 @@ impl Accumulator for CorrelationAccumulator { #[cfg(test)] mod tests { use super::*; + use crate::from_slice::FromSlice; use crate::physical_plan::expressions::col; use crate::{error::Result, generic_test_op2}; use arrow::record_batch::RecordBatch; @@ -243,8 +244,8 @@ mod tests { #[test] fn correlation_f64_1() -> Result<()> { - let a: ArrayRef = Arc::new(Float64Array::from(vec![1_f64, 2_f64, 3_f64])); - let b: ArrayRef = Arc::new(Float64Array::from(vec![4_f64, 5_f64, 7_f64])); + let a: ArrayRef = Arc::new(Float64Array::from_slice(&[1_f64, 2_f64, 3_f64])); + let b: ArrayRef = Arc::new(Float64Array::from_slice(&[4_f64, 5_f64, 7_f64])); generic_test_op2!( a, @@ -259,8 +260,8 @@ mod tests { #[test] fn correlation_f64_2() -> Result<()> { - let a: ArrayRef = Arc::new(Float64Array::from(vec![1_f64, 2_f64, 3_f64])); - let b: ArrayRef = Arc::new(Float64Array::from(vec![4_f64, -5_f64, 6_f64])); + let a: ArrayRef = Arc::new(Float64Array::from_slice(&[1_f64, 2_f64, 3_f64])); + let b: ArrayRef = Arc::new(Float64Array::from_slice(&[4_f64, -5_f64, 6_f64])); generic_test_op2!( a, @@ -275,8 +276,8 @@ mod tests { #[test] fn correlation_f64_4() -> Result<()> { - let a: ArrayRef = Arc::new(Float64Array::from(vec![1.1_f64, 2_f64, 3_f64])); - let b: ArrayRef = Arc::new(Float64Array::from(vec![4.1_f64, 5_f64, 6_f64])); + let a: ArrayRef = Arc::new(Float64Array::from_slice(&[1.1_f64, 2_f64, 3_f64])); + let b: ArrayRef = Arc::new(Float64Array::from_slice(&[4.1_f64, 5_f64, 6_f64])); generic_test_op2!( a, @@ -311,8 +312,8 @@ mod tests { #[test] fn correlation_i32() -> Result<()> { - let a: ArrayRef = Arc::new(Int32Array::from(vec![1, 2, 3])); - let b: ArrayRef = Arc::new(Int32Array::from(vec![4, 5, 6])); + let a: ArrayRef = Arc::new(Int32Array::from_slice(&[1, 2, 3])); + let b: ArrayRef = Arc::new(Int32Array::from_slice(&[4, 5, 6])); generic_test_op2!( a, @@ -327,8 +328,8 @@ mod tests { #[test] fn correlation_u32() -> Result<()> { - let a: ArrayRef = Arc::new(UInt32Array::from(vec![1_u32, 2_u32, 3_u32])); - let b: ArrayRef = Arc::new(UInt32Array::from(vec![4_u32, 5_u32, 6_u32])); + let a: ArrayRef = Arc::new(UInt32Array::from_slice(&[1_u32, 2_u32, 3_u32])); + let b: ArrayRef = Arc::new(UInt32Array::from_slice(&[4_u32, 5_u32, 6_u32])); generic_test_op2!( a, b, @@ -342,8 +343,8 @@ mod tests { #[test] fn correlation_f32() -> Result<()> { - let a: ArrayRef = Arc::new(Float32Array::from(vec![1_f32, 2_f32, 3_f32])); - let b: ArrayRef = Arc::new(Float32Array::from(vec![4_f32, 5_f32, 6_f32])); + let a: ArrayRef = Arc::new(Float32Array::from_slice(&[1_f32, 2_f32, 3_f32])); + let b: ArrayRef = Arc::new(Float32Array::from_slice(&[4_f32, 5_f32, 6_f32])); generic_test_op2!( a, b, @@ -432,10 +433,10 @@ mod tests { #[test] fn correlation_f64_merge_1() -> Result<()> { - let a = Arc::new(Float64Array::from(vec![1_f64, 2_f64, 3_f64])); - let b = Arc::new(Float64Array::from(vec![4_f64, 5_f64, 6_f64])); - let c = Arc::new(Float64Array::from(vec![1.1_f64, 2.2_f64, 3.3_f64])); - let d = Arc::new(Float64Array::from(vec![4.4_f64, 5.5_f64, 9.9_f64])); + let a = Arc::new(Float64Array::from_slice(&[1_f64, 2_f64, 3_f64])); + let b = Arc::new(Float64Array::from_slice(&[4_f64, 5_f64, 6_f64])); + let c = Arc::new(Float64Array::from_slice(&[1.1_f64, 2.2_f64, 3.3_f64])); + let d = Arc::new(Float64Array::from_slice(&[4.4_f64, 5.5_f64, 9.9_f64])); let schema = Schema::new(vec![ Field::new("a", DataType::Float64, false), @@ -467,8 +468,8 @@ mod tests { #[test] fn correlation_f64_merge_2() -> Result<()> { - let a = Arc::new(Float64Array::from(vec![1_f64, 2_f64, 3_f64])); - let b = Arc::new(Float64Array::from(vec![4_f64, 5_f64, 6_f64])); + let a = Arc::new(Float64Array::from_slice(&[1_f64, 2_f64, 3_f64])); + let b = Arc::new(Float64Array::from_slice(&[4_f64, 5_f64, 6_f64])); let c = Arc::new(Float64Array::from(vec![None])); let d = Arc::new(Float64Array::from(vec![None])); diff --git a/datafusion/src/physical_plan/expressions/count.rs b/datafusion/src/physical_plan/expressions/count.rs index edd9aea0219a..c22c4b0767cc 100644 --- a/datafusion/src/physical_plan/expressions/count.rs +++ b/datafusion/src/physical_plan/expressions/count.rs @@ -141,6 +141,7 @@ impl Accumulator for CountAccumulator { #[cfg(test)] mod tests { use super::*; + use crate::from_slice::FromSlice; use crate::physical_plan::expressions::col; use crate::physical_plan::expressions::tests::aggregate; use crate::{error::Result, generic_test_op}; @@ -149,7 +150,7 @@ mod tests { #[test] fn count_elements() -> Result<()> { - let a: ArrayRef = Arc::new(Int32Array::from(vec![1, 2, 3, 4, 5])); + let a: ArrayRef = Arc::new(Int32Array::from_slice(&[1, 2, 3, 4, 5])); generic_test_op!( a, DataType::Int32, diff --git a/datafusion/src/physical_plan/expressions/covariance.rs b/datafusion/src/physical_plan/expressions/covariance.rs index 6b9e2966191d..3d1913c4f40b 100644 --- a/datafusion/src/physical_plan/expressions/covariance.rs +++ b/datafusion/src/physical_plan/expressions/covariance.rs @@ -394,6 +394,7 @@ impl Accumulator for CovarianceAccumulator { #[cfg(test)] mod tests { use super::*; + use crate::from_slice::FromSlice; use crate::physical_plan::expressions::col; use crate::{error::Result, generic_test_op2}; use arrow::record_batch::RecordBatch; @@ -401,8 +402,8 @@ mod tests { #[test] fn covariance_f64_1() -> Result<()> { - let a: ArrayRef = Arc::new(Float64Array::from(vec![1_f64, 2_f64, 3_f64])); - let b: ArrayRef = Arc::new(Float64Array::from(vec![4_f64, 5_f64, 6_f64])); + let a: ArrayRef = Arc::new(Float64Array::from_slice(&[1_f64, 2_f64, 3_f64])); + let b: ArrayRef = Arc::new(Float64Array::from_slice(&[4_f64, 5_f64, 6_f64])); generic_test_op2!( a, @@ -417,8 +418,8 @@ mod tests { #[test] fn covariance_f64_2() -> Result<()> { - let a: ArrayRef = Arc::new(Float64Array::from(vec![1_f64, 2_f64, 3_f64])); - let b: ArrayRef = Arc::new(Float64Array::from(vec![4_f64, 5_f64, 6_f64])); + let a: ArrayRef = Arc::new(Float64Array::from_slice(&[1_f64, 2_f64, 3_f64])); + let b: ArrayRef = Arc::new(Float64Array::from_slice(&[4_f64, 5_f64, 6_f64])); generic_test_op2!( a, @@ -433,8 +434,8 @@ mod tests { #[test] fn covariance_f64_4() -> Result<()> { - let a: ArrayRef = Arc::new(Float64Array::from(vec![1.1_f64, 2_f64, 3_f64])); - let b: ArrayRef = Arc::new(Float64Array::from(vec![4.1_f64, 5_f64, 6_f64])); + let a: ArrayRef = Arc::new(Float64Array::from_slice(&[1.1_f64, 2_f64, 3_f64])); + let b: ArrayRef = Arc::new(Float64Array::from_slice(&[4.1_f64, 5_f64, 6_f64])); generic_test_op2!( a, @@ -449,8 +450,8 @@ mod tests { #[test] fn covariance_f64_5() -> Result<()> { - let a: ArrayRef = Arc::new(Float64Array::from(vec![1.1_f64, 2_f64, 3_f64])); - let b: ArrayRef = Arc::new(Float64Array::from(vec![4.1_f64, 5_f64, 6_f64])); + let a: ArrayRef = Arc::new(Float64Array::from_slice(&[1.1_f64, 2_f64, 3_f64])); + let b: ArrayRef = Arc::new(Float64Array::from_slice(&[4.1_f64, 5_f64, 6_f64])); generic_test_op2!( a, @@ -485,8 +486,8 @@ mod tests { #[test] fn covariance_i32() -> Result<()> { - let a: ArrayRef = Arc::new(Int32Array::from(vec![1, 2, 3])); - let b: ArrayRef = Arc::new(Int32Array::from(vec![4, 5, 6])); + let a: ArrayRef = Arc::new(Int32Array::from_slice(&[1, 2, 3])); + let b: ArrayRef = Arc::new(Int32Array::from_slice(&[4, 5, 6])); generic_test_op2!( a, @@ -501,8 +502,8 @@ mod tests { #[test] fn covariance_u32() -> Result<()> { - let a: ArrayRef = Arc::new(UInt32Array::from(vec![1_u32, 2_u32, 3_u32])); - let b: ArrayRef = Arc::new(UInt32Array::from(vec![4_u32, 5_u32, 6_u32])); + let a: ArrayRef = Arc::new(UInt32Array::from_slice(&[1_u32, 2_u32, 3_u32])); + let b: ArrayRef = Arc::new(UInt32Array::from_slice(&[4_u32, 5_u32, 6_u32])); generic_test_op2!( a, b, @@ -516,8 +517,8 @@ mod tests { #[test] fn covariance_f32() -> Result<()> { - let a: ArrayRef = Arc::new(Float32Array::from(vec![1_f32, 2_f32, 3_f32])); - let b: ArrayRef = Arc::new(Float32Array::from(vec![4_f32, 5_f32, 6_f32])); + let a: ArrayRef = Arc::new(Float32Array::from_slice(&[1_f32, 2_f32, 3_f32])); + let b: ArrayRef = Arc::new(Float32Array::from_slice(&[4_f32, 5_f32, 6_f32])); generic_test_op2!( a, b, @@ -604,10 +605,10 @@ mod tests { #[test] fn covariance_f64_merge_1() -> Result<()> { - let a = Arc::new(Float64Array::from(vec![1_f64, 2_f64, 3_f64])); - let b = Arc::new(Float64Array::from(vec![4_f64, 5_f64, 6_f64])); - let c = Arc::new(Float64Array::from(vec![1.1_f64, 2.2_f64, 3.3_f64])); - let d = Arc::new(Float64Array::from(vec![4.4_f64, 5.5_f64, 6.6_f64])); + let a = Arc::new(Float64Array::from_slice(&[1_f64, 2_f64, 3_f64])); + let b = Arc::new(Float64Array::from_slice(&[4_f64, 5_f64, 6_f64])); + let c = Arc::new(Float64Array::from_slice(&[1.1_f64, 2.2_f64, 3.3_f64])); + let d = Arc::new(Float64Array::from_slice(&[4.4_f64, 5.5_f64, 6.6_f64])); let schema = Schema::new(vec![ Field::new("a", DataType::Float64, false), @@ -639,8 +640,8 @@ mod tests { #[test] fn covariance_f64_merge_2() -> Result<()> { - let a = Arc::new(Float64Array::from(vec![1_f64, 2_f64, 3_f64])); - let b = Arc::new(Float64Array::from(vec![4_f64, 5_f64, 6_f64])); + let a = Arc::new(Float64Array::from_slice(&[1_f64, 2_f64, 3_f64])); + let b = Arc::new(Float64Array::from_slice(&[4_f64, 5_f64, 6_f64])); let c = Arc::new(Float64Array::from(vec![None])); let d = Arc::new(Float64Array::from(vec![None])); diff --git a/datafusion/src/physical_plan/expressions/lead_lag.rs b/datafusion/src/physical_plan/expressions/lead_lag.rs index d1f6c197a186..52f80c30b530 100644 --- a/datafusion/src/physical_plan/expressions/lead_lag.rs +++ b/datafusion/src/physical_plan/expressions/lead_lag.rs @@ -179,12 +179,14 @@ impl PartitionEvaluator for WindowShiftEvaluator { mod tests { use super::*; use crate::error::Result; + use crate::from_slice::FromSlice; use crate::physical_plan::expressions::Column; use arrow::record_batch::RecordBatch; use arrow::{array::*, datatypes::*}; fn test_i32_result(expr: WindowShift, expected: Int32Array) -> Result<()> { - let arr: ArrayRef = Arc::new(Int32Array::from(vec![1, -2, 3, -4, 5, -6, 7, 8])); + let arr: ArrayRef = + Arc::new(Int32Array::from_slice(&[1, -2, 3, -4, 5, -6, 7, 8])); let values = vec![arr]; let schema = Schema::new(vec![Field::new("arr", DataType::Int32, false)]); let batch = RecordBatch::try_new(Arc::new(schema), values.clone())?; diff --git a/datafusion/src/physical_plan/expressions/min_max.rs b/datafusion/src/physical_plan/expressions/min_max.rs index 8f6cd45b193a..b83a27fee62c 100644 --- a/datafusion/src/physical_plan/expressions/min_max.rs +++ b/datafusion/src/physical_plan/expressions/min_max.rs @@ -572,6 +572,7 @@ impl Accumulator for MinAccumulator { #[cfg(test)] mod tests { use super::*; + use crate::from_slice::FromSlice; use crate::physical_plan::expressions::col; use crate::physical_plan::expressions::tests::aggregate; use crate::scalar::ScalarValue::Decimal128; @@ -750,7 +751,7 @@ mod tests { #[test] fn max_i32() -> Result<()> { - let a: ArrayRef = Arc::new(Int32Array::from(vec![1, 2, 3, 4, 5])); + let a: ArrayRef = Arc::new(Int32Array::from_slice(&[1, 2, 3, 4, 5])); generic_test_op!( a, DataType::Int32, @@ -762,7 +763,7 @@ mod tests { #[test] fn min_i32() -> Result<()> { - let a: ArrayRef = Arc::new(Int32Array::from(vec![1, 2, 3, 4, 5])); + let a: ArrayRef = Arc::new(Int32Array::from_slice(&[1, 2, 3, 4, 5])); generic_test_op!( a, DataType::Int32, @@ -882,8 +883,9 @@ mod tests { #[test] fn max_u32() -> Result<()> { - let a: ArrayRef = - Arc::new(UInt32Array::from(vec![1_u32, 2_u32, 3_u32, 4_u32, 5_u32])); + let a: ArrayRef = Arc::new(UInt32Array::from_slice(&[ + 1_u32, 2_u32, 3_u32, 4_u32, 5_u32, + ])); generic_test_op!( a, DataType::UInt32, @@ -895,8 +897,9 @@ mod tests { #[test] fn min_u32() -> Result<()> { - let a: ArrayRef = - Arc::new(UInt32Array::from(vec![1_u32, 2_u32, 3_u32, 4_u32, 5_u32])); + let a: ArrayRef = Arc::new(UInt32Array::from_slice(&[ + 1_u32, 2_u32, 3_u32, 4_u32, 5_u32, + ])); generic_test_op!( a, DataType::UInt32, @@ -908,8 +911,9 @@ mod tests { #[test] fn max_f32() -> Result<()> { - let a: ArrayRef = - Arc::new(Float32Array::from(vec![1_f32, 2_f32, 3_f32, 4_f32, 5_f32])); + let a: ArrayRef = Arc::new(Float32Array::from_slice(&[ + 1_f32, 2_f32, 3_f32, 4_f32, 5_f32, + ])); generic_test_op!( a, DataType::Float32, @@ -921,8 +925,9 @@ mod tests { #[test] fn min_f32() -> Result<()> { - let a: ArrayRef = - Arc::new(Float32Array::from(vec![1_f32, 2_f32, 3_f32, 4_f32, 5_f32])); + let a: ArrayRef = Arc::new(Float32Array::from_slice(&[ + 1_f32, 2_f32, 3_f32, 4_f32, 5_f32, + ])); generic_test_op!( a, DataType::Float32, @@ -934,8 +939,9 @@ mod tests { #[test] fn max_f64() -> Result<()> { - let a: ArrayRef = - Arc::new(Float64Array::from(vec![1_f64, 2_f64, 3_f64, 4_f64, 5_f64])); + let a: ArrayRef = Arc::new(Float64Array::from_slice(&[ + 1_f64, 2_f64, 3_f64, 4_f64, 5_f64, + ])); generic_test_op!( a, DataType::Float64, @@ -947,8 +953,9 @@ mod tests { #[test] fn min_f64() -> Result<()> { - let a: ArrayRef = - Arc::new(Float64Array::from(vec![1_f64, 2_f64, 3_f64, 4_f64, 5_f64])); + let a: ArrayRef = Arc::new(Float64Array::from_slice(&[ + 1_f64, 2_f64, 3_f64, 4_f64, 5_f64, + ])); generic_test_op!( a, DataType::Float64, @@ -960,7 +967,7 @@ mod tests { #[test] fn min_date32() -> Result<()> { - let a: ArrayRef = Arc::new(Date32Array::from(vec![1, 2, 3, 4, 5])); + let a: ArrayRef = Arc::new(Date32Array::from_slice(&[1, 2, 3, 4, 5])); generic_test_op!( a, DataType::Date32, @@ -972,7 +979,7 @@ mod tests { #[test] fn min_date64() -> Result<()> { - let a: ArrayRef = Arc::new(Date64Array::from(vec![1, 2, 3, 4, 5])); + let a: ArrayRef = Arc::new(Date64Array::from_slice(&[1, 2, 3, 4, 5])); generic_test_op!( a, DataType::Date64, @@ -984,7 +991,7 @@ mod tests { #[test] fn max_date32() -> Result<()> { - let a: ArrayRef = Arc::new(Date32Array::from(vec![1, 2, 3, 4, 5])); + let a: ArrayRef = Arc::new(Date32Array::from_slice(&[1, 2, 3, 4, 5])); generic_test_op!( a, DataType::Date32, @@ -996,7 +1003,7 @@ mod tests { #[test] fn max_date64() -> Result<()> { - let a: ArrayRef = Arc::new(Date64Array::from(vec![1, 2, 3, 4, 5])); + let a: ArrayRef = Arc::new(Date64Array::from_slice(&[1, 2, 3, 4, 5])); generic_test_op!( a, DataType::Date64, diff --git a/datafusion/src/physical_plan/expressions/nth_value.rs b/datafusion/src/physical_plan/expressions/nth_value.rs index 14a8f4a8104d..64a526a9c2f9 100644 --- a/datafusion/src/physical_plan/expressions/nth_value.rs +++ b/datafusion/src/physical_plan/expressions/nth_value.rs @@ -198,12 +198,14 @@ impl PartitionEvaluator for NthValueEvaluator { mod tests { use super::*; use crate::error::Result; + use crate::from_slice::FromSlice; use crate::physical_plan::expressions::Column; use arrow::record_batch::RecordBatch; use arrow::{array::*, datatypes::*}; fn test_i32_result(expr: NthValue, expected: Int32Array) -> Result<()> { - let arr: ArrayRef = Arc::new(Int32Array::from(vec![1, -2, 3, -4, 5, -6, 7, 8])); + let arr: ArrayRef = + Arc::new(Int32Array::from_slice(&[1, -2, 3, -4, 5, -6, 7, 8])); let values = vec![arr]; let schema = Schema::new(vec![Field::new("arr", DataType::Int32, false)]); let batch = RecordBatch::try_new(Arc::new(schema), values.clone())?; diff --git a/datafusion/src/physical_plan/expressions/nullif.rs b/datafusion/src/physical_plan/expressions/nullif.rs index 1671b4411c20..7b121bfd74af 100644 --- a/datafusion/src/physical_plan/expressions/nullif.rs +++ b/datafusion/src/physical_plan/expressions/nullif.rs @@ -123,6 +123,7 @@ pub static SUPPORTED_NULLIF_TYPES: &[DataType] = &[ mod tests { use super::*; use crate::error::Result; + use crate::from_slice::FromSlice; #[test] fn nullif_int32() -> Result<()> { @@ -162,7 +163,7 @@ mod tests { #[test] // Ensure that arrays with no nulls can also invoke NULLIF() correctly fn nullif_int32_nonulls() -> Result<()> { - let a = Int32Array::from(vec![1, 3, 10, 7, 8, 1, 2, 4, 5]); + let a = Int32Array::from_slice(&[1, 3, 10, 7, 8, 1, 2, 4, 5]); let a = ColumnarValue::Array(Arc::new(a)); let lit_array = ColumnarValue::Scalar(ScalarValue::Int32(Some(1i32))); diff --git a/datafusion/src/physical_plan/expressions/stddev.rs b/datafusion/src/physical_plan/expressions/stddev.rs index a4c24fc0422b..4404c5bc840f 100644 --- a/datafusion/src/physical_plan/expressions/stddev.rs +++ b/datafusion/src/physical_plan/expressions/stddev.rs @@ -260,6 +260,7 @@ impl Accumulator for StddevAccumulator { #[cfg(test)] mod tests { use super::*; + use crate::from_slice::FromSlice; use crate::physical_plan::expressions::col; use crate::{error::Result, generic_test_op}; use arrow::record_batch::RecordBatch; @@ -267,7 +268,7 @@ mod tests { #[test] fn stddev_f64_1() -> Result<()> { - let a: ArrayRef = Arc::new(Float64Array::from(vec![1_f64, 2_f64])); + let a: ArrayRef = Arc::new(Float64Array::from_slice(&[1_f64, 2_f64])); generic_test_op!( a, DataType::Float64, @@ -279,7 +280,7 @@ mod tests { #[test] fn stddev_f64_2() -> Result<()> { - let a: ArrayRef = Arc::new(Float64Array::from(vec![1.1_f64, 2_f64, 3_f64])); + let a: ArrayRef = Arc::new(Float64Array::from_slice(&[1.1_f64, 2_f64, 3_f64])); generic_test_op!( a, DataType::Float64, @@ -291,8 +292,9 @@ mod tests { #[test] fn stddev_f64_3() -> Result<()> { - let a: ArrayRef = - Arc::new(Float64Array::from(vec![1_f64, 2_f64, 3_f64, 4_f64, 5_f64])); + let a: ArrayRef = Arc::new(Float64Array::from_slice(&[ + 1_f64, 2_f64, 3_f64, 4_f64, 5_f64, + ])); generic_test_op!( a, DataType::Float64, @@ -304,7 +306,7 @@ mod tests { #[test] fn stddev_f64_4() -> Result<()> { - let a: ArrayRef = Arc::new(Float64Array::from(vec![1.1_f64, 2_f64, 3_f64])); + let a: ArrayRef = Arc::new(Float64Array::from_slice(&[1.1_f64, 2_f64, 3_f64])); generic_test_op!( a, DataType::Float64, @@ -316,7 +318,7 @@ mod tests { #[test] fn stddev_i32() -> Result<()> { - let a: ArrayRef = Arc::new(Int32Array::from(vec![1, 2, 3, 4, 5])); + let a: ArrayRef = Arc::new(Int32Array::from_slice(&[1, 2, 3, 4, 5])); generic_test_op!( a, DataType::Int32, @@ -328,8 +330,9 @@ mod tests { #[test] fn stddev_u32() -> Result<()> { - let a: ArrayRef = - Arc::new(UInt32Array::from(vec![1_u32, 2_u32, 3_u32, 4_u32, 5_u32])); + let a: ArrayRef = Arc::new(UInt32Array::from_slice(&[ + 1_u32, 2_u32, 3_u32, 4_u32, 5_u32, + ])); generic_test_op!( a, DataType::UInt32, @@ -341,8 +344,9 @@ mod tests { #[test] fn stddev_f32() -> Result<()> { - let a: ArrayRef = - Arc::new(Float32Array::from(vec![1_f32, 2_f32, 3_f32, 4_f32, 5_f32])); + let a: ArrayRef = Arc::new(Float32Array::from_slice(&[ + 1_f32, 2_f32, 3_f32, 4_f32, 5_f32, + ])); generic_test_op!( a, DataType::Float32, @@ -365,7 +369,7 @@ mod tests { #[test] fn test_stddev_1_input() -> Result<()> { - let a: ArrayRef = Arc::new(Float64Array::from(vec![1_f64])); + let a: ArrayRef = Arc::new(Float64Array::from_slice(&[1_f64])); let schema = Schema::new(vec![Field::new("a", DataType::Float64, false)]); let batch = RecordBatch::try_new(Arc::new(schema.clone()), vec![a])?; @@ -417,8 +421,8 @@ mod tests { #[test] fn stddev_f64_merge_1() -> Result<()> { - let a = Arc::new(Float64Array::from(vec![1_f64, 2_f64, 3_f64])); - let b = Arc::new(Float64Array::from(vec![4_f64, 5_f64])); + let a = Arc::new(Float64Array::from_slice(&[1_f64, 2_f64, 3_f64])); + let b = Arc::new(Float64Array::from_slice(&[4_f64, 5_f64])); let schema = Schema::new(vec![Field::new("a", DataType::Float64, false)]); @@ -445,7 +449,9 @@ mod tests { #[test] fn stddev_f64_merge_2() -> Result<()> { - let a = Arc::new(Float64Array::from(vec![1_f64, 2_f64, 3_f64, 4_f64, 5_f64])); + let a = Arc::new(Float64Array::from_slice(&[ + 1_f64, 2_f64, 3_f64, 4_f64, 5_f64, + ])); let b = Arc::new(Float64Array::from(vec![None])); let schema = Schema::new(vec![Field::new("a", DataType::Float64, false)]); diff --git a/datafusion/src/physical_plan/expressions/sum.rs b/datafusion/src/physical_plan/expressions/sum.rs index 61691c4933ee..9fc5c4dbcff4 100644 --- a/datafusion/src/physical_plan/expressions/sum.rs +++ b/datafusion/src/physical_plan/expressions/sum.rs @@ -383,6 +383,7 @@ impl Accumulator for SumAccumulator { mod tests { use super::*; use crate::arrow::array::DecimalBuilder; + use crate::from_slice::FromSlice; use crate::physical_plan::expressions::col; use crate::{error::Result, generic_test_op}; use arrow::datatypes::*; @@ -523,7 +524,7 @@ mod tests { #[test] fn sum_i32() -> Result<()> { - let a: ArrayRef = Arc::new(Int32Array::from(vec![1, 2, 3, 4, 5])); + let a: ArrayRef = Arc::new(Int32Array::from_slice(&[1, 2, 3, 4, 5])); generic_test_op!( a, DataType::Int32, @@ -565,8 +566,9 @@ mod tests { #[test] fn sum_u32() -> Result<()> { - let a: ArrayRef = - Arc::new(UInt32Array::from(vec![1_u32, 2_u32, 3_u32, 4_u32, 5_u32])); + let a: ArrayRef = Arc::new(UInt32Array::from_slice(&[ + 1_u32, 2_u32, 3_u32, 4_u32, 5_u32, + ])); generic_test_op!( a, DataType::UInt32, @@ -578,8 +580,9 @@ mod tests { #[test] fn sum_f32() -> Result<()> { - let a: ArrayRef = - Arc::new(Float32Array::from(vec![1_f32, 2_f32, 3_f32, 4_f32, 5_f32])); + let a: ArrayRef = Arc::new(Float32Array::from_slice(&[ + 1_f32, 2_f32, 3_f32, 4_f32, 5_f32, + ])); generic_test_op!( a, DataType::Float32, @@ -591,8 +594,9 @@ mod tests { #[test] fn sum_f64() -> Result<()> { - let a: ArrayRef = - Arc::new(Float64Array::from(vec![1_f64, 2_f64, 3_f64, 4_f64, 5_f64])); + let a: ArrayRef = Arc::new(Float64Array::from_slice(&[ + 1_f64, 2_f64, 3_f64, 4_f64, 5_f64, + ])); generic_test_op!( a, DataType::Float64, diff --git a/datafusion/src/physical_plan/expressions/variance.rs b/datafusion/src/physical_plan/expressions/variance.rs index 5e7d01aff6ed..64294ac64551 100644 --- a/datafusion/src/physical_plan/expressions/variance.rs +++ b/datafusion/src/physical_plan/expressions/variance.rs @@ -339,6 +339,7 @@ impl Accumulator for VarianceAccumulator { #[cfg(test)] mod tests { use super::*; + use crate::from_slice::FromSlice; use crate::physical_plan::expressions::col; use crate::{error::Result, generic_test_op}; use arrow::record_batch::RecordBatch; @@ -346,7 +347,7 @@ mod tests { #[test] fn variance_f64_1() -> Result<()> { - let a: ArrayRef = Arc::new(Float64Array::from(vec![1_f64, 2_f64])); + let a: ArrayRef = Arc::new(Float64Array::from_slice(&[1_f64, 2_f64])); generic_test_op!( a, DataType::Float64, @@ -358,8 +359,9 @@ mod tests { #[test] fn variance_f64_2() -> Result<()> { - let a: ArrayRef = - Arc::new(Float64Array::from(vec![1_f64, 2_f64, 3_f64, 4_f64, 5_f64])); + let a: ArrayRef = Arc::new(Float64Array::from_slice(&[ + 1_f64, 2_f64, 3_f64, 4_f64, 5_f64, + ])); generic_test_op!( a, DataType::Float64, @@ -371,8 +373,9 @@ mod tests { #[test] fn variance_f64_3() -> Result<()> { - let a: ArrayRef = - Arc::new(Float64Array::from(vec![1_f64, 2_f64, 3_f64, 4_f64, 5_f64])); + let a: ArrayRef = Arc::new(Float64Array::from_slice(&[ + 1_f64, 2_f64, 3_f64, 4_f64, 5_f64, + ])); generic_test_op!( a, DataType::Float64, @@ -384,7 +387,7 @@ mod tests { #[test] fn variance_f64_4() -> Result<()> { - let a: ArrayRef = Arc::new(Float64Array::from(vec![1.1_f64, 2_f64, 3_f64])); + let a: ArrayRef = Arc::new(Float64Array::from_slice(&[1.1_f64, 2_f64, 3_f64])); generic_test_op!( a, DataType::Float64, @@ -396,7 +399,7 @@ mod tests { #[test] fn variance_i32() -> Result<()> { - let a: ArrayRef = Arc::new(Int32Array::from(vec![1, 2, 3, 4, 5])); + let a: ArrayRef = Arc::new(Int32Array::from_slice(&[1, 2, 3, 4, 5])); generic_test_op!( a, DataType::Int32, @@ -408,8 +411,9 @@ mod tests { #[test] fn variance_u32() -> Result<()> { - let a: ArrayRef = - Arc::new(UInt32Array::from(vec![1_u32, 2_u32, 3_u32, 4_u32, 5_u32])); + let a: ArrayRef = Arc::new(UInt32Array::from_slice(&[ + 1_u32, 2_u32, 3_u32, 4_u32, 5_u32, + ])); generic_test_op!( a, DataType::UInt32, @@ -421,8 +425,9 @@ mod tests { #[test] fn variance_f32() -> Result<()> { - let a: ArrayRef = - Arc::new(Float32Array::from(vec![1_f32, 2_f32, 3_f32, 4_f32, 5_f32])); + let a: ArrayRef = Arc::new(Float32Array::from_slice(&[ + 1_f32, 2_f32, 3_f32, 4_f32, 5_f32, + ])); generic_test_op!( a, DataType::Float32, @@ -445,7 +450,7 @@ mod tests { #[test] fn test_variance_1_input() -> Result<()> { - let a: ArrayRef = Arc::new(Float64Array::from(vec![1_f64])); + let a: ArrayRef = Arc::new(Float64Array::from_slice(&[1_f64])); let schema = Schema::new(vec![Field::new("a", DataType::Float64, false)]); let batch = RecordBatch::try_new(Arc::new(schema.clone()), vec![a])?; @@ -497,8 +502,8 @@ mod tests { #[test] fn variance_f64_merge_1() -> Result<()> { - let a = Arc::new(Float64Array::from(vec![1_f64, 2_f64, 3_f64])); - let b = Arc::new(Float64Array::from(vec![4_f64, 5_f64])); + let a = Arc::new(Float64Array::from_slice(&[1_f64, 2_f64, 3_f64])); + let b = Arc::new(Float64Array::from_slice(&[4_f64, 5_f64])); let schema = Schema::new(vec![Field::new("a", DataType::Float64, false)]); @@ -525,7 +530,9 @@ mod tests { #[test] fn variance_f64_merge_2() -> Result<()> { - let a = Arc::new(Float64Array::from(vec![1_f64, 2_f64, 3_f64, 4_f64, 5_f64])); + let a = Arc::new(Float64Array::from_slice(&[ + 1_f64, 2_f64, 3_f64, 4_f64, 5_f64, + ])); let b = Arc::new(Float64Array::from(vec![None])); let schema = Schema::new(vec![Field::new("a", DataType::Float64, false)]); diff --git a/datafusion/src/physical_plan/functions.rs b/datafusion/src/physical_plan/functions.rs index 77e36a39e5fc..d829112e3867 100644 --- a/datafusion/src/physical_plan/functions.rs +++ b/datafusion/src/physical_plan/functions.rs @@ -1695,6 +1695,7 @@ where #[cfg(test)] mod tests { use super::*; + use crate::from_slice::FromSlice; use crate::{ error::Result, physical_plan::expressions::{col, lit}, @@ -1723,7 +1724,7 @@ mod tests { // any type works here: we evaluate against a literal of `value` let schema = Schema::new(vec![Field::new("a", DataType::Int32, false)]); - let columns: Vec = vec![Arc::new(Int32Array::from(vec![1]))]; + let columns: Vec = vec![Arc::new(Int32Array::from_slice(&[1]))]; let expr = create_physical_expr(&BuiltinScalarFunction::$FUNC, $ARGS, &schema, &ctx_state)?; @@ -3996,16 +3997,16 @@ mod tests { // different types, to validate that casting happens generic_test_array( - Arc::new(UInt32Array::from(vec![1u32])), - Arc::new(UInt64Array::from(vec![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(vec![1u64])), - Arc::new(UInt32Array::from(vec![1u32])), + Arc::new(UInt64Array::from_slice(&[1u64])), + Arc::new(UInt32Array::from_slice(&[1u32])), DataType::UInt64, "PrimitiveArray\n[\n 1,\n 1,\n]", ) @@ -4059,7 +4060,7 @@ mod tests { let col_value = lit(ScalarValue::Utf8(Some("aaa-555".to_string()))); let pattern = lit(ScalarValue::Utf8(Some(r".*-(\d*)".to_string()))); - let columns: Vec = vec![Arc::new(Int32Array::from(vec![1]))]; + let columns: Vec = vec![Arc::new(Int32Array::from_slice(&[1]))]; let expr = create_physical_expr( &BuiltinScalarFunction::RegexpMatch, &[col_value, pattern], diff --git a/datafusion/src/physical_plan/hash_aggregate.rs b/datafusion/src/physical_plan/hash_aggregate.rs index f15e8f0fb47e..8074ae36ce05 100644 --- a/datafusion/src/physical_plan/hash_aggregate.rs +++ b/datafusion/src/physical_plan/hash_aggregate.rs @@ -1009,15 +1009,15 @@ fn finalize_aggregation( #[cfg(test)] mod tests { - use arrow::array::{Float64Array, UInt32Array}; - use arrow::datatypes::DataType; - use futures::FutureExt; - use super::*; + use crate::from_slice::FromSlice; use crate::physical_plan::expressions::{col, Avg}; use crate::test::assert_is_pending; use crate::test::exec::{assert_strong_count_converges_to_zero, BlockingExec}; use crate::{assert_batches_sorted_eq, physical_plan::common}; + use arrow::array::{Float64Array, UInt32Array}; + use arrow::datatypes::DataType; + use futures::FutureExt; use crate::physical_plan::coalesce_partitions::CoalescePartitionsExec; @@ -1036,16 +1036,16 @@ mod tests { RecordBatch::try_new( schema.clone(), vec![ - Arc::new(UInt32Array::from(vec![2, 3, 4, 4])), - Arc::new(Float64Array::from(vec![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(vec![2, 3, 3, 4])), - Arc::new(Float64Array::from(vec![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/src/physical_plan/hash_utils.rs b/datafusion/src/physical_plan/hash_utils.rs index 25d1f3fdd85c..ce995c4a2e58 100644 --- a/datafusion/src/physical_plan/hash_utils.rs +++ b/datafusion/src/physical_plan/hash_utils.rs @@ -515,16 +515,16 @@ pub fn create_hashes<'a>( #[cfg(test)] mod tests { - use std::sync::Arc; - + use crate::from_slice::FromSlice; use arrow::{array::DictionaryArray, datatypes::Int8Type}; + use std::sync::Arc; use super::*; #[test] fn create_hashes_for_float_arrays() -> Result<()> { - let f32_arr = Arc::new(Float32Array::from(vec![0.12, 0.5, 1f32, 444.7])); - let f64_arr = Arc::new(Float64Array::from(vec![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/src/physical_plan/memory.rs b/datafusion/src/physical_plan/memory.rs index 15848c558916..61be207720ee 100644 --- a/datafusion/src/physical_plan/memory.rs +++ b/datafusion/src/physical_plan/memory.rs @@ -229,6 +229,7 @@ impl RecordBatchStream for MemoryStream { #[cfg(test)] mod tests { use super::*; + use crate::from_slice::FromSlice; use crate::physical_plan::ColumnStatistics; use arrow::array::Int32Array; use arrow::datatypes::{DataType, Field, Schema}; @@ -245,10 +246,10 @@ mod tests { let batch = RecordBatch::try_new( schema.clone(), vec![ - Arc::new(Int32Array::from(vec![1, 2, 3])), - Arc::new(Int32Array::from(vec![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(vec![7, 8, 9])), + Arc::new(Int32Array::from_slice(&[7, 8, 9])), ], )?; diff --git a/datafusion/src/physical_plan/repartition.rs b/datafusion/src/physical_plan/repartition.rs index 5549794ed9b8..afb70002d240 100644 --- a/datafusion/src/physical_plan/repartition.rs +++ b/datafusion/src/physical_plan/repartition.rs @@ -492,9 +492,8 @@ impl RecordBatchStream for RepartitionStream { #[cfg(test)] mod tests { - use std::collections::HashSet; - use super::*; + use crate::from_slice::FromSlice; use crate::{ assert_batches_sorted_eq, physical_plan::{collect, expressions::col, memory::MemoryExec}, @@ -513,6 +512,7 @@ mod tests { error::ArrowError, }; use futures::FutureExt; + use std::collections::HashSet; #[tokio::test] async fn one_to_many_round_robin() -> Result<()> { @@ -613,7 +613,7 @@ mod tests { fn create_batch(schema: &Arc) -> RecordBatch { RecordBatch::try_new( schema.clone(), - vec![Arc::new(UInt32Array::from(vec![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/src/physical_plan/sorts/sort_preserving_merge.rs b/datafusion/src/physical_plan/sorts/sort_preserving_merge.rs index fa49daf5a1a6..f3bed6979697 100644 --- a/datafusion/src/physical_plan/sorts/sort_preserving_merge.rs +++ b/datafusion/src/physical_plan/sorts/sort_preserving_merge.rs @@ -656,6 +656,7 @@ impl RecordBatchStream for SortPreservingMergeStream { #[cfg(test)] mod tests { use crate::datasource::object_store::local::LocalFileSystem; + use crate::from_slice::FromSlice; use crate::physical_plan::metrics::MetricValue; use crate::test::exec::{assert_strong_count_converges_to_zero, BlockingExec}; use arrow::array::ArrayRef; @@ -679,7 +680,7 @@ mod tests { #[tokio::test] async fn test_merge_interleave() { let runtime = Arc::new(RuntimeEnv::default()); - let a: ArrayRef = Arc::new(Int32Array::from(vec![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"), @@ -690,7 +691,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(vec![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"), @@ -727,7 +728,7 @@ mod tests { #[tokio::test] async fn test_merge_some_overlap() { let runtime = Arc::new(RuntimeEnv::default()); - let a: ArrayRef = Arc::new(Int32Array::from(vec![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"), @@ -738,7 +739,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(vec![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"), @@ -775,7 +776,7 @@ mod tests { #[tokio::test] async fn test_merge_no_overlap() { let runtime = Arc::new(RuntimeEnv::default()); - let a: ArrayRef = Arc::new(Int32Array::from(vec![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"), @@ -786,7 +787,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(vec![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"), @@ -823,7 +824,7 @@ mod tests { #[tokio::test] async fn test_merge_three_partitions() { let runtime = Arc::new(RuntimeEnv::default()); - let a: ArrayRef = Arc::new(Int32Array::from(vec![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"), @@ -834,7 +835,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(vec![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"), @@ -846,7 +847,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(vec![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"), @@ -1146,7 +1147,7 @@ mod tests { #[tokio::test] async fn test_nulls() { let runtime = Arc::new(RuntimeEnv::default()); - let a: ArrayRef = Arc::new(Int32Array::from(vec![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"), @@ -1163,7 +1164,7 @@ mod tests { ])); let b1 = RecordBatch::try_from_iter(vec![("a", a), ("b", b), ("c", c)]).unwrap(); - let a: ArrayRef = Arc::new(Int32Array::from(vec![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"), @@ -1298,11 +1299,11 @@ mod tests { #[tokio::test] async fn test_merge_metrics() { let runtime = Arc::new(RuntimeEnv::default()); - let a: ArrayRef = Arc::new(Int32Array::from(vec![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(vec![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/src/scalar.rs b/datafusion/src/scalar.rs index 586a69b9719c..8ab4fff9433b 100644 --- a/datafusion/src/scalar.rs +++ b/datafusion/src/scalar.rs @@ -1930,6 +1930,7 @@ impl ScalarType for TimestampNanosecondType { #[cfg(test)] mod tests { use super::*; + use crate::from_slice::FromSlice; #[test] fn scalar_decimal_test() { @@ -2635,7 +2636,7 @@ mod tests { let expected = Arc::new(StructArray::from(vec![ ( field_a.clone(), - Arc::new(Int32Array::from(vec![23, 23])) as ArrayRef, + Arc::new(Int32Array::from_slice(&[23, 23])) as ArrayRef, ), ( field_b.clone(), @@ -2650,11 +2651,11 @@ mod tests { Arc::new(StructArray::from(vec![ ( field_e.clone(), - Arc::new(Int16Array::from(vec![2, 2])) as ArrayRef, + Arc::new(Int16Array::from_slice(&[2, 2])) as ArrayRef, ), ( field_f.clone(), - Arc::new(Int64Array::from(vec![3, 3])) as ArrayRef, + Arc::new(Int64Array::from_slice(&[3, 3])) as ArrayRef, ), ])) as ArrayRef, ), @@ -2730,7 +2731,7 @@ mod tests { let expected = Arc::new(StructArray::from(vec![ ( field_a, - Arc::new(Int32Array::from(vec![23, 7, -1000])) as ArrayRef, + Arc::new(Int32Array::from_slice(&[23, 7, -1000])) as ArrayRef, ), ( field_b, @@ -2745,11 +2746,11 @@ mod tests { Arc::new(StructArray::from(vec![ ( field_e, - Arc::new(Int16Array::from(vec![2, 4, 6])) as ArrayRef, + Arc::new(Int16Array::from_slice(&[2, 4, 6])) as ArrayRef, ), ( field_f, - Arc::new(Int64Array::from(vec![3, 5, 7])) as ArrayRef, + Arc::new(Int64Array::from_slice(&[3, 5, 7])) as ArrayRef, ), ])) as ArrayRef, ), diff --git a/datafusion/src/test/mod.rs b/datafusion/src/test/mod.rs index 39c9de1f6a5f..87679391de6f 100644 --- a/datafusion/src/test/mod.rs +++ b/datafusion/src/test/mod.rs @@ -20,6 +20,7 @@ use crate::datasource::object_store::local::local_unpartitioned_file; use crate::datasource::{MemTable, PartitionedFile, TableProvider}; use crate::error::Result; +use crate::from_slice::FromSlice; use crate::logical_plan::{LogicalPlan, LogicalPlanBuilder}; use array::{ Array, ArrayRef, StringArray, TimestampMicrosecondArray, TimestampMillisecondArray, @@ -44,7 +45,7 @@ pub fn create_table_dual() -> Arc { let batch = RecordBatch::try_new( dual_schema.clone(), vec![ - Arc::new(array::Int32Array::from(vec![1])), + Arc::new(array::Int32Array::from_slice(&[1])), Arc::new(array::StringArray::from(vec!["a"])), ], ) diff --git a/datafusion/tests/custom_sources.rs b/datafusion/tests/custom_sources.rs index 4f027e903ec0..6f0daa444de0 100644 --- a/datafusion/tests/custom_sources.rs +++ b/datafusion/tests/custom_sources.rs @@ -20,7 +20,7 @@ use arrow::compute::kernels::aggregate; use arrow::datatypes::{DataType, Field, Int32Type, Schema, SchemaRef}; use arrow::error::Result as ArrowResult; use arrow::record_batch::RecordBatch; - +use datafusion::from_slice::FromSlice; use datafusion::physical_plan::empty::EmptyExec; use datafusion::scalar::ScalarValue; use datafusion::{datasource::TableProvider, physical_plan::collect}; @@ -72,8 +72,8 @@ macro_rules! TEST_CUSTOM_RECORD_BATCH { RecordBatch::try_new( TEST_CUSTOM_SCHEMA_REF!(), vec![ - Arc::new(Int32Array::from(vec![1, 10, 10, 100])), - Arc::new(Int32Array::from(vec![2, 12, 12, 120])), + Arc::new(Int32Array::from_slice(&[1, 10, 10, 100])), + Arc::new(Int32Array::from_slice(&[2, 12, 12, 120])), ], ) }; @@ -288,9 +288,9 @@ async fn optimizers_catch_all_statistics() { Field::new("MAX(test.c1)", DataType::Int32, false), ])), vec![ - Arc::new(UInt64Array::from(vec![4])), - Arc::new(Int32Array::from(vec![1])), - Arc::new(Int32Array::from(vec![100])), + Arc::new(UInt64Array::from_slice(&[4])), + Arc::new(Int32Array::from_slice(&[1])), + Arc::new(Int32Array::from_slice(&[100])), ], ) .unwrap(); diff --git a/datafusion/tests/dataframe.rs b/datafusion/tests/dataframe.rs index 76b9600812e1..0f28165ddf3c 100644 --- a/datafusion/tests/dataframe.rs +++ b/datafusion/tests/dataframe.rs @@ -15,13 +15,13 @@ // specific language governing permissions and limitations // under the License. -use std::sync::Arc; - use arrow::datatypes::{DataType, Field, Schema}; use arrow::{ array::{Int32Array, StringArray}, record_batch::RecordBatch, }; +use datafusion::from_slice::FromSlice; +use std::sync::Arc; use datafusion::assert_batches_eq; use datafusion::error::Result; @@ -45,7 +45,7 @@ async fn join() -> Result<()> { schema1.clone(), vec![ Arc::new(StringArray::from(vec!["a", "b", "c", "d"])), - Arc::new(Int32Array::from(vec![1, 10, 10, 100])), + Arc::new(Int32Array::from_slice(&[1, 10, 10, 100])), ], )?; // define data. @@ -53,7 +53,7 @@ async fn join() -> Result<()> { schema2.clone(), vec![ Arc::new(StringArray::from(vec!["a", "b", "c", "d"])), - Arc::new(Int32Array::from(vec![1, 10, 10, 100])), + Arc::new(Int32Array::from_slice(&[1, 10, 10, 100])), ], )?; @@ -89,8 +89,8 @@ async fn sort_on_unprojected_columns() -> Result<()> { let batch = RecordBatch::try_new( Arc::new(schema.clone()), vec![ - Arc::new(Int32Array::from(vec![1, 10, 10, 100])), - Arc::new(Int32Array::from(vec![2, 12, 12, 120])), + Arc::new(Int32Array::from_slice(&[1, 10, 10, 100])), + Arc::new(Int32Array::from_slice(&[2, 12, 12, 120])), ], ) .unwrap(); diff --git a/datafusion/tests/dataframe_functions.rs b/datafusion/tests/dataframe_functions.rs index c11aa141f003..2cf2d2977a4b 100644 --- a/datafusion/tests/dataframe_functions.rs +++ b/datafusion/tests/dataframe_functions.rs @@ -15,13 +15,13 @@ // specific language governing permissions and limitations // under the License. -use std::sync::Arc; - use arrow::datatypes::{DataType, Field, Schema}; use arrow::{ array::{Int32Array, StringArray}, record_batch::RecordBatch, }; +use datafusion::from_slice::FromSlice; +use std::sync::Arc; use datafusion::dataframe::DataFrame; use datafusion::datasource::MemTable; @@ -51,7 +51,7 @@ fn create_test_table() -> Result> { "CBAdef", "123AbcDef", ])), - Arc::new(Int32Array::from(vec![1, 10, 10, 100])), + Arc::new(Int32Array::from_slice(&[1, 10, 10, 100])), ], )?; diff --git a/datafusion/tests/sql/joins.rs b/datafusion/tests/sql/joins.rs index 1613463550f0..469ee991f26f 100644 --- a/datafusion/tests/sql/joins.rs +++ b/datafusion/tests/sql/joins.rs @@ -16,6 +16,7 @@ // under the License. use super::*; +use datafusion::from_slice::FromSlice; #[tokio::test] async fn equijoin() -> Result<()> { @@ -505,7 +506,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(vec![838.698, 1778.934, 626.443])), + Arc::new(Float32Array::from_slice(&[838.698, 1778.934, 626.443])), ], )?; let population_table = @@ -546,7 +547,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(vec![838.698, 1778.934, 626.443])), + Arc::new(Float64Array::from_slice(&[838.698, 1778.934, 626.443])), ], )?; let population_table = @@ -626,7 +627,7 @@ async fn inner_join_nulls() { #[tokio::test] async fn join_tables_with_duplicated_column_name_not_in_on_constraint() -> Result<()> { let batch = RecordBatch::try_from_iter(vec![ - ("id", Arc::new(Int32Array::from(vec![1, 2, 3])) as _), + ("id", Arc::new(Int32Array::from_slice(&[1, 2, 3])) as _), ( "country", Arc::new(StringArray::from(vec!["Germany", "Sweden", "Japan"])) as _, @@ -638,7 +639,7 @@ 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(vec![1, 2, 3, 4, 5, 6, 7])) as _, + Arc::new(Int32Array::from_slice(&[1, 2, 3, 4, 5, 6, 7])) as _, ), ( "city", @@ -654,7 +655,7 @@ async fn join_tables_with_duplicated_column_name_not_in_on_constraint() -> Resul ), ( "country_id", - Arc::new(Int32Array::from(vec![1, 2, 3, 1, 2, 3, 3])) as _, + Arc::new(Int32Array::from_slice(&[1, 2, 3, 1, 2, 3, 3])) as _, ), ]) .unwrap(); diff --git a/datafusion/tests/sql/mod.rs b/datafusion/tests/sql/mod.rs index cd854c2ba41e..46c33f7a30e9 100644 --- a/datafusion/tests/sql/mod.rs +++ b/datafusion/tests/sql/mod.rs @@ -29,6 +29,7 @@ use datafusion::assert_batches_eq; use datafusion::assert_batches_sorted_eq; use datafusion::assert_contains; use datafusion::assert_not_contains; +use datafusion::from_slice::FromSlice; use datafusion::logical_plan::plan::{Aggregate, Projection}; use datafusion::logical_plan::LogicalPlan; use datafusion::logical_plan::TableScan; @@ -175,7 +176,7 @@ fn create_join_context( let t1_data = RecordBatch::try_new( t1_schema.clone(), vec![ - Arc::new(UInt32Array::from(vec![11, 22, 33, 44])), + Arc::new(UInt32Array::from_slice(&[11, 22, 33, 44])), Arc::new(StringArray::from(vec![ Some("a"), Some("b"), @@ -194,7 +195,7 @@ fn create_join_context( let t2_data = RecordBatch::try_new( t2_schema.clone(), vec![ - Arc::new(UInt32Array::from(vec![11, 22, 44, 55])), + Arc::new(UInt32Array::from_slice(&[11, 22, 44, 55])), Arc::new(StringArray::from(vec![ Some("z"), Some("y"), @@ -220,9 +221,9 @@ fn create_join_context_qualified() -> Result { let t1_data = RecordBatch::try_new( t1_schema.clone(), vec![ - Arc::new(UInt32Array::from(vec![1, 2, 3, 4])), - Arc::new(UInt32Array::from(vec![10, 20, 30, 40])), - Arc::new(UInt32Array::from(vec![50, 60, 70, 80])), + Arc::new(UInt32Array::from_slice(&[1, 2, 3, 4])), + Arc::new(UInt32Array::from_slice(&[10, 20, 30, 40])), + Arc::new(UInt32Array::from_slice(&[50, 60, 70, 80])), ], )?; let t1_table = MemTable::try_new(t1_schema, vec![vec![t1_data]])?; @@ -236,9 +237,9 @@ fn create_join_context_qualified() -> Result { let t2_data = RecordBatch::try_new( t2_schema.clone(), vec![ - Arc::new(UInt32Array::from(vec![1, 2, 9, 4])), - Arc::new(UInt32Array::from(vec![100, 200, 300, 400])), - Arc::new(UInt32Array::from(vec![500, 600, 700, 800])), + Arc::new(UInt32Array::from_slice(&[1, 2, 9, 4])), + Arc::new(UInt32Array::from_slice(&[100, 200, 300, 400])), + Arc::new(UInt32Array::from_slice(&[500, 600, 700, 800])), ], )?; let t2_table = MemTable::try_new(t2_schema, vec![vec![t2_data]])?; @@ -261,7 +262,7 @@ fn create_join_context_unbalanced( let t1_data = RecordBatch::try_new( t1_schema.clone(), vec![ - Arc::new(UInt32Array::from(vec![11, 22, 33, 44, 77])), + Arc::new(UInt32Array::from_slice(&[11, 22, 33, 44, 77])), Arc::new(StringArray::from(vec![ Some("a"), Some("b"), @@ -281,7 +282,7 @@ fn create_join_context_unbalanced( let t2_data = RecordBatch::try_new( t2_schema.clone(), vec![ - Arc::new(UInt32Array::from(vec![11, 22, 44, 55])), + Arc::new(UInt32Array::from_slice(&[11, 22, 44, 55])), Arc::new(StringArray::from(vec![ Some("z"), Some("y"), diff --git a/datafusion/tests/sql/select.rs b/datafusion/tests/sql/select.rs index cfe0faccf20c..6264c18d3ecd 100644 --- a/datafusion/tests/sql/select.rs +++ b/datafusion/tests/sql/select.rs @@ -16,6 +16,7 @@ // under the License. use super::*; +use datafusion::from_slice::FromSlice; #[tokio::test] async fn all_where_empty() -> Result<()> { @@ -473,7 +474,7 @@ async fn use_between_expression_in_select_query() -> Result<()> { ]; assert_batches_eq!(expected, &actual); - let input = Int64Array::from(vec![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(); let table = MemTable::try_new(batch.schema(), vec![vec![batch]])?; ctx.register_table("test", Arc::new(table))?; diff --git a/datafusion/tests/sql/timestamp.rs b/datafusion/tests/sql/timestamp.rs index e9065f6f9a96..d8b45c5fea53 100644 --- a/datafusion/tests/sql/timestamp.rs +++ b/datafusion/tests/sql/timestamp.rs @@ -16,6 +16,7 @@ // under the License. use super::*; +use datafusion::from_slice::FromSlice; #[tokio::test] async fn query_cast_timestamp_millis() -> Result<()> { @@ -793,7 +794,7 @@ async fn group_by_timestamp_millis() -> Result<()> { schema.clone(), vec![ Arc::new(TimestampMillisecondArray::from(timestamps)), - Arc::new(Int32Array::from(vec![10, 20, 30, 40, 50, 60])), + Arc::new(Int32Array::from_slice(&[10, 20, 30, 40, 50, 60])), ], )?; let t1_table = MemTable::try_new(schema, vec![vec![data]])?;