Inline Kleene boolean kernels

encodings/bytebool/src/compute.rs

@@ -6,17 +6,24 @@ use vortex_array::ArrayRef;
 use vortex_array::ArrayView;
 use vortex_array::ExecutionCtx;
 use vortex_array::IntoArray;
+use vortex_array::arrays::Constant;
 use vortex_array::arrays::PrimitiveArray;
 use vortex_array::arrays::dict::TakeExecute;
 use vortex_array::buffer::BufferHandle;
 use vortex_array::dtype::DType;
 use vortex_array::match_each_integer_ptype;
+use vortex_array::scalar_fn::fns::binary::BooleanKernel;
+use vortex_array::scalar_fn::fns::binary::kleene_boolean_buffer_scalar;
+use vortex_array::scalar_fn::fns::binary::kleene_boolean_buffers;
 use vortex_array::scalar_fn::fns::cast::CastKernel;
 use vortex_array::scalar_fn::fns::cast::CastReduce;
 use vortex_array::scalar_fn::fns::mask::MaskReduce;
+use vortex_array::scalar_fn::fns::operators::Operator;
 use vortex_array::validity::Validity;
+use vortex_buffer::BitBuffer;
 use vortex_buffer::ByteBuffer;
 use vortex_error::VortexResult;
+use vortex_error::vortex_err;
 
 use super::ByteBool;
 
@@ -106,9 +113,60 @@ impl TakeExecute for ByteBool {
     }
 }
 
