Added and_scalar and or_scalar for boolean

src/compute/boolean.rs

@@ -3,11 +3,16 @@ use crate::array::{Array, BooleanArray};
 use crate::bitmap::{Bitmap, MutableBitmap};
 use crate::datatypes::DataType;
 use crate::error::{ArrowError, Result};
+use crate::scalar::BooleanScalar;
 
 use super::utils::combine_validities;
 
-/// Helper function to implement binary kernels
-fn binary_boolean_kernel<F>(lhs: &BooleanArray, rhs: &BooleanArray, op: F) -> Result<BooleanArray>
+/// Helper function to implement binary kernels for two boolean arrays
+fn binary_boolean_arrays_kernel<F>(
+    lhs: &BooleanArray,
+    rhs: &BooleanArray,
+    op: F,
+) -> Result<BooleanArray>
 where
     F: Fn(&Bitmap, &Bitmap) -> Bitmap,
 {
@@ -27,6 +32,25 @@ where
     Ok(BooleanArray::from_data(DataType::Boolean, values, validity))
 }
 
+/// Helper function to implement binary kernels for a boolean array and a boolean scalar
+fn binary_boolean_array_and_scalar_kernel<F>(
+    array: &BooleanArray,
+    scalar: &BooleanScalar,
+    op: F,
+) -> BooleanArray
+where
+    F: Fn(bool, bool) -> bool,
+{
+    let (rhs, validity) = match scalar.value() {
+        Some(val) => (val, array.validity().cloned()),
+        None => (bool::default(), Some(Bitmap::new_zeroed(array.len()))),
+    };
+
+    let values = Bitmap::from_trusted_len_iter(array.values_iter().map(|x| op(x, rhs)));
+
+    BooleanArray::from_data(DataType::Boolean, values, validity)
+}
+
 /// Performs `AND` operation on two arrays. If either left or right value is null then the
 /// result is also null.
 /// # Error
@@ -45,7 +69,7 @@ where
 /// # }
 /// ```
 pub fn and(lhs: &BooleanArray, rhs: &BooleanArray) -> Result<BooleanArray> {
-    binary_boolean_kernel(lhs, rhs, |lhs, rhs| lhs & rhs)
+    binary_boolean_arrays_kernel(lhs, rhs, |lhs, rhs| lhs & rhs)
 }
 
 /// Performs `OR` operation on two arrays. If either left or right value is null then the
@@ -66,7 +90,7 @@ pub fn and(lhs: &BooleanArray, rhs: &BooleanArray) -> Result<BooleanArray> {
 /// # }
 /// ```
 pub fn or(lhs: &BooleanArray, rhs: &BooleanArray) -> Result<BooleanArray> {
-    binary_boolean_kernel(lhs, rhs, |lhs, rhs| lhs | rhs)
+    binary_boolean_arrays_kernel(lhs, rhs, |lhs, rhs| lhs | rhs)
 }
 
 /// Performs unary `NOT` operation on an arrays. If value is null then the result is also
@@ -133,3 +157,39 @@ pub fn is_not_null(input: &dyn Array) -> BooleanArray {
     };
     BooleanArray::from_data(DataType::Boolean, values, None)
 }
+
+/// Performs `AND` operation on an array and a scalar value. If either left or right value
+/// is null then the result is also null.
+/// # Example
+/// ```rust
+/// use arrow2::array::BooleanArray;
+/// use arrow2::compute::boolean::and_scalar;
+/// use arrows::scalar::BooleanScalar;
+/// # fn main() {
+/// let array = BooleanArray::from_slice(vec![false, false, true, true]);
+/// let scalar = BooleanScalar::new(Some(true));
+/// let result = and_scalar(&array, &scalar);
+/// assert_eq!(result, BooleanArray::from(vec![false, false, true, true]));
+/// # }
+/// ```
+pub fn and_scalar(array: &BooleanArray, scalar: &BooleanScalar) -> BooleanArray {
+    binary_boolean_array_and_scalar_kernel(array, scalar, |lhs, rhs| lhs && rhs)
+}
+
+/// Performs `OR` operation on an array and a scalar value. If either left or right value
+/// is null then the result is also null.
+/// # Example
+/// ```rust
+/// use arrow2::array::BooleanArray;
+/// use arrow2::compute::boolean::or_scalar;
+/// use arrows::scalar::BooleanScalar;
+/// # fn main() {
+/// let array = BooleanArray::from_slice(vec![false, false, true, true]);
+/// let scalar = BooleanScalar::new(Some(true));
+/// let result = or_scalar(&array, &scalar);
+/// assert_eq!(result, BooleanArray::from(vec![true, true, true, true]));
+/// # }
+/// ```
+pub fn or_scalar(array: &BooleanArray, scalar: &BooleanScalar) -> BooleanArray {
+    binary_boolean_array_and_scalar_kernel(array, scalar, |lhs, rhs| lhs || rhs)
+}

