Skip to content
This repository has been archived by the owner on Feb 18, 2024. It is now read-only.

Commit

Permalink
Migrated to new Enum.
Browse files Browse the repository at this point in the history
  • Loading branch information
@jorgecarleitao
jorgecarleitao committed Aug 31, 2021
1 parent 5f86cc7 commit cd9600e
Show file tree
Hide file tree
Showing 20 changed files with 137 additions and 435 deletions.
61 changes: 3 additions & 58 deletions src/array/equal/mod.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -173,66 +173,11 @@ pub fn equal(lhs: &dyn Array, rhs: &dyn Array) -> bool {
let rhs = rhs.as_any().downcast_ref().unwrap();
boolean::equal(lhs, rhs)
}
UInt8 => {
Primitive(primitive) => with_match_primitive_type!(primitive, |$T| {
let lhs = lhs.as_any().downcast_ref().unwrap();
let rhs = rhs.as_any().downcast_ref().unwrap();
primitive::equal::<u8>(lhs, rhs)
}
UInt16 => {
let lhs = lhs.as_any().downcast_ref().unwrap();
let rhs = rhs.as_any().downcast_ref().unwrap();
primitive::equal::<u16>(lhs, rhs)
}
UInt32 => {
let lhs = lhs.as_any().downcast_ref().unwrap();
let rhs = rhs.as_any().downcast_ref().unwrap();
primitive::equal::<u32>(lhs, rhs)
}
UInt64 => {
let lhs = lhs.as_any().downcast_ref().unwrap();
let rhs = rhs.as_any().downcast_ref().unwrap();
primitive::equal::<u64>(lhs, rhs)
}
Int8 => {
let lhs = lhs.as_any().downcast_ref().unwrap();
let rhs = rhs.as_any().downcast_ref().unwrap();
primitive::equal::<i8>(lhs, rhs)
}
Int16 => {
let lhs = lhs.as_any().downcast_ref().unwrap();
let rhs = rhs.as_any().downcast_ref().unwrap();
primitive::equal::<i16>(lhs, rhs)
}
Int32 => {
let lhs = lhs.as_any().downcast_ref().unwrap();
let rhs = rhs.as_any().downcast_ref().unwrap();
primitive::equal::<i32>(lhs, rhs)
}
Int64 => {
let lhs = lhs.as_any().downcast_ref().unwrap();
let rhs = rhs.as_any().downcast_ref().unwrap();
primitive::equal::<i64>(lhs, rhs)
}
Int128 => {
let lhs = lhs.as_any().downcast_ref().unwrap();
let rhs = rhs.as_any().downcast_ref().unwrap();
primitive::equal::<i128>(lhs, rhs)
}
DaysMs => {
let lhs = lhs.as_any().downcast_ref().unwrap();
let rhs = rhs.as_any().downcast_ref().unwrap();
primitive::equal::<days_ms>(lhs, rhs)
}
Float32 => {
let lhs = lhs.as_any().downcast_ref().unwrap();
let rhs = rhs.as_any().downcast_ref().unwrap();
primitive::equal::<f32>(lhs, rhs)
}
Float64 => {
let lhs = lhs.as_any().downcast_ref().unwrap();
let rhs = rhs.as_any().downcast_ref().unwrap();
primitive::equal::<f64>(lhs, rhs)
}
primitive::equal::<$T>(lhs, rhs)
}),
Utf8 => {
let lhs = lhs.as_any().downcast_ref().unwrap();
let rhs = rhs.as_any().downcast_ref().unwrap();
Expand Down
15 changes: 3 additions & 12 deletions src/array/ffi.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -45,18 +45,9 @@ pub fn buffers_children_dictionary(array: &dyn Array) -> BuffersChildren {
match array.data_type().to_physical_type() {
Null => ffi_dyn!(array, NullArray),
Boolean => ffi_dyn!(array, BooleanArray),
Int8 => ffi_dyn!(array, PrimitiveArray<i8>),
Int16 => ffi_dyn!(array, PrimitiveArray<i16>),
Int32 => ffi_dyn!(array, PrimitiveArray<i32>),
DaysMs => ffi_dyn!(array, PrimitiveArray<days_ms>),
Int64 => ffi_dyn!(array, PrimitiveArray<i64>),
Int128 => ffi_dyn!(array, PrimitiveArray<i128>),
UInt8 => ffi_dyn!(array, PrimitiveArray<u8>),
UInt16 => ffi_dyn!(array, PrimitiveArray<u16>),
UInt32 => ffi_dyn!(array, PrimitiveArray<u32>),
UInt64 => ffi_dyn!(array, PrimitiveArray<u64>),
Float32 => ffi_dyn!(array, PrimitiveArray<f32>),
Float64 => ffi_dyn!(array, PrimitiveArray<f64>),
Primitive(primitive) => with_match_primitive_type!(primitive, |$T| {
ffi_dyn!(array, PrimitiveArray<$T>)
}),
Binary => ffi_dyn!(array, BinaryArray<i32>),
LargeBinary => ffi_dyn!(array, BinaryArray<i64>),
FixedSizeBinary => ffi_dyn!(array, FixedSizeBinaryArray),
Expand Down
15 changes: 3 additions & 12 deletions src/array/growable/mod.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -110,18 +110,9 @@ pub fn make_growable<'a>(
capacity,
))
}
Int8 => dyn_growable!(i8, arrays, use_validity, capacity),
Int16 => dyn_growable!(i16, arrays, use_validity, capacity),
Int32 => dyn_growable!(i32, arrays, use_validity, capacity),
Int64 => dyn_growable!(i64, arrays, use_validity, capacity),
Int128 => dyn_growable!(i128, arrays, use_validity, capacity),
DaysMs => dyn_growable!(days_ms, arrays, use_validity, capacity),
UInt8 => dyn_growable!(u8, arrays, use_validity, capacity),
UInt16 => dyn_growable!(u16, arrays, use_validity, capacity),
UInt32 => dyn_growable!(u32, arrays, use_validity, capacity),
UInt64 => dyn_growable!(u64, arrays, use_validity, capacity),
Float32 => dyn_growable!(f32, arrays, use_validity, capacity),
Float64 => dyn_growable!(f64, arrays, use_validity, capacity),
Primitive(primitive) => with_match_primitive_type!(primitive, |$T| {
dyn_growable!($T, arrays, use_validity, capacity)
}),
Utf8 => {
let arrays = arrays
.iter()
Expand Down
81 changes: 33 additions & 48 deletions src/array/mod.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -181,24 +181,36 @@ macro_rules! with_match_physical_dictionary_key_type {(
}
})}

