[arrow-rs] branch master updated: Add kernel and tests (#1124)

[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 9a592f6  Add kernel and tests (#1124)
9a592f6 is described below

commit 9a592f6c5ab55a32fa1ae0976d8c53afae0da043
Author: Matthew Turner <matthew.m.tur...@outlook.com>
AuthorDate: Sun Jan 2 06:11:00 2022 -0500

    Add kernel and tests (#1124)
---
 arrow/src/compute/kernels/comparison.rs | 53 +++++++++++++++++++++++++++++++++
 1 file changed, 53 insertions(+)

diff --git a/arrow/src/compute/kernels/comparison.rs 
b/arrow/src/compute/kernels/comparison.rs
index b4de774..8b0c5ff 100644
--- a/arrow/src/compute/kernels/comparison.rs
+++ b/arrow/src/compute/kernels/comparison.rs
@@ -1180,6 +1180,29 @@ pub fn eq_dyn_utf8_scalar(left: Arc<dyn Array>, right: 
&str) -> Result<BooleanAr
     result
 }
 
+/// Perform `left >= right` operation on an array and a numeric scalar
+/// value. Supports StringArrays, and DictionaryArrays that have string values
+pub fn gt_eq_dyn_utf8_scalar(left: Arc<dyn Array>, right: &str) -> 
Result<BooleanArray> {
+    let result = match left.data_type() {
+        DataType::Dictionary(key_type, value_type) => match 
value_type.as_ref() {
+            DataType::Utf8 | DataType::LargeUtf8 => {
+                dyn_compare_utf8_scalar!(&left, right, key_type, 
gt_eq_utf8_scalar)
+            }
+            _ => Err(ArrowError::ComputeError(
+                "gt_eq_dyn_utf8_scalar only supports Utf8 or LargeUtf8 arrays 
or DictionaryArray with Utf8 or LargeUtf8 values".to_string(),
+            )),
+        },
+        DataType::Utf8 | DataType::LargeUtf8 => {
+            let left = as_string_array(&left);
+            gt_eq_utf8_scalar(left, right)
+        }
+        _ => Err(ArrowError::ComputeError(
+            "gt_eq_dyn_utf8_scalar only supports Utf8 or LargeUtf8 
arrays".to_string(),
+        )),
+    };
+    result
+}
+
 /// Perform `left == right` operation on an array and a numeric scalar
 /// value. Supports BooleanArrays, and DictionaryArrays that have string values
 pub fn eq_dyn_bool_scalar(left: Arc<dyn Array>, right: bool) -> 
Result<BooleanArray> {
@@ -3066,6 +3089,36 @@ mod tests {
     }
 
     #[test]
+    fn test_gt_eq_dyn_utf8_scalar() {
+        let array = StringArray::from(vec!["abc", "def", "xyz"]);
+        let array = Arc::new(array);
+        let a_eq = gt_eq_dyn_utf8_scalar(array, "def").unwrap();
+        assert_eq!(
+            a_eq,
+            BooleanArray::from(vec![Some(false), Some(true), Some(true)])
+        );
+    }
+    #[test]
+    fn test_gt_eq_dyn_utf8_scalar_with_dict() {
+        let key_builder = PrimitiveBuilder::<Int8Type>::new(3);
+        let value_builder = StringBuilder::new(100);
+        let mut builder = StringDictionaryBuilder::new(key_builder, 
value_builder);
+        builder.append("abc").unwrap();
+        builder.append_null().unwrap();
+        builder.append("def").unwrap();
+        builder.append("def").unwrap();
+        builder.append("xyz").unwrap();
+        let array = Arc::new(builder.finish());
+        let a_eq = gt_eq_dyn_utf8_scalar(array, "def").unwrap();
+        assert_eq!(
+            a_eq,
+            BooleanArray::from(
+                vec![Some(false), None, Some(true), Some(true), Some(true)]
+            )
+        );
+    }
+
+    #[test]
     fn test_eq_dyn_bool_scalar() {
         let array = BooleanArray::from(vec![true, false, true]);
         let array = Arc::new(array);