tests/it/compute/boolean.rs

@@ -1,5 +1,6 @@
 use arrow2::array::*;
 use arrow2::compute::boolean::*;
+use arrow2::scalar::BooleanScalar;
 
 #[test]
 fn array_and() {
@@ -336,3 +337,84 @@ fn test_nullable_array_with_offset_is_not_null() {
 
     assert_eq!(expected, res);
 }
+
+#[test]
+fn array_and_scalar() {
+    let array = BooleanArray::from_slice(vec![false, false, true, true]);
+
+    let scalar = BooleanScalar::new(Some(true));
+    let real = and_scalar(&array, &scalar);
+
+    let expected = BooleanArray::from_slice(vec![false, false, true, true]);
+    assert_eq!(real, expected);
+
+    let scalar = BooleanScalar::new(Some(false));
+    let real = and_scalar(&array, &scalar);
+
+    let expected = BooleanArray::from_slice(vec![false, false, false, false]);
+
+    assert_eq!(real, expected);
+}
+
+#[test]
+fn array_and_scalar_validity() {
+    let array = BooleanArray::from(vec![None, Some(false), Some(true)]);
+
+    let scalar = BooleanScalar::new(Some(true));
+    let real = and_scalar(&array, &scalar);
+
+    let expected = BooleanArray::from(vec![None, Some(false), Some(true)]);
+    assert_eq!(real, expected);
+
+    let scalar = BooleanScalar::new(None);
+    let real = and_scalar(&array, &scalar);
+
+    let expected = BooleanArray::from(vec![None; 3]);
+    assert_eq!(real, expected);
+
+    let array = BooleanArray::from_slice(vec![true, false, true]);
+    let real = and_scalar(&array, &scalar);
+
+    let expected = BooleanArray::from(vec![None; 3]);
+    assert_eq!(real, expected);
+}
+
+#[test]
+fn array_or_scalar() {
+    let array = BooleanArray::from_slice(vec![false, false, true, true]);
+
+    let scalar = BooleanScalar::new(Some(true));
+    let real = or_scalar(&array, &scalar);
+
+    let expected = BooleanArray::from_slice(vec![true, true, true, true]);
+    assert_eq!(real, expected);
+
+    let scalar = BooleanScalar::new(Some(false));
+    let real = or_scalar(&array, &scalar);
+
+    let expected = BooleanArray::from_slice(vec![false, false, true, true]);
+    assert_eq!(real, expected);
+}
+
+#[test]
+fn array_or_scalar_validity() {
+    let array = BooleanArray::from(vec![None, Some(false), Some(true)]);
+
+    let scalar = BooleanScalar::new(Some(true));
+    let real = or_scalar(&array, &scalar);
+
+    let expected = BooleanArray::from(vec![None, Some(true), Some(true)]);
+    assert_eq!(real, expected);
+
+    let scalar = BooleanScalar::new(None);
+    let real = or_scalar(&array, &scalar);
+
+    let expected = BooleanArray::from(vec![None; 3]);
+    assert_eq!(real, expected);
+
+    let array = BooleanArray::from_slice(vec![true, false, true]);
+    let real = and_scalar(&array, &scalar);
+
+    let expected = BooleanArray::from(vec![None; 3]);
+    assert_eq!(real, expected);
+}