You are viewing a plain text version of this content. The canonical link for it is here.
Posted to github@arrow.apache.org by "tustvold (via GitHub)" <gi...@apache.org> on 2023/08/11 18:59:09 UTC

[GitHub] [arrow-rs] tustvold commented on a diff in pull request #4687: Cleanup DynComparator (#2654)

tustvold commented on code in PR #4687:
URL: https://github.com/apache/arrow-rs/pull/4687#discussion_r1291687910


##########
arrow-ord/src/ord.rs:
##########
@@ -21,114 +21,59 @@ use arrow_array::cast::AsArray;
 use arrow_array::types::*;
 use arrow_array::*;
 use arrow_buffer::ArrowNativeType;
-use arrow_schema::{ArrowError, DataType};
+use arrow_schema::ArrowError;
 use std::cmp::Ordering;
 
 /// Compare the values at two arbitrary indices in two arrays.
 pub type DynComparator = Box<dyn Fn(usize, usize) -> Ordering + Send + Sync>;
 
-fn compare_primitives<T: ArrowPrimitiveType>(
+fn compare_primitive<T: ArrowPrimitiveType>(
     left: &dyn Array,
     right: &dyn Array,
 ) -> DynComparator
 where
     T::Native: ArrowNativeTypeOp,
 {
-    let left: PrimitiveArray<T> = PrimitiveArray::from(left.to_data());
-    let right: PrimitiveArray<T> = PrimitiveArray::from(right.to_data());
+    let left = left.as_primitive::<T>().clone();
+    let right = right.as_primitive::<T>().clone();
     Box::new(move |i, j| left.value(i).compare(right.value(j)))
 }
 
 fn compare_boolean(left: &dyn Array, right: &dyn Array) -> DynComparator {
-    let left: BooleanArray = BooleanArray::from(left.to_data());
-    let right: BooleanArray = BooleanArray::from(right.to_data());
+    let left: BooleanArray = left.as_boolean().clone();
+    let right: BooleanArray = right.as_boolean().clone();
 
     Box::new(move |i, j| left.value(i).cmp(&right.value(j)))
 }
 
-fn compare_string(left: &dyn Array, right: &dyn Array) -> DynComparator {
-    let left: StringArray = StringArray::from(left.to_data());
-    let right: StringArray = StringArray::from(right.to_data());
+fn compare_bytes<T: ByteArrayType>(left: &dyn Array, right: &dyn Array) -> DynComparator {
+    let left = left.as_bytes::<T>().clone();
+    let right = right.as_bytes::<T>().clone();
 
-    Box::new(move |i, j| left.value(i).cmp(right.value(j)))
-}
-
-fn compare_dict_primitive<K, V>(left: &dyn Array, right: &dyn Array) -> DynComparator
-where
-    K: ArrowDictionaryKeyType,
-    V: ArrowPrimitiveType,
-    V::Native: ArrowNativeTypeOp,
-{
-    let left = left.as_dictionary::<K>();
-    let right = right.as_dictionary::<K>();
-
-    let left_keys: PrimitiveArray<K> = PrimitiveArray::from(left.keys().to_data());
-    let right_keys: PrimitiveArray<K> = PrimitiveArray::from(right.keys().to_data());
-    let left_values: PrimitiveArray<V> = left.values().to_data().into();
-    let right_values: PrimitiveArray<V> = right.values().to_data().into();
-
-    Box::new(move |i: usize, j: usize| {
-        let key_left = left_keys.value(i).as_usize();
-        let key_right = right_keys.value(j).as_usize();
-        let left = left_values.value(key_left);
-        let right = right_values.value(key_right);
-        left.compare(right)
-    })
-}
-
-fn compare_dict_string<T>(left: &dyn Array, right: &dyn Array) -> DynComparator
-where
-    T: ArrowDictionaryKeyType,
-{
-    let left = left.as_dictionary::<T>();
-    let right = right.as_dictionary::<T>();
-
-    let left_keys: PrimitiveArray<T> = PrimitiveArray::from(left.keys().to_data());
-    let right_keys: PrimitiveArray<T> = PrimitiveArray::from(right.keys().to_data());
-    let left_values = StringArray::from(left.values().to_data());
-    let right_values = StringArray::from(right.values().to_data());
-
-    Box::new(move |i: usize, j: usize| {
-        let key_left = left_keys.value(i).as_usize();
-        let key_right = right_keys.value(j).as_usize();
-        let left = left_values.value(key_left);
-        let right = right_values.value(key_right);
-        left.cmp(right)
+    Box::new(move |i, j| {
+        let l: &[u8] = left.value(i).as_ref();
+        let r: &[u8] = right.value(j).as_ref();
+        l.cmp(r)
     })
 }
 
-fn cmp_dict_primitive<VT>(
-    key_type: &DataType,
+fn compare_dict<K: ArrowDictionaryKeyType>(
     left: &dyn Array,
     right: &dyn Array,
-) -> Result<DynComparator, ArrowError>
-where
-    VT: ArrowPrimitiveType,
-    VT::Native: ArrowNativeTypeOp,
-{
-    use DataType::*;
-
-    Ok(match key_type {
-        UInt8 => compare_dict_primitive::<UInt8Type, VT>(left, right),
-        UInt16 => compare_dict_primitive::<UInt16Type, VT>(left, right),
-        UInt32 => compare_dict_primitive::<UInt32Type, VT>(left, right),
-        UInt64 => compare_dict_primitive::<UInt64Type, VT>(left, right),
-        Int8 => compare_dict_primitive::<Int8Type, VT>(left, right),
-        Int16 => compare_dict_primitive::<Int16Type, VT>(left, right),
-        Int32 => compare_dict_primitive::<Int32Type, VT>(left, right),
-        Int64 => compare_dict_primitive::<Int64Type, VT>(left, right),
-        t => {
-            return Err(ArrowError::InvalidArgumentError(format!(
-                "Dictionaries do not support keys of type {t:?}"
-            )));
-        }
-    })
-}
+) -> Result<DynComparator, ArrowError> {
+    let left = left.as_dictionary::<K>();
+    let right = right.as_dictionary::<K>();
+
+    let cmp = build_compare(left.values().as_ref(), right.values().as_ref())?;
+    let left_keys = left.keys().clone();
+    let right_keys = right.keys().clone();
 
-macro_rules! cmp_dict_primitive_helper {
-    ($t:ty, $key_type_lhs:expr, $left:expr, $right:expr) => {
-        cmp_dict_primitive::<$t>($key_type_lhs, $left, $right)?
-    };
+    // TODO: Handle value nulls (#2687)

Review Comment:
   I'm still thinking about how best to handle this, we could pass SortOptions to build_compare, but this would likely imply making build_compare always handle nulls



-- 
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

To unsubscribe, e-mail: github-unsubscribe@arrow.apache.org

For queries about this service, please contact Infrastructure at:
users@infra.apache.org