add scaffolding for FixedSizeListArray::bind

We can't actually implement this right now without some sort of way to
expand the mask.

Signed-off-by: Connor Tsui <[email protected]>

Author: connortsui20

vortex-array/src/arrays/fixed_size_list/vtable/mod.rs

@@ -8,6 +8,7 @@ use crate::{EncodingId, EncodingRef, vtable};
 mod array;
 mod canonical;
 mod operations;
+mod operator;
 mod serde;
 mod validity;
 mod visitor;

vortex-array/src/arrays/fixed_size_list/vtable/operator.rs

@@ -0,0 +1,79 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use std::sync::Arc;
+
+use vortex_error::{VortexExpect, VortexResult};
+use vortex_vector::Vector;
+use vortex_vector::fixed_size_list::FixedSizeListVector;
+
+use crate::ArrayRef;
+use crate::arrays::{FixedSizeListArray, FixedSizeListVTable};
+use crate::execution::{BatchKernelRef, BindCtx, kernel};
+use crate::vtable::{OperatorVTable, ValidityHelper};
+
+impl OperatorVTable<FixedSizeListVTable> for FixedSizeListVTable {
+    fn bind(
+        array: &FixedSizeListArray,
+        selection: Option<&ArrayRef>,
+        ctx: &mut dyn BindCtx,
+    ) -> VortexResult<BatchKernelRef> {
+        let validity = ctx.bind_validity(array.validity(), array.len(), selection)?;
+
+        let list_size = array.list_size();
+        let elem_dtype = array
+            .dtype()
+            .as_fixed_size_list_element_opt()
+            .vortex_expect("`FixedSizeListArray` `DType` was somehow not `FixedSizeList`")
+            .clone();
+
+        // TODO(connor): Should we raise an error if a child kernel returns a data-full `elements`?
+        // Technically nothing bad will happen if we don't because of this edge case handling below.
+
+        // If the size of each list is 0, then we know that the child elements must empty. Even if
+        // the child kernel incorrectly gives us some data, we can (correctly) just throw it away.
+        if list_size == 0 {
+            return Ok(kernel(move || {
+                let elements = Vector::empty(&elem_dtype);
+                let validity_mask = validity.execute()?;
+
+                Ok(
+                    FixedSizeListVector::try_new(Arc::new(elements), list_size, validity_mask)?
+                        .into(),
+                )
+            }));
+        }
+
+        // Bind the child elements by "expanding" the selection mask out by `list_size` so that we
+        // correctly select all of the child elements we need.
+        let expanded_selection = expand_selection(selection, list_size);
+        let elements_kernel = ctx.bind(array.elements(), expanded_selection.as_ref())?;
+
+        Ok(kernel(move || {
+            if list_size != 0 {
+                let elements = elements_kernel.execute()?;
+                let validity_mask = validity.execute()?;
+
+                Ok(
+                    FixedSizeListVector::try_new(Arc::new(elements), list_size, validity_mask)?
+                        .into(),
+                )
+            } else {
+                todo!()
+            }
+        }))
+    }
+}
+
+/// Takes a selection mask and "expands" it out by duplicating each bit `list_size` times.
+///
+/// If `selection` is not `None`, the output array is guaranteed to have
+/// `selection.len() * list_size` total bits.
+fn expand_selection(_selection: Option<&ArrayRef>, _list_size: u32) -> Option<ArrayRef> {
+    todo!(
+        "TODO(connor)[FixedSizeList]: We need some sort of `ExpandArray` that takes the bits and
+        duplicates them, this would be similar to a:
+        `RunEndArray(selection_mask, ends=Constant(list_size)`
+        (but without depending on the `vortex-runend` encoding crate"
+    )
+}

vortex-vector/src/listview/vector_mut.rs

@@ -178,7 +178,7 @@ impl ListViewVectorMut {
     ///
     /// TODO figure out how to set offsets and sizes type?
     pub fn with_capacity(_element_dtype: &DType, _capacity: usize) -> Self {
-        todo!("ListViewVectorMut::with_capacity")
+        todo!("TODO(connor)[ListView]")
     }
 
     /// Decomposes the [`ListViewVectorMut`] into its constituent parts (child elements, offsets,

vortex-vector/src/vector.rs

@@ -6,6 +6,7 @@
 //!
 //! [`Vector`] can be transformed into the [`VectorMut`] type if it is owned.
 
+use vortex_dtype::DType;
 use vortex_error::vortex_panic;
 
 use crate::binaryview::{BinaryVector, StringVector};
@@ -16,7 +17,7 @@ use crate::listview::ListViewVector;
 use crate::null::NullVector;
 use crate::primitive::PrimitiveVector;
 use crate::struct_::StructVector;
-use crate::{VectorMut, VectorOps, match_each_vector};
+use crate::{VectorMut, VectorMutOps, VectorOps, match_each_vector};
 
 /// An enum over all kinds of immutable vectors, which represent fully decompressed (canonical)
 /// array data.
@@ -78,6 +79,13 @@ impl VectorOps for Vector {
 }
 
 impl Vector {
+    /// Returns an empty `Vector` according to the given `DType`.
+    pub fn empty(dtype: &DType) -> Self {
+        // We _could_ manually implement this for `Vector` instead of doing this via `VectorMut` and
+        // `freeze`, but it's probably not worth it.
+        VectorMut::with_capacity(dtype, 0).freeze()
+    }
+
     /// Returns a reference to the inner [`NullVector`] if `self` is of that variant.
     pub fn as_null(&self) -> &NullVector {
         if let Vector::Null(v) = self {

vortex-vector/src/vector_mut.rs

@@ -70,19 +70,19 @@ impl VectorMut {
             DType::Primitive(ptype, _) => {
                 PrimitiveVectorMut::with_capacity(*ptype, capacity).into()
             }
+            DType::Decimal(decimal_dtype, _) => {
+                DecimalVectorMut::with_capacity(decimal_dtype, capacity).into()
+            }
+            DType::Utf8(..) => StringVectorMut::with_capacity(capacity).into(),
+            DType::Binary(..) => BinaryVectorMut::with_capacity(capacity).into(),
+            DType::List(..) => ListViewVectorMut::with_capacity(dtype, capacity).into(),
             DType::FixedSizeList(elem_dtype, list_size, _) => {
                 FixedSizeListVectorMut::with_capacity(elem_dtype, *list_size, capacity).into()
             }
             DType::Struct(struct_fields, _) => {
                 StructVectorMut::with_capacity(struct_fields, capacity).into()
             }
-            DType::Decimal(decimal_dtype, _) => {
-                DecimalVectorMut::with_capacity(decimal_dtype, capacity).into()
-            }
-            DType::Utf8(..) => StringVectorMut::with_capacity(capacity).into(),
-            DType::Binary(..) => BinaryVectorMut::with_capacity(capacity).into(),
             DType::Extension(ext) => VectorMut::with_capacity(ext.storage_dtype(), capacity),
-            DType::List(..) => ListViewVectorMut::with_capacity(dtype, capacity).into(),
         }
     }
 }