diff --git a/rust/arrow/src/array/array.rs b/rust/arrow/src/array/array.rs index bdebc4a7869..a6e94a56dd4 100644 --- a/rust/arrow/src/array/array.rs +++ b/rust/arrow/src/array/array.rs @@ -411,25 +411,18 @@ pub struct PrimitiveArray { raw_values: RawPtrBox, } -/// Common operations for primitive types, including numeric types and boolean type. -pub trait PrimitiveArrayOps { +impl PrimitiveArray { /// Returns a `Buffer` holding all the values of this array. /// /// Note this doesn't take the offset of this array into account. - fn values(&self) -> Buffer; + pub fn values(&self) -> Buffer { + self.data.buffers()[0].clone() + } /// Returns the primitive value at index `i`. /// /// Note this doesn't do any bound checking, for performance reason. - fn value(&self, i: usize) -> T::Native; -} - -impl PrimitiveArrayOps for PrimitiveArray { - fn values(&self) -> Buffer { - self.data.buffers()[0].clone() - } - - fn value(&self, i: usize) -> T::Native { + pub fn value(&self, i: usize) -> T::Native { let offset = i + self.offset(); unsafe { T::index(self.raw_values.get(), offset) } } diff --git a/rust/arrow/src/array/iterator.rs b/rust/arrow/src/array/iterator.rs index 050bba6f4ae..e88321b222d 100644 --- a/rust/arrow/src/array/iterator.rs +++ b/rust/arrow/src/array/iterator.rs @@ -17,7 +17,7 @@ use crate::datatypes::ArrowPrimitiveType; -use super::{Array, PrimitiveArray, PrimitiveArrayOps}; +use super::{Array, PrimitiveArray}; /// an iterator that returns Some(T) or None, that can be used on any non-boolean PrimitiveArray #[derive(Debug)] diff --git a/rust/arrow/src/array/mod.rs b/rust/arrow/src/array/mod.rs index 8770e1a461e..3befa11b981 100644 --- a/rust/arrow/src/array/mod.rs +++ b/rust/arrow/src/array/mod.rs @@ -49,7 +49,7 @@ //! ``` //! extern crate arrow; //! -//! use arrow::array::{Int16Array, PrimitiveArrayOps}; +//! use arrow::array::Int16Array; //! //! // Create a new builder with a capacity of 100 //! let mut builder = Int16Array::builder(100); @@ -160,7 +160,6 @@ pub use self::array::GenericBinaryArray; pub use self::array::GenericListArray; pub use self::array::GenericStringArray; pub use self::array::OffsetSizeTrait; -pub use self::array::PrimitiveArrayOps; pub use self::array::StringOffsetSizeTrait; // --------------------- Array Builder --------------------- diff --git a/rust/arrow/src/compute/kernels/boolean.rs b/rust/arrow/src/compute/kernels/boolean.rs index 248e4c3e595..075ffb0d67b 100644 --- a/rust/arrow/src/compute/kernels/boolean.rs +++ b/rust/arrow/src/compute/kernels/boolean.rs @@ -153,7 +153,6 @@ pub fn is_not_null(input: &ArrayRef) -> Result { mod tests { use super::*; use crate::array::Int32Array; - use crate::array::PrimitiveArrayOps; #[test] fn test_bool_array_and() { diff --git a/rust/arrow/src/compute/kernels/filter.rs b/rust/arrow/src/compute/kernels/filter.rs index 55ce499c3fa..2e6ed1264a9 100644 --- a/rust/arrow/src/compute/kernels/filter.rs +++ b/rust/arrow/src/compute/kernels/filter.rs @@ -17,7 +17,6 @@ //! Defines miscellaneous array kernels. -use crate::array::PrimitiveArrayOps; use crate::array::*; use crate::datatypes::*; use crate::error::{ArrowError, Result}; diff --git a/rust/arrow/src/compute/kernels/sort.rs b/rust/arrow/src/compute/kernels/sort.rs index d881c7f8d1f..ffee0d2a290 100644 --- a/rust/arrow/src/compute/kernels/sort.rs +++ b/rust/arrow/src/compute/kernels/sort.rs @@ -409,7 +409,7 @@ pub struct SortColumn { /// ``` /// use std::convert::From; /// use std::sync::Arc; -/// use arrow::array::{ArrayRef, StringArray, PrimitiveArray, PrimitiveArrayOps, as_primitive_array}; +/// use arrow::array::{ArrayRef, StringArray, PrimitiveArray, as_primitive_array}; /// use arrow::compute::kernels::sort::{SortColumn, SortOptions, lexsort}; /// use arrow::datatypes::Int64Type; /// diff --git a/rust/arrow/src/lib.rs b/rust/arrow/src/lib.rs index e7ee9d3f8f9..6e3eea50896 100644 --- a/rust/arrow/src/lib.rs +++ b/rust/arrow/src/lib.rs @@ -36,7 +36,7 @@ //! can be obtained via [`is_null(index)`](array::Array::is_null). To downcast an [`Array`](array::Array) to a specific implementation, you can use //! //! ```rust -//! use arrow::array::{Array, PrimitiveArrayOps, UInt32Array}; +//! use arrow::array::{Array, UInt32Array}; //! let array = UInt32Array::from(vec![Some(1), None, Some(3)]); //! assert_eq!(array.len(), 3); //! assert_eq!(array.value(0), 1); @@ -61,7 +61,7 @@ //! //! ```rust //! # use std::sync::Arc; -//! # use arrow::array::{UInt32Array, ArrayRef, PrimitiveArrayOps}; +//! # use arrow::array::{UInt32Array, ArrayRef}; //! # let array = UInt32Array::from(vec![Some(1), None, Some(3)]); //! # let array: ArrayRef = Arc::new(array); //! let array = array.as_any().downcast_ref::().unwrap(); diff --git a/rust/arrow/src/util/display.rs b/rust/arrow/src/util/display.rs index bf0cade562f..102ec5d99ed 100644 --- a/rust/arrow/src/util/display.rs +++ b/rust/arrow/src/util/display.rs @@ -20,7 +20,7 @@ //! record batch pretty printing. use crate::array; -use crate::array::{Array, PrimitiveArrayOps}; +use crate::array::Array; use crate::datatypes::{ ArrowNativeType, ArrowPrimitiveType, DataType, Int16Type, Int32Type, Int64Type, Int8Type, TimeUnit, UInt16Type, UInt32Type, UInt64Type, UInt8Type, diff --git a/rust/datafusion/examples/simple_udaf.rs b/rust/datafusion/examples/simple_udaf.rs index 1f41f0db410..c3cd49fec73 100644 --- a/rust/datafusion/examples/simple_udaf.rs +++ b/rust/datafusion/examples/simple_udaf.rs @@ -18,8 +18,8 @@ /// In this example we will declare a single-type, single return type UDAF that computes the geometric mean. /// The geometric mean is described here: https://en.wikipedia.org/wiki/Geometric_mean use arrow::{ - array::Float32Array, array::Float64Array, array::PrimitiveArrayOps, - datatypes::DataType, record_batch::RecordBatch, + array::Float32Array, array::Float64Array, datatypes::DataType, + record_batch::RecordBatch, }; use datafusion::{error::Result, logical_plan::create_udaf, physical_plan::Accumulator}; diff --git a/rust/datafusion/examples/simple_udf.rs b/rust/datafusion/examples/simple_udf.rs index 24e8cf7bd8b..c0d4a04bd15 100644 --- a/rust/datafusion/examples/simple_udf.rs +++ b/rust/datafusion/examples/simple_udf.rs @@ -16,9 +16,7 @@ // under the License. use arrow::{ - array::{ - Array, ArrayRef, Float32Array, Float64Array, Float64Builder, PrimitiveArrayOps, - }, + array::{Array, ArrayRef, Float32Array, Float64Array, Float64Builder}, datatypes::DataType, record_batch::RecordBatch, util::pretty, diff --git a/rust/datafusion/src/datasource/parquet.rs b/rust/datafusion/src/datasource/parquet.rs index ca5ac6bc945..eb4e0beef34 100644 --- a/rust/datafusion/src/datasource/parquet.rs +++ b/rust/datafusion/src/datasource/parquet.rs @@ -69,7 +69,6 @@ impl TableProvider for ParquetTable { #[cfg(test)] mod tests { use super::*; - use arrow::array::PrimitiveArrayOps; use arrow::array::{ BinaryArray, BooleanArray, Float32Array, Float64Array, Int32Array, TimestampNanosecondArray, diff --git a/rust/datafusion/src/execution/context.rs b/rust/datafusion/src/execution/context.rs index 0e2425dbec9..f2a356925d0 100644 --- a/rust/datafusion/src/execution/context.rs +++ b/rust/datafusion/src/execution/context.rs @@ -534,9 +534,7 @@ mod tests { datasource::MemTable, logical_plan::create_udaf, physical_plan::expressions::AvgAccumulator, }; - use arrow::array::{ - ArrayRef, Float64Array, Int32Array, PrimitiveArrayOps, StringArray, - }; + use arrow::array::{ArrayRef, Float64Array, Int32Array, StringArray}; use arrow::compute::add; use std::fs::File; use std::thread::{self, JoinHandle}; diff --git a/rust/datafusion/src/physical_plan/expressions.rs b/rust/datafusion/src/physical_plan/expressions.rs index 3240fe906a1..ce3d038f726 100644 --- a/rust/datafusion/src/physical_plan/expressions.rs +++ b/rust/datafusion/src/physical_plan/expressions.rs @@ -1703,8 +1703,8 @@ mod tests { use arrow::datatypes::*; use arrow::{ array::{ - LargeStringArray, PrimitiveArray, PrimitiveArrayOps, PrimitiveBuilder, - StringArray, StringDictionaryBuilder, Time64NanosecondArray, + LargeStringArray, PrimitiveArray, PrimitiveBuilder, StringArray, + StringDictionaryBuilder, Time64NanosecondArray, }, util::display::array_value_to_string, }; diff --git a/rust/datafusion/src/physical_plan/functions.rs b/rust/datafusion/src/physical_plan/functions.rs index 848184f2f97..afc4690ef34 100644 --- a/rust/datafusion/src/physical_plan/functions.rs +++ b/rust/datafusion/src/physical_plan/functions.rs @@ -362,10 +362,7 @@ mod tests { use super::*; use crate::{error::Result, physical_plan::expressions::lit, scalar::ScalarValue}; use arrow::{ - array::{ - ArrayRef, FixedSizeListArray, Float64Array, Int32Array, PrimitiveArrayOps, - StringArray, - }, + array::{ArrayRef, FixedSizeListArray, Float64Array, Int32Array, StringArray}, datatypes::Field, record_batch::RecordBatch, }; diff --git a/rust/datafusion/src/physical_plan/hash_aggregate.rs b/rust/datafusion/src/physical_plan/hash_aggregate.rs index 0476a9bb837..8d7beadb740 100644 --- a/rust/datafusion/src/physical_plan/hash_aggregate.rs +++ b/rust/datafusion/src/physical_plan/hash_aggregate.rs @@ -28,7 +28,6 @@ use crate::error::{DataFusionError, Result}; use crate::physical_plan::{Accumulator, AggregateExpr}; use crate::physical_plan::{Distribution, ExecutionPlan, Partitioning, PhysicalExpr}; -use crate::arrow::array::PrimitiveArrayOps; use arrow::datatypes::{DataType, Field, Schema, SchemaRef}; use arrow::error::Result as ArrowResult; use arrow::record_batch::RecordBatch; diff --git a/rust/datafusion/src/physical_plan/math_expressions.rs b/rust/datafusion/src/physical_plan/math_expressions.rs index 71eda2b0de3..9ad0e2540df 100644 --- a/rust/datafusion/src/physical_plan/math_expressions.rs +++ b/rust/datafusion/src/physical_plan/math_expressions.rs @@ -19,9 +19,7 @@ use std::sync::Arc; -use arrow::array::{ - make_array, Array, ArrayData, ArrayRef, Float32Array, Float64Array, PrimitiveArrayOps, -}; +use arrow::array::{make_array, Array, ArrayData, ArrayRef, Float32Array, Float64Array}; use arrow::buffer::Buffer; use arrow::datatypes::{DataType, ToByteSlice}; diff --git a/rust/datafusion/src/scalar.rs b/rust/datafusion/src/scalar.rs index 6424508f1bb..83701e51c8c 100644 --- a/rust/datafusion/src/scalar.rs +++ b/rust/datafusion/src/scalar.rs @@ -28,10 +28,7 @@ use arrow::array::{ Int16Builder, Int32Builder, Int64Builder, Int8Builder, ListBuilder, UInt16Builder, UInt32Builder, UInt64Builder, UInt8Builder, }; -use arrow::{ - array::{ArrayRef, PrimitiveArrayOps}, - datatypes::DataType, -}; +use arrow::{array::ArrayRef, datatypes::DataType}; use crate::error::{DataFusionError, Result}; diff --git a/rust/datafusion/src/test/mod.rs b/rust/datafusion/src/test/mod.rs index e2d603ebe4b..67ae056c88e 100644 --- a/rust/datafusion/src/test/mod.rs +++ b/rust/datafusion/src/test/mod.rs @@ -23,7 +23,6 @@ use crate::execution::context::ExecutionContext; use crate::logical_plan::{LogicalPlan, LogicalPlanBuilder}; use crate::physical_plan::ExecutionPlan; use arrow::array; -use arrow::array::PrimitiveArrayOps; use arrow::datatypes::{DataType, Field, Schema, SchemaRef}; use arrow::record_batch::RecordBatch; use std::env; diff --git a/rust/datafusion/tests/user_defined_plan.rs b/rust/datafusion/tests/user_defined_plan.rs index 5536311ecc1..7db7eec516c 100644 --- a/rust/datafusion/tests/user_defined_plan.rs +++ b/rust/datafusion/tests/user_defined_plan.rs @@ -61,7 +61,7 @@ use futures::{FutureExt, Stream, StreamExt, TryStreamExt}; use arrow::{ - array::{Int64Array, PrimitiveArrayOps, StringArray}, + array::{Int64Array, StringArray}, datatypes::SchemaRef, error::ArrowError, record_batch::RecordBatch,