macro_rules! with_match_primitive_type {(
$key_type:expr, | $_:tt $T:ident | $($body:tt)*
) => ({
macro_rules! __with_ty__ {( $_ $T:ident ) => ( $($body)* )}
use crate::datatypes::PrimitiveType::*;
match $key_type {
Int8 => __with_ty__! { i8 },
Int16 => __with_ty__! { i16 },
Int32 => __with_ty__! { i32 },
Int64 => __with_ty__! { i64 },
Int128 => __with_ty__! { i128 },
DaysMs => __with_ty__! { days_ms },
UInt8 => __with_ty__! { u8 },
UInt16 => __with_ty__! { u16 },
UInt32 => __with_ty__! { u32 },
UInt64 => __with_ty__! { u64 },
Float32 => __with_ty__! { f32 },
Float64 => __with_ty__! { f64 },
}
})}

impl Display for dyn Array {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
use crate::datatypes::PhysicalType::*;
match self.data_type().to_physical_type() {
Null => fmt_dyn!(self, NullArray, f),
Boolean => fmt_dyn!(self, BooleanArray, f),
Int8 => fmt_dyn!(self, PrimitiveArray<i8>, f),
Int16 => fmt_dyn!(self, PrimitiveArray<i16>, f),
Int32 => fmt_dyn!(self, PrimitiveArray<i32>, f),
DaysMs => fmt_dyn!(self, PrimitiveArray<days_ms>, f),
Int64 => fmt_dyn!(self, PrimitiveArray<i64>, f),
Int128 => fmt_dyn!(self, PrimitiveArray<i128>, f),
UInt8 => fmt_dyn!(self, PrimitiveArray<u8>, f),
UInt16 => fmt_dyn!(self, PrimitiveArray<u16>, f),
UInt32 => fmt_dyn!(self, PrimitiveArray<u32>, f),
UInt64 => fmt_dyn!(self, PrimitiveArray<u64>, f),
Float32 => fmt_dyn!(self, PrimitiveArray<f32>, f),
Float64 => fmt_dyn!(self, PrimitiveArray<f64>, f),
Primitive(primitive) => with_match_primitive_type!(primitive, |$T| {
fmt_dyn!(self, PrimitiveArray<$T>, f)
}),
Binary => fmt_dyn!(self, BinaryArray<i32>, f),
LargeBinary => fmt_dyn!(self, BinaryArray<i64>, f),
FixedSizeBinary => fmt_dyn!(self, FixedSizeBinaryArray, f),
Expand All @@ -224,18 +236,9 @@ pub fn new_empty_array(data_type: DataType) -> Box<dyn Array> {
match data_type.to_physical_type() {
Null => Box::new(NullArray::new_empty(data_type)),
Boolean => Box::new(BooleanArray::new_empty(data_type)),
Int8 => Box::new(PrimitiveArray::<i8>::new_empty(data_type)),
Int16 => Box::new(PrimitiveArray::<i16>::new_empty(data_type)),
Int32 => Box::new(PrimitiveArray::<i32>::new_empty(data_type)),
DaysMs => Box::new(PrimitiveArray::<days_ms>::new_empty(data_type)),
Int64 => Box::new(PrimitiveArray::<i64>::new_empty(data_type)),
Int128 => Box::new(PrimitiveArray::<i128>::new_empty(data_type)),
UInt8 => Box::new(PrimitiveArray::<u8>::new_empty(data_type)),
UInt16 => Box::new(PrimitiveArray::<u16>::new_empty(data_type)),
UInt32 => Box::new(PrimitiveArray::<u32>::new_empty(data_type)),
UInt64 => Box::new(PrimitiveArray::<u64>::new_empty(data_type)),
Float32 => Box::new(PrimitiveArray::<f32>::new_empty(data_type)),
Float64 => Box::new(PrimitiveArray::<f64>::new_empty(data_type)),
Primitive(primitive) => with_match_primitive_type!(primitive, |$T| {
Box::new(PrimitiveArray::<$T>::new_empty(data_type))
}),
Binary => Box::new(BinaryArray::<i32>::new_empty(data_type)),
LargeBinary => Box::new(BinaryArray::<i64>::new_empty(data_type)),
FixedSizeBinary => Box::new(FixedSizeBinaryArray::new_empty(data_type)),
Expand All @@ -262,18 +265,9 @@ pub fn new_null_array(data_type: DataType, length: usize) -> Box<dyn Array> {
match data_type.to_physical_type() {
Null => Box::new(NullArray::new_null(data_type, length)),
Boolean => Box::new(BooleanArray::new_null(data_type, length)),
Int8 => Box::new(PrimitiveArray::<i8>::new_null(data_type, length)),
Int16 => Box::new(PrimitiveArray::<i16>::new_null(data_type, length)),
Int32 => Box::new(PrimitiveArray::<i32>::new_null(data_type, length)),
DaysMs => Box::new(PrimitiveArray::<days_ms>::new_null(data_type, length)),
Int64 => Box::new(PrimitiveArray::<i64>::new_null(data_type, length)),
Int128 => Box::new(PrimitiveArray::<i128>::new_null(data_type, length)),
UInt8 => Box::new(PrimitiveArray::<u8>::new_null(data_type, length)),
UInt16 => Box::new(PrimitiveArray::<u16>::new_null(data_type, length)),
UInt32 => Box::new(PrimitiveArray::<u32>::new_null(data_type, length)),
UInt64 => Box::new(PrimitiveArray::<u64>::new_null(data_type, length)),
Float32 => Box::new(PrimitiveArray::<f32>::new_null(data_type, length)),
Float64 => Box::new(PrimitiveArray::<f64>::new_null(data_type, length)),
Primitive(primitive) => with_match_primitive_type!(primitive, |$T| {
Box::new(PrimitiveArray::<$T>::new_null(data_type, length))
}),
Binary => Box::new(BinaryArray::<i32>::new_null(data_type, length)),
LargeBinary => Box::new(BinaryArray::<i64>::new_null(data_type, length)),
FixedSizeBinary => Box::new(FixedSizeBinaryArray::new_null(data_type, length)),
Expand Down Expand Up @@ -308,18 +302,9 @@ pub fn clone(array: &dyn Array) -> Box<dyn Array> {
match array.data_type().to_physical_type() {
Null => clone_dyn!(array, NullArray),
Boolean => clone_dyn!(array, BooleanArray),
Int8 => clone_dyn!(array, PrimitiveArray<i8>),
Int16 => clone_dyn!(array, PrimitiveArray<i16>),
Int32 => clone_dyn!(array, PrimitiveArray<i32>),
DaysMs => clone_dyn!(array, PrimitiveArray<days_ms>),
Int64 => clone_dyn!(array, PrimitiveArray<i64>),
Int128 => clone_dyn!(array, PrimitiveArray<i128>),
UInt8 => clone_dyn!(array, PrimitiveArray<u8>),
UInt16 => clone_dyn!(array, PrimitiveArray<u16>),
UInt32 => clone_dyn!(array, PrimitiveArray<u32>),
UInt64 => clone_dyn!(array, PrimitiveArray<u64>),
Float32 => clone_dyn!(array, PrimitiveArray<f32>),
Float64 => clone_dyn!(array, PrimitiveArray<f64>),
Primitive(primitive) => with_match_primitive_type!(primitive, |$T| {
clone_dyn!(array, PrimitiveArray<$T>)
}),
Binary => clone_dyn!(array, BinaryArray<i32>),
LargeBinary => clone_dyn!(array, BinaryArray<i64>),
FixedSizeBinary => clone_dyn!(array, FixedSizeBinaryArray),
Expand Down
31 changes: 8 additions & 23 deletions src/compute/aggregate/memory.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -7,17 +7,6 @@ fn validity_size(validity: &Option<Bitmap>) -> usize {
validity.as_ref().map(|b| b.as_slice().0.len()).unwrap_or(0)
}

macro_rules! dyn_primitive {
($array:expr, $ty:ty) => {{
let array = $array
.as_any()
.downcast_ref::<PrimitiveArray<$ty>>()
.unwrap();

array.values().len() * std::mem::size_of::<$ty>() + validity_size(array.validity())
}};
}

macro_rules! dyn_binary {
($array:expr, $ty:ty, $o:ty) => {{
let array = $array.as_any().downcast_ref::<$ty>().unwrap();
Expand Down Expand Up @@ -57,18 +46,14 @@ pub fn estimated_bytes_size(array: &dyn Array) -> usize {
let array = array.as_any().downcast_ref::<BooleanArray>().unwrap();
array.values().as_slice().0.len() + validity_size(array.validity())
}
Int8 => dyn_primitive!(array, i8),
Int16 => dyn_primitive!(array, i16),
Int32 => dyn_primitive!(array, i32),
Int64 => dyn_primitive!(array, i64),
Int128 => dyn_primitive!(array, i128),
DaysMs => dyn_primitive!(array, days_ms),
UInt8 => dyn_primitive!(array, u16),
UInt16 => dyn_primitive!(array, u16),
UInt32 => dyn_primitive!(array, u32),
UInt64 => dyn_primitive!(array, u64),
Float32 => dyn_primitive!(array, f32),
Float64 => dyn_primitive!(array, f64),
Primitive(primitive) => with_match_primitive_type!(primitive, |$T| {
let array = array
.as_any()
.downcast_ref::<PrimitiveArray<$T>>()
.unwrap();

array.values().len() * std::mem::size_of::<$T>() + validity_size(array.validity())
}),
Binary => dyn_binary!(array, BinaryArray<i32>, i32),
FixedSizeBinary => {
let array = array
Expand Down
81 changes: 11 additions & 70 deletions src/compute/filter.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -85,17 +85,6 @@ fn filter_growable<'a>(growable: &mut impl Growable<'a>, chunks: &[(usize, usize
.for_each(|(start, len)| growable.extend(0, *start, *len));
}

macro_rules! dyn_filter {
($ty:ty, $array:expr, $filter_count:expr, $chunks:expr) => {{
let array = $array.as_any().downcast_ref().unwrap();
let mut growable =
growable::GrowablePrimitive::<$ty>::new(vec![array], false, $filter_count);
filter_growable(&mut growable, &$chunks);
let array: PrimitiveArray<$ty> = growable.into();
Box::new(array)
}};
}

/// Returns a prepared function optimized to filter multiple arrays.
/// Creating this function requires time, but using it is faster than [filter] when the
/// same filter needs to be applied to multiple arrays (e.g. a multi-column `RecordBatch`).
Expand All @@ -109,18 +98,14 @@ pub fn build_filter(filter: &BooleanArray) -> Result<Filter> {
use crate::datatypes::PhysicalType::*;
Ok(Box::new(move |array: &dyn Array| {
match array.data_type().to_physical_type() {
UInt8 => dyn_filter!(u8, array, filter_count, chunks),
UInt16 => dyn_filter!(u16, array, filter_count, chunks),
UInt32 => dyn_filter!(u32, array, filter_count, chunks),
UInt64 => dyn_filter!(u64, array, filter_count, chunks),
Int8 => dyn_filter!(i8, array, filter_count, chunks),
Int16 => dyn_filter!(i16, array, filter_count, chunks),
Int32 => dyn_filter!(i32, array, filter_count, chunks),
Int64 => dyn_filter!(i64, array, filter_count, chunks),
Int128 => dyn_filter!(i128, array, filter_count, chunks),
DaysMs => dyn_filter!(days_ms, array, filter_count, chunks),
Float32 => dyn_filter!(f32, array, filter_count, chunks),
Float64 => dyn_filter!(f64, array, filter_count, chunks),
Primitive(primitive) => with_match_primitive_type!(primitive, |$T| {
let array = array.as_any().downcast_ref().unwrap();
let mut growable =
growable::GrowablePrimitive::<$T>::new(vec![array], false, filter_count);
filter_growable(&mut growable, &chunks);
let array: PrimitiveArray<$T> = growable.into();
Box::new(array)
}),
Utf8 => {
let array = array.as_any().downcast_ref::<Utf8Array<i32>>().unwrap();
let mut growable = growable::GrowableUtf8::new(vec![array], false, filter_count);
Expand Down Expand Up @@ -166,54 +151,10 @@ pub fn build_filter(filter: &BooleanArray) -> Result<Filter> {
pub fn filter(array: &dyn Array, filter: &BooleanArray) -> Result<Box<dyn Array>> {
use crate::datatypes::PhysicalType::*;
match array.data_type().to_physical_type() {
UInt8 => {
let array = array.as_any().downcast_ref().unwrap();
Ok(Box::new(filter_primitive::<u8>(array, filter)))
}
UInt16 => {
let array = array.as_any().downcast_ref().unwrap();
Ok(Box::new(filter_primitive::<u16>(array, filter)))
}
UInt32 => {
let array = array.as_any().downcast_ref().unwrap();
Ok(Box::new(filter_primitive::<u32>(array, filter)))
}
UInt64 => {
let array = array.as_any().downcast_ref().unwrap();
Ok(Box::new(filter_primitive::<u64>(array, filter)))
}
Int8 => {
let array = array.as_any().downcast_ref().unwrap();
Ok(Box::new(filter_primitive::<i8>(array, filter)))
}
Int16 => {
Primitive(primitive) => with_match_primitive_type!(primitive, |$T| {
let array = array.as_any().downcast_ref().unwrap();
Ok(Box::new(filter_primitive::<i16>(array, filter)))
}
Int32 => {
let array = array.as_any().downcast_ref().unwrap();
Ok(Box::new(filter_primitive::<i32>(array, filter)))
}
Int64 => {
let array = array.as_any().downcast_ref().unwrap();
Ok(Box::new(filter_primitive::<i64>(array, filter)))
}
Int128 => {
let array = array.as_any().downcast_ref().unwrap();
Ok(Box::new(filter_primitive::<i128>(array, filter)))
}
DaysMs => {
let array = array.as_any().downcast_ref().unwrap();
Ok(Box::new(filter_primitive::<days_ms>(array, filter)))
}
Float32 => {
let array = array.as_any().downcast_ref().unwrap();
Ok(Box::new(filter_primitive::<f32>(array, filter)))
}
Float64 => {
let array = array.as_any().downcast_ref().unwrap();
Ok(Box::new(filter_primitive::<f64>(array, filter)))
}
Ok(Box::new(filter_primitive::<$T>(array, filter)))
}),
_ => {
let iter = SlicesIterator::new(filter.values());
let mut mutable = make_growable(&[array], false, iter.slots());
Expand Down
Loading

0 comments on commit cd9600e

Please sign in to comment.