+impl BooleanKernel for ByteBool {
+    fn boolean(
+        lhs: ArrayView<'_, Self>,
+        rhs: &ArrayRef,
+        operator: Operator,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Option<ArrayRef>> {
+        let nullability = lhs.dtype().nullability() | rhs.dtype().nullability();
+        let lhs_values = truthy_bit_buffer(lhs);
+
+        if let Some(rhs) = rhs.as_opt::<Constant>() {
+            let rhs = rhs
+                .scalar()
+                .as_bool_opt()
+                .ok_or_else(|| vortex_err!("expected boolean scalar"))?;
+            return kleene_boolean_buffer_scalar(
+                lhs_values,
+                lhs.validity()?,
+                &rhs,
+                operator,
+                nullability,
+                ctx,
+            )
+            .map(Some);
+        }
+
+        let Some(rhs) = rhs.as_opt::<ByteBool>() else {
+            return Ok(None);
+        };
+
+        kleene_boolean_buffers(
+            lhs_values,
+            lhs.validity()?,
+            truthy_bit_buffer(rhs),
+            rhs.validity()?,
+            operator,
+            nullability,
+            ctx,
+        )
+        .map(Some)
+    }
+}
+
+fn truthy_bit_buffer(array: ArrayView<'_, ByteBool>) -> BitBuffer {
+    let bytes = array.truthy_bytes();
+    BitBuffer::collect_bool(bytes.len(), |idx| bytes[idx] != 0)
+}
+
 #[cfg(test)]
 mod tests {
     use rstest::rstest;
+    use vortex_array::LEGACY_SESSION;
+    use vortex_array::VortexSessionExecute;
+    use vortex_array::arrays::BoolArray;
     use vortex_array::assert_arrays_eq;
     use vortex_array::builtins::ArrayBuiltins;
     use vortex_array::compute::conformance::cast::test_cast_conformance;
@@ -119,6 +177,7 @@ mod tests {
     use vortex_array::dtype::DType;
     use vortex_array::dtype::Nullability;
     use vortex_array::scalar_fn::fns::operators::Operator;
+    use vortex_error::vortex_err;
 
     use super::*;
     use crate::ByteBoolArray;
@@ -184,6 +243,31 @@ mod tests {
         assert_arrays_eq!(arr, expected.into_array());
     }
 
+    #[test]
+    fn test_boolean_kernel_kleene() -> VortexResult<()> {
+        let lhs = bb_opt(vec![Some(false), Some(true), None, Some(false), None]);
+        let rhs = bb_opt(vec![None, None, Some(true), Some(false), None]).into_array();
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+
+        let and_result =
+            <ByteBool as BooleanKernel>::boolean(lhs.as_view(), &rhs, Operator::And, &mut ctx)?
+                .ok_or_else(|| vortex_err!("ByteBool should handle ByteBool boolean AND"))?;
+        assert_arrays_eq!(
+            and_result,
+            BoolArray::from_iter([Some(false), None, None, Some(false), None])
+        );
+
+        let or_result =
+            <ByteBool as BooleanKernel>::boolean(lhs.as_view(), &rhs, Operator::Or, &mut ctx)?
+                .ok_or_else(|| vortex_err!("ByteBool should handle ByteBool boolean OR"))?;
+        assert_arrays_eq!(
+            or_result,
+            BoolArray::from_iter([None, Some(true), Some(true), Some(false), None])
+        );
+
+        Ok(())
+    }
+
     #[test]
     fn test_mask_byte_bool() {
         test_mask_conformance(&bb(vec![true, false, true, true, false]).into_array());

encodings/bytebool/src/kernel.rs

@@ -3,11 +3,13 @@
 
 use vortex_array::arrays::dict::TakeExecuteAdaptor;
 use vortex_array::kernel::ParentKernelSet;
+use vortex_array::scalar_fn::fns::binary::BooleanExecuteAdaptor;
 use vortex_array::scalar_fn::fns::cast::CastExecuteAdaptor;
 
 use crate::ByteBool;
 
 pub(crate) const PARENT_KERNELS: ParentKernelSet<ByteBool> = ParentKernelSet::new(&[
+    ParentKernelSet::lift(&BooleanExecuteAdaptor(ByteBool)),
     ParentKernelSet::lift(&CastExecuteAdaptor(ByteBool)),
     ParentKernelSet::lift(&TakeExecuteAdaptor(ByteBool)),
 ]);

vortex-array/src/arrays/bool/compute/boolean.rs

@@ -0,0 +1,58 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex_error::VortexResult;
+use vortex_error::vortex_err;
+
+use crate::ArrayRef;
+use crate::ExecutionCtx;
+use crate::array::ArrayView;
+use crate::arrays::Bool;
+use crate::arrays::Constant;
+use crate::arrays::bool::BoolArrayExt;
+use crate::scalar_fn::fns::binary::BooleanKernel;
+use crate::scalar_fn::fns::binary::kleene_boolean_buffer_scalar;
+use crate::scalar_fn::fns::binary::kleene_boolean_buffers;
+use crate::scalar_fn::fns::operators::Operator;
+
+impl BooleanKernel for Bool {
+    fn boolean(
+        lhs: ArrayView<'_, Self>,
+        rhs: &ArrayRef,
+        operator: Operator,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Option<ArrayRef>> {
+        let nullability = lhs.dtype().nullability() | rhs.dtype().nullability();
+
+        if let Some(rhs) = rhs.as_opt::<Constant>() {
+            let rhs = rhs
+                .scalar()
+                .as_bool_opt()
+                .ok_or_else(|| vortex_err!("expected boolean scalar"))?;
+            return kleene_boolean_buffer_scalar(
+                lhs.to_bit_buffer(),
+                lhs.validity()?,
+                &rhs,
+                operator,
+                nullability,
+                ctx,
+            )
+            .map(Some);
+        }
+
+        let Some(rhs) = rhs.as_opt::<Bool>() else {
+            return Ok(None);
+        };
+
+        kleene_boolean_buffers(
+            lhs.to_bit_buffer(),
+            lhs.validity()?,
+            rhs.to_bit_buffer(),
+            rhs.validity()?,
+            operator,
+            nullability,
+            ctx,
+        )
+        .map(Some)
+    }
+}

vortex-array/src/arrays/bool/compute/mod.rs

@@ -1,6 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+mod boolean;
 mod cast;
 mod fill_null;
 pub(crate) mod filter;

vortex-array/src/arrays/bool/vtable/kernel.rs

@@ -4,11 +4,13 @@
 use crate::arrays::Bool;
 use crate::arrays::dict::TakeExecuteAdaptor;
 use crate::kernel::ParentKernelSet;
+use crate::scalar_fn::fns::binary::BooleanExecuteAdaptor;
 use crate::scalar_fn::fns::cast::CastExecuteAdaptor;
 use crate::scalar_fn::fns::fill_null::FillNullExecuteAdaptor;
 use crate::scalar_fn::fns::zip::ZipExecuteAdaptor;
 
 pub(super) const PARENT_KERNELS: ParentKernelSet<Bool> = ParentKernelSet::new(&[
+    ParentKernelSet::lift(&BooleanExecuteAdaptor(Bool)),
     ParentKernelSet::lift(&CastExecuteAdaptor(Bool)),
     ParentKernelSet::lift(&FillNullExecuteAdaptor(Bool)),
     ParentKernelSet::lift(&TakeExecuteAdaptor(Bool)),