[arrow-rs] branch master updated: Add lt eq dyn scalar kernel (#1115)

[alamb]

This is an automated email from the ASF dual-hosted git repository.

alamb pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/arrow-rs.git


The following commit(s) were added to refs/heads/master by this push:
     new fe106e0  Add lt eq dyn scalar kernel (#1115)
fe106e0 is described below

commit fe106e0f27dc9d3ad568a4dac0b800640bb5eb28
Author: Matthew Turner <matthew.m.tur...@outlook.com>
AuthorDate: Sun Jan 2 06:33:51 2022 -0500

    Add lt eq dyn scalar kernel (#1115)
    
    * Add lt_dyn_scalar and tests
    
    * Add lt_eq_dyn_scalar kernel
    
    * Add kernel to error message
    
    * fix merge problem
    
    Co-authored-by: Andrew Lamb <and...@nerdnetworks.org>
---
 arrow/src/compute/kernels/comparison.rs | 69 ++++++++++++++++++++++++++++++++-
 1 file changed, 67 insertions(+), 2 deletions(-)

diff --git a/arrow/src/compute/kernels/comparison.rs 
b/arrow/src/compute/kernels/comparison.rs
index 17617fb..60ba634 100644
--- a/arrow/src/compute/kernels/comparison.rs
+++ b/arrow/src/compute/kernels/comparison.rs
@@ -1138,7 +1138,7 @@ where
             | DataType::UInt32
             | DataType::UInt64 => {dyn_compare_scalar!(&left, right, key_type, 
lt_scalar)}
             _ => Err(ArrowError::ComputeError(
-                "lt_dyn_scalar only supports PrimitiveArray or DictionaryArray 
with Primitive values".to_string(),
+                "Kernel only supports PrimitiveArray or DictionaryArray with 
Primitive values".to_string(),
             ))
         }
         DataType::Int8
@@ -1152,7 +1152,43 @@ where
             dyn_compare_scalar!(&left, right, lt_scalar)
         }
         _ => Err(ArrowError::ComputeError(
-            "lt_dyn_scalar only supports PrimitiveArray or DictionaryArray 
with Primitive values".to_string(),
+            "Kernel only supports PrimitiveArray or DictionaryArray with 
Primitive values".to_string(),
+        ))
+    }
+}
+
+/// Perform `left <= right` operation on an array and a numeric scalar
+/// value. Supports PrimitiveArrays, and DictionaryArrays that have primitive 
values
+pub fn lt_eq_dyn_scalar<T>(left: Arc<dyn Array>, right: T) -> 
Result<BooleanArray>
+where
+    T: TryInto<i128> + Copy + std::fmt::Debug,
+{
+    match left.data_type() {
+        DataType::Dictionary(key_type, value_type) => match 
value_type.as_ref() {
+            DataType::Int8
+            | DataType::Int16
+            | DataType::Int32
+            | DataType::Int64
+            | DataType::UInt8
+            | DataType::UInt16
+            | DataType::UInt32
+            | DataType::UInt64 => {dyn_compare_scalar!(&left, right, key_type, 
lt_eq_scalar)}
+            _ => Err(ArrowError::ComputeError(
+                "lt_eq_dyn_scalar only supports PrimitiveArray or 
DictionaryArray with Primitive values".to_string(),
+            ))
+        }
+        DataType::Int8
+        | DataType::Int16
+        | DataType::Int32
+        | DataType::Int64
+        | DataType::UInt8
+        | DataType::UInt16
+        | DataType::UInt32
+        | DataType::UInt64 => {
+            dyn_compare_scalar!(&left, right, lt_eq_scalar)
+        }
+        _ => Err(ArrowError::ComputeError(
+            "lt_eq_dyn_scalar only supports PrimitiveArray or DictionaryArray 
with Primitive values".to_string(),
         ))
     }
 }
@@ -3082,6 +3118,34 @@ mod tests {
         );
     }
     #[test]
+    fn test_lt_eq_dyn_scalar() {
+        let array = Int32Array::from(vec![6, 7, 8, 8, 10]);
+        let array = Arc::new(array);
+        let a_eq = lt_eq_dyn_scalar(array, 8).unwrap();
+        assert_eq!(
+            a_eq,
+            BooleanArray::from(
+                vec![Some(true), Some(true), Some(true), Some(true), 
Some(false)]
+            )
+        );
+    }
+    #[test]
+    fn test_lt_eq_dyn_scalar_with_dict() {
+        let key_builder = PrimitiveBuilder::<Int8Type>::new(3);
+        let value_builder = PrimitiveBuilder::<Int32Type>::new(2);
+        let mut builder = PrimitiveDictionaryBuilder::new(key_builder, 
value_builder);
+        builder.append(123).unwrap();
+        builder.append_null().unwrap();
+        builder.append(23).unwrap();
+        let array = Arc::new(builder.finish());
+        let a_eq = lt_eq_dyn_scalar(array, 23).unwrap();
+        assert_eq!(
+            a_eq,
+            BooleanArray::from(vec![Some(false), None, Some(true)])
+        );
+    }
+
+    #[test]
     fn test_eq_dyn_utf8_scalar() {
         let array = StringArray::from(vec!["abc", "def", "xyz"]);
         let array = Arc::new(array);
@@ -3091,6 +3155,7 @@ mod tests {
             BooleanArray::from(vec![Some(false), Some(false), Some(true)])
         );
     }
+
     #[test]
     fn test_eq_dyn_utf8_scalar_with_dict() {
         let key_builder = PrimitiveBuilder::<Int8Type>::new(3);