Remove selection mask

Signed-off-by: Nicholas Gates <[email protected]>

Author: gatesn

vortex-array/src/array/operator.rs

@@ -72,7 +72,7 @@ impl ArrayOperator for Arc<dyn Array> {
 
 impl<V: VTable> ArrayOperator for ArrayAdapter<V> {
     fn execute_batch(&self, ctx: &mut dyn ExecutionCtx) -> VortexResult<Vector> {
-        let vector = <V::OperatorVTable as OperatorVTable<V>>::execute_batch(&self.0, ctx)?;
+        let vector = V::execute(&self.0, ctx)?;
 
         if cfg!(debug_assertions) {
             // Checks for correct type and nullability.

vortex-array/src/vtable/mod.rs

@@ -25,8 +25,10 @@ pub use validity::*;
 pub use visitor::*;
 use vortex_buffer::ByteBuffer;
 use vortex_dtype::DType;
-use vortex_error::VortexResult;
+use vortex_error::{VortexResult, vortex_bail};
+use vortex_vector::Vector;
 
+use crate::execution::ExecutionCtx;
 use crate::serde::ArrayChildren;
 use crate::{Array, Encoding, EncodingId, EncodingRef, IntoArray};
 
@@ -127,6 +129,23 @@ pub trait VTable: 'static + Sized + Send + Sync + Debug {
         buffers: &[ByteBuffer],
         children: &dyn ArrayChildren,
     ) -> VortexResult<Self::Array>;
+
+    /// Executes this array tree to return a canonical [`Vector`].
+    ///
+    /// The returned vector must be the appropriate one for the array's logical type (they are
+    /// one-to-one with Vortex `DType`s), and should respect the output nullability of the array.
+    ///
+    /// Debug builds will panic if the returned vector is of the wrong type, wrong length, or
+    /// incorrectly contains null values.
+    ///
+    /// Implementations should recursively call [`crate::ArrayOperator::execute_batch`] on child
+    /// arrays as needed.
+    fn execute(array: &Self::Array, _ctx: &mut dyn ExecutionCtx) -> VortexResult<Vector> {
+        vortex_bail!(
+            "Array {} does not support vector execution",
+            Self::encoding(array).id()
+        )
+    }
 }
 
 /// Placeholder type used to indicate when a particular vtable is not supported by the encoding.

vortex-array/src/vtable/operator.rs

@@ -2,10 +2,9 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use vortex_error::{VortexResult, vortex_bail};
-use vortex_vector::Vector;
 
 use crate::ArrayRef;
-use crate::execution::{BatchKernelRef, BindCtx, ExecutionCtx};
+use crate::execution::{BatchKernelRef, BindCtx};
 use crate::pipeline::PipelinedNode;
 use crate::vtable::{NotSupported, VTable};
 
@@ -15,25 +14,6 @@ use crate::vtable::{NotSupported, VTable};
 ///
 /// See <https://github.com/vortex-data/vortex/pull/4726> for the operators RFC.
 pub trait OperatorVTable<V: VTable> {
-    /// Returns a canonical [`Vector`].
-    ///
-    /// The returned vector must be the appropriate one for the array's logical type (they are
-    /// one-to-one with Vortex `DType`s), and should respect the output nullability of the array.
-    ///
-    /// Debug builds will panic if the returned vector is of the wrong type, wrong length, or
-    /// incorrectly contains null values.
-    ///
-    /// Implementations should recursively call [`crate::ArrayOperator::execute_batch`] on child
-    /// arrays as needed.
-    // NOTE(ngates): in the future, we will add pipeline_execute to process chunks of 1k rows at
-    //  a time.
-    // TODO(ngates): we should fix array vtables such that we can take the array by ownership. This
-    //  allows for more efficient in-place compute, as well as avoids allocating additional memory
-    //  if the array's own memory can be reused by some reasonable allocator.
-    fn execute_batch(array: &V::Array, _ctx: &mut dyn ExecutionCtx) -> VortexResult<Vector> {
-        Self::bind(array, None, &mut ())?.execute()
-    }
-
     /// Downcast this array into a [`PipelinedNode`] if it supports pipelined execution.
     ///
     /// Each node is either a source node or a transformation node.