diff --git a/encodings/bytebool/src/array.rs b/encodings/bytebool/src/array.rs
index e1604b7642e..538c6c079f3 100644
--- a/encodings/bytebool/src/array.rs
+++ b/encodings/bytebool/src/array.rs
@@ -73,7 +73,7 @@ impl VTable for ByteBool {
         len: usize,
         slots: &[Option<ArrayRef>],
     ) -> VortexResult<()> {
-        let validity = child_to_validity(&slots[VALIDITY_SLOT], dtype.nullability());
+        let validity = child_to_validity(slots[VALIDITY_SLOT].as_ref(), dtype.nullability());
         ByteBoolData::validate(data.buffer(), &validity, dtype, len)
     }
 
@@ -186,7 +186,7 @@ impl Display for ByteBoolData {
 pub trait ByteBoolArrayExt: TypedArrayRef<ByteBool> {
     fn validity(&self) -> Validity {
         child_to_validity(
-            &self.as_ref().slots()[VALIDITY_SLOT],
+            self.as_ref().slots()[VALIDITY_SLOT].as_ref(),
             self.as_ref().dtype().nullability(),
         )
     }
diff --git a/encodings/datetime-parts/public-api.lock b/encodings/datetime-parts/public-api.lock
index f9d63d86197..65f4aed6ef9 100644
--- a/encodings/datetime-parts/public-api.lock
+++ b/encodings/datetime-parts/public-api.lock
@@ -152,6 +152,62 @@ pub fn vortex_datetime_parts::DateTimePartsMetadata::clear(&mut self)
 
 pub fn vortex_datetime_parts::DateTimePartsMetadata::encoded_len(&self) -> usize
 
+pub struct vortex_datetime_parts::DateTimePartsParts
+
+pub vortex_datetime_parts::DateTimePartsParts::days: vortex_array::array::erased::ArrayRef
+
+pub vortex_datetime_parts::DateTimePartsParts::seconds: vortex_array::array::erased::ArrayRef
+
+pub vortex_datetime_parts::DateTimePartsParts::subseconds: vortex_array::array::erased::ArrayRef
+
+pub struct vortex_datetime_parts::DateTimePartsSlots
+
+pub vortex_datetime_parts::DateTimePartsSlots::days: vortex_array::array::erased::ArrayRef
+
+pub vortex_datetime_parts::DateTimePartsSlots::seconds: vortex_array::array::erased::ArrayRef
+
+pub vortex_datetime_parts::DateTimePartsSlots::subseconds: vortex_array::array::erased::ArrayRef
+
+impl vortex_datetime_parts::DateTimePartsSlots
+
+pub const vortex_datetime_parts::DateTimePartsSlots::COUNT: usize
+
+pub const vortex_datetime_parts::DateTimePartsSlots::DAYS: usize
+
+pub const vortex_datetime_parts::DateTimePartsSlots::NAMES: [&'static str; 3]
+
+pub const vortex_datetime_parts::DateTimePartsSlots::SECONDS: usize
+
+pub const vortex_datetime_parts::DateTimePartsSlots::SUBSECONDS: usize
+
+pub fn vortex_datetime_parts::DateTimePartsSlots::from_slots(slots: alloc::vec::Vec<core::option::Option<vortex_array::array::erased::ArrayRef>>) -> Self
+
+pub fn vortex_datetime_parts::DateTimePartsSlots::into_slots(self) -> alloc::vec::Vec<core::option::Option<vortex_array::array::erased::ArrayRef>>
+
+pub struct vortex_datetime_parts::DateTimePartsSlotsView<'a>
+
+pub vortex_datetime_parts::DateTimePartsSlotsView::days: &'a vortex_array::array::erased::ArrayRef
+
+pub vortex_datetime_parts::DateTimePartsSlotsView::seconds: &'a vortex_array::array::erased::ArrayRef
+
+pub vortex_datetime_parts::DateTimePartsSlotsView::subseconds: &'a vortex_array::array::erased::ArrayRef
+
+impl<'a> vortex_datetime_parts::DateTimePartsSlotsView<'a>
+
+pub fn vortex_datetime_parts::DateTimePartsSlotsView<'a>::from_slots(slots: &'a [core::option::Option<vortex_array::array::erased::ArrayRef>]) -> Self
+
+pub fn vortex_datetime_parts::DateTimePartsSlotsView<'a>::to_owned(&self) -> vortex_datetime_parts::DateTimePartsSlots
+
+impl<'a> core::clone::Clone for vortex_datetime_parts::DateTimePartsSlotsView<'a>
+
+pub fn vortex_datetime_parts::DateTimePartsSlotsView<'a>::clone(&self) -> vortex_datetime_parts::DateTimePartsSlotsView<'a>
+
+impl<'a> core::fmt::Debug for vortex_datetime_parts::DateTimePartsSlotsView<'a>
+
+pub fn vortex_datetime_parts::DateTimePartsSlotsView<'a>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl<'a> core::marker::Copy for vortex_datetime_parts::DateTimePartsSlotsView<'a>
+
 pub struct vortex_datetime_parts::TemporalParts
 
 pub vortex_datetime_parts::TemporalParts::days: vortex_array::array::erased::ArrayRef
@@ -160,22 +216,34 @@ pub vortex_datetime_parts::TemporalParts::seconds: vortex_array::array::erased::
 
 pub vortex_datetime_parts::TemporalParts::subseconds: vortex_array::array::erased::ArrayRef
 
-pub trait vortex_datetime_parts::DateTimePartsArrayExt: vortex_array::array::typed::TypedArrayRef<vortex_datetime_parts::DateTimeParts>
+pub trait vortex_datetime_parts::DateTimePartsArraySlotsExt: vortex_array::array::typed::TypedArrayRef<vortex_datetime_parts::DateTimeParts>
 
-pub fn vortex_datetime_parts::DateTimePartsArrayExt::days(&self) -> &vortex_array::array::erased::ArrayRef
+pub fn vortex_datetime_parts::DateTimePartsArraySlotsExt::days(&self) -> &vortex_array::array::erased::ArrayRef
 
-pub fn vortex_datetime_parts::DateTimePartsArrayExt::seconds(&self) -> &vortex_array::array::erased::ArrayRef
+pub fn vortex_datetime_parts::DateTimePartsArraySlotsExt::seconds(&self) -> &vortex_array::array::erased::ArrayRef
 
-pub fn vortex_datetime_parts::DateTimePartsArrayExt::subseconds(&self) -> &vortex_array::array::erased::ArrayRef
+pub fn vortex_datetime_parts::DateTimePartsArraySlotsExt::slots_view(&self) -> vortex_datetime_parts::DateTimePartsSlotsView<'_>
 
-impl<T: vortex_array::array::typed::TypedArrayRef<vortex_datetime_parts::DateTimeParts>> vortex_datetime_parts::DateTimePartsArrayExt for T
+pub fn vortex_datetime_parts::DateTimePartsArraySlotsExt::subseconds(&self) -> &vortex_array::array::erased::ArrayRef
+
+impl<T: vortex_array::array::typed::TypedArrayRef<vortex_datetime_parts::DateTimeParts>> vortex_datetime_parts::DateTimePartsArraySlotsExt for T
 
 pub fn T::days(&self) -> &vortex_array::array::erased::ArrayRef
 
 pub fn T::seconds(&self) -> &vortex_array::array::erased::ArrayRef
 
+pub fn T::slots_view(&self) -> vortex_datetime_parts::DateTimePartsSlotsView<'_>
+
 pub fn T::subseconds(&self) -> &vortex_array::array::erased::ArrayRef
 
+pub trait vortex_datetime_parts::DateTimePartsOwnedExt
+
+pub fn vortex_datetime_parts::DateTimePartsOwnedExt::into_parts(self) -> vortex_datetime_parts::DateTimePartsParts
+
+impl vortex_datetime_parts::DateTimePartsOwnedExt for vortex_array::array::typed::Array<vortex_datetime_parts::DateTimeParts>
+
+pub fn vortex_array::array::typed::Array<vortex_datetime_parts::DateTimeParts>::into_parts(self) -> vortex_datetime_parts::DateTimePartsParts
+
 pub fn vortex_datetime_parts::initialize(session: &vortex_session::VortexSession)
 
 pub fn vortex_datetime_parts::split_temporal(array: vortex_array::arrays::datetime::TemporalArray, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_datetime_parts::TemporalParts>
diff --git a/encodings/datetime-parts/src/array.rs b/encodings/datetime-parts/src/array.rs
index 74a58b9418e..86e1927422e 100644
--- a/encodings/datetime-parts/src/array.rs
+++ b/encodings/datetime-parts/src/array.rs
@@ -7,6 +7,7 @@ use std::fmt::Formatter;
 use std::hash::Hasher;
 
 use prost::Message;
+use vortex_array::AnyCanonical;
 use vortex_array::Array;
 use vortex_array::ArrayEq;
 use vortex_array::ArrayHash;
@@ -18,17 +19,18 @@ use vortex_array::ExecutionCtx;
 use vortex_array::ExecutionResult;
 use vortex_array::IntoArray;
 use vortex_array::Precision;
-use vortex_array::TypedArrayRef;
+use vortex_array::array_slots;
+use vortex_array::arrays::Primitive;
 use vortex_array::arrays::TemporalArray;
 use vortex_array::buffer::BufferHandle;
 use vortex_array::dtype::DType;
 use vortex_array::dtype::Nullability;
 use vortex_array::dtype::PType;
+use vortex_array::require_child;
 use vortex_array::serde::ArrayChildren;
 use vortex_array::vtable::VTable;
 use vortex_array::vtable::ValidityChild;
 use vortex_array::vtable::ValidityVTableFromChild;
-use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
 use vortex_error::vortex_ensure;
@@ -104,16 +106,8 @@ impl VTable for DateTimeParts {
         len: usize,
         slots: &[Option<ArrayRef>],
     ) -> VortexResult<()> {
-        let days = slots[DAYS_SLOT]
-            .as_ref()
-            .vortex_expect("DateTimePartsArray days slot");
-        let seconds = slots[SECONDS_SLOT]
-            .as_ref()
-            .vortex_expect("DateTimePartsArray seconds slot");
-        let subseconds = slots[SUBSECONDS_SLOT]
-            .as_ref()
-            .vortex_expect("DateTimePartsArray subseconds slot");
-        DateTimePartsData::validate(dtype, days, seconds, subseconds, len)
+        let slots = DateTimePartsSlotsView::from_slots(slots);
+        DateTimePartsData::validate(dtype, slots.days, slots.seconds, slots.subseconds, len)
     }
 
     fn nbuffers(_array: ArrayView<'_, Self>) -> usize {
@@ -181,12 +175,20 @@ impl VTable for DateTimeParts {
     }
 
     fn slot_name(_array: ArrayView<'_, Self>, idx: usize) -> String {
-        SLOT_NAMES[idx].to_string()
+        DateTimePartsSlots::NAMES[idx].to_string()
     }
 
     fn execute(array: Array<Self>, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
+        let array = require_child!(array, array.days(), DateTimePartsSlots::DAYS => Primitive);
+        let array =
+            require_child!(array, array.seconds(), DateTimePartsSlots::SECONDS => AnyCanonical);
+        let array = require_child!(array, array.subseconds(), DateTimePartsSlots::SUBSECONDS => AnyCanonical);
+
+        let dtype = array.dtype().clone();
+        let parts = array.into_parts();
+
         Ok(ExecutionResult::done(
-            decode_to_temporal(&array, ctx)?.into_array(),
+            decode_to_temporal(parts, &dtype, ctx)?.into_array(),
         ))
     }
 
@@ -208,46 +210,58 @@ impl VTable for DateTimeParts {
     }
 }
 
-/// The days component of the datetime, stored as an integer array.
-pub(super) const DAYS_SLOT: usize = 0;
-/// The seconds component of the datetime (within the day).
-pub(super) const SECONDS_SLOT: usize = 1;
-/// The sub-second component of the datetime.
-pub(super) const SUBSECONDS_SLOT: usize = 2;
-pub(super) const NUM_SLOTS: usize = 3;
-pub(super) const SLOT_NAMES: [&str; NUM_SLOTS] = ["days", "seconds", "subseconds"];
+#[array_slots(DateTimeParts)]
+pub struct DateTimePartsSlots {
+    /// The days component of the datetime, stored as an integer array.
+    pub days: ArrayRef,
+    /// The seconds component of the datetime (within the day).
+    pub seconds: ArrayRef,
+    /// The sub-second component of the datetime.
+    pub subseconds: ArrayRef,
+}
 
 #[derive(Clone, Debug)]
 pub struct DateTimePartsData {}
 
-impl Display for DateTimePartsData {
-    fn fmt(&self, _f: &mut Formatter<'_>) -> std::fmt::Result {
-        Ok(())
-    }
+pub struct DateTimePartsParts {
+    pub days: ArrayRef,
+    pub seconds: ArrayRef,
+    pub subseconds: ArrayRef,
 }
 
-pub trait DateTimePartsArrayExt: TypedArrayRef<DateTimeParts> {
-    fn days(&self) -> &ArrayRef {
-        self.as_ref().slots()[DAYS_SLOT]
-            .as_ref()
-            .vortex_expect("DateTimePartsArray days slot")
-    }
+pub trait DateTimePartsOwnedExt {
+    fn into_parts(self) -> DateTimePartsParts;
+}
 
-    fn seconds(&self) -> &ArrayRef {
-        self.as_ref().slots()[SECONDS_SLOT]
-            .as_ref()
-            .vortex_expect("DateTimePartsArray seconds slot")
+impl DateTimePartsOwnedExt for Array<DateTimeParts> {
+    fn into_parts(self) -> DateTimePartsParts {
+        match self.try_into_parts() {
+            Ok(parts) => {
+                let slots = DateTimePartsSlots::from_slots(parts.slots);
+                DateTimePartsParts {
+                    days: slots.days,
+                    seconds: slots.seconds,
+                    subseconds: slots.subseconds,
+                }
+            }
+            Err(array) => {
+                let view = DateTimePartsSlotsView::from_slots(array.as_ref().slots());
+                DateTimePartsParts {
+                    days: view.days.clone(),
+                    seconds: view.seconds.clone(),
+                    subseconds: view.subseconds.clone(),
+                }
+            }
+        }
     }
+}
 
-    fn subseconds(&self) -> &ArrayRef {
-        self.as_ref().slots()[SUBSECONDS_SLOT]
-            .as_ref()
-            .vortex_expect("DateTimePartsArray subseconds slot")
+impl Display for DateTimePartsData {
+    fn fmt(&self, _f: &mut Formatter<'_>) -> std::fmt::Result {
+        Ok(())
     }
 }
 
-impl<T: TypedArrayRef<DateTimeParts>> DateTimePartsArrayExt for T {}
-
 #[derive(Clone, Debug)]
 pub struct DateTimeParts;
 
diff --git a/encodings/datetime-parts/src/canonical.rs b/encodings/datetime-parts/src/canonical.rs
index de1313339dd..78dc8e689c1 100644
--- a/encodings/datetime-parts/src/canonical.rs
+++ b/encodings/datetime-parts/src/canonical.rs
@@ -4,11 +4,11 @@
 use num_traits::AsPrimitive;
 use vortex_array::ExecutionCtx;
 use vortex_array::IntoArray;
+use vortex_array::arrays::Primitive;
 use vortex_array::arrays::PrimitiveArray;
 use vortex_array::arrays::TemporalArray;
-use vortex_array::builtins::ArrayBuiltins;
+use vortex_array::arrays::primitive::PrimitiveArrayExt;
 use vortex_array::dtype::DType;
-use vortex_array::dtype::PType;
 use vortex_array::extension::datetime::TimeUnit;
 use vortex_array::extension::datetime::Timestamp;
 use vortex_array::match_each_integer_ptype;
@@ -17,17 +17,15 @@ use vortex_error::VortexExpect as _;
 use vortex_error::VortexResult;
 use vortex_error::vortex_panic;
 
-use crate::DateTimePartsArray;
-use crate::array::DateTimePartsArrayExt;
+use crate::array::DateTimePartsParts;
 
-/// Decode an [Array] into a [TemporalArray].
-///
-/// Enforces that the passed array is actually a [DateTimePartsArray] with proper metadata.
+/// Decode [`DateTimePartsParts`] into a [`TemporalArray`].
 pub fn decode_to_temporal(
-    array: &DateTimePartsArray,
+    parts: DateTimePartsParts,
+    dtype: &DType,
     ctx: &mut ExecutionCtx,
 ) -> VortexResult<TemporalArray> {
-    let DType::Extension(ext) = array.dtype().clone() else {
+    let DType::Extension(ext) = dtype else {
         vortex_panic!(Compute: "expected dtype to be DType::Extension variant")
     };
 
@@ -43,21 +41,19 @@ pub fn decode_to_temporal(
         TimeUnit::Days => vortex_panic!(InvalidArgument: "cannot decode into TimeUnit::D"),
     };
 
-    let days_buf = array
-        .days()
-        .cast(DType::Primitive(PType::I64, array.dtype().nullability()))
-        .vortex_expect("must be able to cast days to i64")
-        .execute::<PrimitiveArray>(ctx)?;
-
-    // We start with the days component, which is always present.
-    // And then add the seconds and subseconds components.
-    // We split this into separate passes because often the seconds and/org subseconds components
-    // are constant.
-    let mut values: BufferMut<i64> = days_buf
-        .into_buffer::<i64>()
-        .map_each_in_place(|d| d * 86_400 * divisor);
-
-    if let Some(seconds) = array.seconds().as_constant() {
+    // Days is guaranteed Primitive by require_child.
+    let days = parts.days.as_::<Primitive>();
+    let validity = days.validity()?;
+
+    let mut values: BufferMut<i64> = match_each_integer_ptype!(days.ptype(), |D| {
+        BufferMut::from_iter(days.as_slice::<D>().iter().map(|d| {
+            let d: i64 = d.as_();
+            d * 86_400 * divisor
+        }))
+    });
+
+    // Seconds/subseconds may be Constant — handle the fast path.
+    if let Some(seconds) = parts.seconds.as_constant() {
         let seconds = seconds
             .as_primitive()
             .as_::<i64>()
@@ -67,7 +63,7 @@ pub fn decode_to_temporal(
             *v += seconds;
         }
     } else {
-        let seconds_buf = array.seconds().clone().execute::<PrimitiveArray>(ctx)?;
+        let seconds_buf = parts.seconds.execute::<PrimitiveArray>(ctx)?;
         match_each_integer_ptype!(seconds_buf.ptype(), |S| {
             for (v, second) in values.iter_mut().zip(seconds_buf.as_slice::<S>()) {
                 let second: i64 = second.as_();
@@ -76,7 +72,7 @@ pub fn decode_to_temporal(
         });
     }
 
-    if let Some(subseconds) = array.subseconds().as_constant() {
+    if let Some(subseconds) = parts.subseconds.as_constant() {
         let subseconds = subseconds
             .as_primitive()
             .as_::<i64>()
@@ -85,17 +81,17 @@ pub fn decode_to_temporal(
             *v += subseconds;
         }
     } else {
-        let subseconds_buf = array.subseconds().clone().execute::<PrimitiveArray>(ctx)?;
+        let subseconds_buf = parts.subseconds.execute::<PrimitiveArray>(ctx)?;
         match_each_integer_ptype!(subseconds_buf.ptype(), |S| {
-            for (v, subseconds) in values.iter_mut().zip(subseconds_buf.as_slice::<S>()) {
-                let subseconds: i64 = subseconds.as_();
-                *v += subseconds;
+            for (v, subsecond) in values.iter_mut().zip(subseconds_buf.as_slice::<S>()) {
+                let subsecond: i64 = subsecond.as_();
+                *v += subsecond;
             }
         });
     }
 
     Ok(TemporalArray::new_timestamp(
-        PrimitiveArray::new(values.freeze(), array.validity()?).into_array(),
+        PrimitiveArray::new(values.freeze(), validity).into_array(),
         options.unit,
         options.tz.clone(),
     ))
@@ -116,6 +112,8 @@ mod test {
     use vortex_session::VortexSession;
 
     use crate::DateTimeParts;
+    use crate::array::DateTimePartsArraySlotsExt;
+    use crate::array::DateTimePartsParts;
     use crate::canonical::decode_to_temporal;
 
     #[rstest]
@@ -152,7 +150,14 @@ mod test {
                 .mask_eq(&validity, &mut ctx)?
         );
 
-        let primitive_values = decode_to_temporal(&date_times, &mut ctx)?
+        let dtype = date_times.dtype().clone();
+        let parts = DateTimePartsParts {
+            days: date_times.days().clone(),
+            seconds: date_times.seconds().clone(),
+            subseconds: date_times.subseconds().clone(),
+        };
+
+        let primitive_values = decode_to_temporal(parts, &dtype, &mut ctx)?
             .temporal_values()
             .clone()
             .execute::<PrimitiveArray>(&mut ctx)?;
diff --git a/encodings/datetime-parts/src/compute/cast.rs b/encodings/datetime-parts/src/compute/cast.rs
index 3124d77a2d0..ccc3cc0cd91 100644
--- a/encodings/datetime-parts/src/compute/cast.rs
+++ b/encodings/datetime-parts/src/compute/cast.rs
@@ -10,7 +10,7 @@ use vortex_array::scalar_fn::fns::cast::CastReduce;
 use vortex_error::VortexResult;
 
 use crate::DateTimeParts;
-use crate::array::DateTimePartsArrayExt;
+use crate::array::DateTimePartsArraySlotsExt;
 impl CastReduce for DateTimeParts {
     fn cast(array: ArrayView<'_, Self>, dtype: &DType) -> VortexResult<Option<ArrayRef>> {
         if !array.dtype().eq_ignore_nullability(dtype) {
diff --git a/encodings/datetime-parts/src/compute/compare.rs b/encodings/datetime-parts/src/compute/compare.rs
index bbeda194636..faecc8452b3 100644
--- a/encodings/datetime-parts/src/compute/compare.rs
+++ b/encodings/datetime-parts/src/compute/compare.rs
@@ -17,7 +17,7 @@ use vortex_array::scalar_fn::fns::operators::Operator;
 use vortex_error::VortexResult;
 
 use crate::array::DateTimeParts;
-use crate::array::DateTimePartsArrayExt;
+use crate::array::DateTimePartsArraySlotsExt;
 use crate::timestamp;
 
 impl CompareKernel for DateTimeParts {
diff --git a/encodings/datetime-parts/src/compute/filter.rs b/encodings/datetime-parts/src/compute/filter.rs
index c0042806264..149574f53d4 100644
--- a/encodings/datetime-parts/src/compute/filter.rs
+++ b/encodings/datetime-parts/src/compute/filter.rs
@@ -9,7 +9,7 @@ use vortex_error::VortexResult;
 use vortex_mask::Mask;
 
 use crate::DateTimeParts;
-use crate::array::DateTimePartsArrayExt;
+use crate::array::DateTimePartsArraySlotsExt;
 impl FilterReduce for DateTimeParts {
     fn filter(array: ArrayView<'_, Self>, mask: &Mask) -> VortexResult<Option<ArrayRef>> {
         Ok(Some(
diff --git a/encodings/datetime-parts/src/compute/is_constant.rs b/encodings/datetime-parts/src/compute/is_constant.rs
index d84e294f7aa..cd4ecf2752a 100644
--- a/encodings/datetime-parts/src/compute/is_constant.rs
+++ b/encodings/datetime-parts/src/compute/is_constant.rs
@@ -11,7 +11,7 @@ use vortex_array::scalar::Scalar;
 use vortex_error::VortexResult;
 
 use crate::DateTimeParts;
-use crate::array::DateTimePartsArrayExt;
+use crate::array::DateTimePartsArraySlotsExt;
 
 /// DateTimeParts-specific is_constant kernel.
 ///
diff --git a/encodings/datetime-parts/src/compute/mask.rs b/encodings/datetime-parts/src/compute/mask.rs
index de737105ffe..bd81605c446 100644
--- a/encodings/datetime-parts/src/compute/mask.rs
+++ b/encodings/datetime-parts/src/compute/mask.rs
@@ -9,7 +9,7 @@ use vortex_array::scalar_fn::fns::mask::MaskReduce;
 use vortex_error::VortexResult;
 
 use crate::DateTimeParts;
-use crate::array::DateTimePartsArrayExt;
+use crate::array::DateTimePartsArraySlotsExt;
 
 impl MaskReduce for DateTimeParts {
     fn mask(array: ArrayView<'_, Self>, mask: &ArrayRef) -> VortexResult<Option<ArrayRef>> {
diff --git a/encodings/datetime-parts/src/compute/rules.rs b/encodings/datetime-parts/src/compute/rules.rs
index bc9f0205add..a8b1b2eca83 100644
--- a/encodings/datetime-parts/src/compute/rules.rs
+++ b/encodings/datetime-parts/src/compute/rules.rs
@@ -27,7 +27,7 @@ use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 
 use crate::DateTimeParts;
-use crate::array::DateTimePartsArrayExt;
+use crate::array::DateTimePartsArraySlotsExt;
 use crate::timestamp;
 pub(crate) const PARENT_RULES: ParentRuleSet<DateTimeParts> = ParentRuleSet::new(&[
     ParentRuleSet::lift(&DTPFilterPushDownRule),
diff --git a/encodings/datetime-parts/src/compute/slice.rs b/encodings/datetime-parts/src/compute/slice.rs
index 46819a41562..3cfd2fd6b36 100644
--- a/encodings/datetime-parts/src/compute/slice.rs
+++ b/encodings/datetime-parts/src/compute/slice.rs
@@ -10,7 +10,7 @@ use vortex_array::arrays::slice::SliceReduce;
 use vortex_error::VortexResult;
 
 use crate::DateTimeParts;
-use crate::array::DateTimePartsArrayExt;
+use crate::array::DateTimePartsArraySlotsExt;
 
 impl SliceReduce for DateTimeParts {
     fn slice(array: ArrayView<'_, Self>, range: Range<usize>) -> VortexResult<Option<ArrayRef>> {
diff --git a/encodings/datetime-parts/src/compute/take.rs b/encodings/datetime-parts/src/compute/take.rs
index a9cb88b449c..fcdc00c1979 100644
--- a/encodings/datetime-parts/src/compute/take.rs
+++ b/encodings/datetime-parts/src/compute/take.rs
@@ -16,7 +16,7 @@ use vortex_error::VortexResult;
 use vortex_error::vortex_panic;
 
 use crate::DateTimeParts;
-use crate::array::DateTimePartsArrayExt;
+use crate::array::DateTimePartsArraySlotsExt;
 fn take_datetime_parts(
     array: ArrayView<DateTimeParts>,
     indices: &ArrayRef,
diff --git a/encodings/datetime-parts/src/ops.rs b/encodings/datetime-parts/src/ops.rs
index 75ddcd87fa8..57a1f60173f 100644
--- a/encodings/datetime-parts/src/ops.rs
+++ b/encodings/datetime-parts/src/ops.rs
@@ -12,7 +12,7 @@ use vortex_error::VortexResult;
 use vortex_error::vortex_panic;
 
 use crate::DateTimeParts;
-use crate::array::DateTimePartsArrayExt;
+use crate::array::DateTimePartsArraySlotsExt;
 use crate::timestamp;
 use crate::timestamp::TimestampParts;
 
diff --git a/encodings/fastlanes/src/bitpacking/array/mod.rs b/encodings/fastlanes/src/bitpacking/array/mod.rs
index 9cadc8ccf93..9f23750398a 100644
--- a/encodings/fastlanes/src/bitpacking/array/mod.rs
+++ b/encodings/fastlanes/src/bitpacking/array/mod.rs
@@ -316,10 +316,7 @@ pub trait BitPackedArrayExt: BitPackedArraySlotsExt {
 
     #[inline]
     fn validity(&self) -> Validity {
-        child_to_validity(
-            &self.validity_child().cloned(),
-            self.as_ref().dtype().nullability(),
-        )
+        child_to_validity(self.validity_child(), self.as_ref().dtype().nullability())
     }
 
     #[inline]
diff --git a/encodings/fastlanes/src/bitpacking/vtable/mod.rs b/encodings/fastlanes/src/bitpacking/vtable/mod.rs
index 8c9e4d214c6..9289e0a83fc 100644
--- a/encodings/fastlanes/src/bitpacking/vtable/mod.rs
+++ b/encodings/fastlanes/src/bitpacking/vtable/mod.rs
@@ -105,7 +105,7 @@ impl VTable for BitPacked {
     ) -> VortexResult<()> {
         let slots = BitPackedSlotsView::from_slots(slots);
 
-        let validity = child_to_validity(&slots.validity_child.cloned(), dtype.nullability());
+        let validity = child_to_validity(slots.validity_child, dtype.nullability());
         let patches = match (slots.patch_indices, slots.patch_values) {
             (Some(indices), Some(values)) => {
                 let patch_offset = data
diff --git a/encodings/fsst/src/array.rs b/encodings/fsst/src/array.rs
index bafca478804..dd5214aadc0 100644
--- a/encodings/fsst/src/array.rs
+++ b/encodings/fsst/src/array.rs
@@ -719,7 +719,7 @@ pub trait FSSTArrayExt: TypedArrayRef<FSST> {
             .vortex_expect("FSSTArray codes_offsets slot")
             .clone();
         let validity = child_to_validity(
-            &self.as_ref().slots()[CODES_VALIDITY_SLOT],
+            self.as_ref().slots()[CODES_VALIDITY_SLOT].as_ref(),
             self.as_ref().dtype().nullability(),
         );
         let codes_bytes = self.codes_bytes_handle().clone();
@@ -745,7 +745,7 @@ impl<T: TypedArrayRef<FSST>> FSSTArrayExt for T {}
 impl ValidityVTable<FSST> for FSST {
     fn validity(array: ArrayView<'_, FSST>) -> VortexResult<Validity> {
         Ok(child_to_validity(
-            &array.slots()[CODES_VALIDITY_SLOT],
+            array.slots()[CODES_VALIDITY_SLOT].as_ref(),
             array.dtype().nullability(),
         ))
     }
diff --git a/encodings/parquet-variant/src/array.rs b/encodings/parquet-variant/src/array.rs
index 1f549e6e5bf..15c58b894c0 100644
--- a/encodings/parquet-variant/src/array.rs
+++ b/encodings/parquet-variant/src/array.rs
@@ -221,7 +221,7 @@ pub trait ParquetVariantArrayExt: TypedArrayRef<ParquetVariant> {
 
     fn validity(&self) -> Validity {
         child_to_validity(
-            &self.as_ref().slots()[VALIDITY_SLOT],
+            self.as_ref().slots()[VALIDITY_SLOT].as_ref(),
             self.as_ref().dtype().nullability(),
         )
     }
diff --git a/encodings/parquet-variant/src/vtable.rs b/encodings/parquet-variant/src/vtable.rs
index 75ea8036c9a..7c8dc942bb4 100644
--- a/encodings/parquet-variant/src/vtable.rs
+++ b/encodings/parquet-variant/src/vtable.rs
@@ -80,7 +80,7 @@ impl VTable for ParquetVariant {
         slots: &[Option<ArrayRef>],
     ) -> VortexResult<()> {
         let _ = data;
-        let validity = child_to_validity(&slots[VALIDITY_SLOT], dtype.nullability());
+        let validity = child_to_validity(slots[VALIDITY_SLOT].as_ref(), dtype.nullability());
         let metadata = slots[METADATA_SLOT]
             .as_ref()
             .ok_or_else(|| vortex_err!("ParquetVariantArray metadata slot"))?;
diff --git a/encodings/pco/src/array.rs b/encodings/pco/src/array.rs
index c119cc4ecce..21d748927d4 100644
--- a/encodings/pco/src/array.rs
+++ b/encodings/pco/src/array.rs
@@ -138,7 +138,7 @@ impl VTable for Pco {
         len: usize,
         slots: &[Option<ArrayRef>],
     ) -> VortexResult<()> {
-        let validity = child_to_validity(&slots[0], dtype.nullability());
+        let validity = child_to_validity(slots[0].as_ref(), dtype.nullability());
         data.validate(dtype, len, &validity)
     }
 
@@ -216,8 +216,10 @@ impl VTable for Pco {
     }
 
     fn execute(array: Array<Self>, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
-        let unsliced_validity =
-            child_to_validity(&array.as_ref().slots()[0], array.dtype().nullability());
+        let unsliced_validity = child_to_validity(
+            array.as_ref().slots()[0].as_ref(),
+            array.dtype().nullability(),
+        );
         Ok(ExecutionResult::done(
             array
                 .data()
@@ -641,7 +643,8 @@ impl PcoData {
 
 impl ValidityVTable<Pco> for Pco {
     fn validity(array: ArrayView<'_, Pco>) -> VortexResult<Validity> {
-        let unsliced_validity = child_to_validity(&array.slots()[0], array.dtype().nullability());
+        let unsliced_validity =
+            child_to_validity(array.slots()[0].as_ref(), array.dtype().nullability());
         unsliced_validity.slice(array.slice_start()..array.slice_stop())
     }
 }
@@ -652,7 +655,8 @@ impl OperationsVTable<Pco> for Pco {
         index: usize,
         ctx: &mut ExecutionCtx,
     ) -> VortexResult<Scalar> {
-        let unsliced_validity = child_to_validity(&array.slots()[0], array.dtype().nullability());
+        let unsliced_validity =
+            child_to_validity(array.slots()[0].as_ref(), array.dtype().nullability());
         array
             ._slice(index, index + 1)
             .decompress(&unsliced_validity, ctx)?
diff --git a/encodings/pco/src/compute/cast.rs b/encodings/pco/src/compute/cast.rs
index 831a454c3b6..ad95badd7f3 100644
--- a/encodings/pco/src/compute/cast.rs
+++ b/encodings/pco/src/compute/cast.rs
@@ -32,7 +32,7 @@ impl CastReduce for Pco {
         if array.dtype().eq_ignore_nullability(dtype) {
             // Create a new validity with the target nullability
             let unsliced_validity =
-                child_to_validity(&array.slots()[0], array.dtype().nullability());
+                child_to_validity(array.slots()[0].as_ref(), array.dtype().nullability());
             let new_validity =
                 unsliced_validity.cast_nullability(dtype.nullability(), array.len())?;
 
diff --git a/encodings/pco/src/slice.rs b/encodings/pco/src/slice.rs
index 2f341f989b7..30dd1ee3e93 100644
--- a/encodings/pco/src/slice.rs
+++ b/encodings/pco/src/slice.rs
@@ -14,7 +14,8 @@ use crate::Pco;
 
 impl SliceReduce for Pco {
     fn slice(array: ArrayView<'_, Self>, range: Range<usize>) -> VortexResult<Option<ArrayRef>> {
-        let unsliced_validity = child_to_validity(&array.slots()[0], array.dtype().nullability());
+        let unsliced_validity =
+            child_to_validity(array.slots()[0].as_ref(), array.dtype().nullability());
         Ok(Some(
             Pco::try_new(
                 array.dtype().clone(),
diff --git a/encodings/pco/src/tests.rs b/encodings/pco/src/tests.rs
index b848d04afa0..6fbed76df68 100644
--- a/encodings/pco/src/tests.rs
+++ b/encodings/pco/src/tests.rs
@@ -50,7 +50,7 @@ fn test_compress_decompress() {
 
     // check full decompression works
     let unsliced_validity = child_to_validity(
-        &compressed.as_ref().slots()[0],
+        compressed.as_ref().slots()[0].as_ref(),
         compressed.dtype().nullability(),
     );
     let decompressed = compressed.decompress(&unsliced_validity, &mut ctx).unwrap();
@@ -77,7 +77,7 @@ fn test_compress_decompress_small() {
     assert_arrays_eq!(compressed, expected);
 
     let unsliced_validity = child_to_validity(
-        &compressed.as_ref().slots()[0],
+        compressed.as_ref().slots()[0].as_ref(),
         compressed.dtype().nullability(),
     );
     let decompressed = compressed.decompress(&unsliced_validity, &mut ctx).unwrap();
@@ -91,7 +91,7 @@ fn test_empty() {
     let array = PrimitiveArray::from_iter(data.clone());
     let compressed = Pco::from_primitive(array.as_view(), 3, 100, &mut ctx).unwrap();
     let unsliced_validity = child_to_validity(
-        &compressed.as_ref().slots()[0],
+        compressed.as_ref().slots()[0].as_ref(),
         compressed.dtype().nullability(),
     );
     let primitive = compressed.decompress(&unsliced_validity, &mut ctx).unwrap();
diff --git a/encodings/zstd/src/array.rs b/encodings/zstd/src/array.rs
index 4927a3aa7eb..2a685f1ea2a 100644
--- a/encodings/zstd/src/array.rs
+++ b/encodings/zstd/src/array.rs
@@ -143,7 +143,7 @@ impl VTable for Zstd {
         len: usize,
         slots: &[Option<ArrayRef>],
     ) -> VortexResult<()> {
-        let validity = child_to_validity(&slots[0], dtype.nullability());
+        let validity = child_to_validity(slots[0].as_ref(), dtype.nullability());
         data.validate(dtype, len, &validity)
     }
 
@@ -230,8 +230,10 @@ impl VTable for Zstd {
     }
 
     fn execute(array: Array<Self>, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
-        let unsliced_validity =
-            child_to_validity(&array.as_ref().slots()[0], array.dtype().nullability());
+        let unsliced_validity = child_to_validity(
+            array.as_ref().slots()[0].as_ref(),
+            array.dtype().nullability(),
+        );
         array
             .data()
             .decompress(array.dtype(), &unsliced_validity, ctx)?
@@ -307,8 +309,10 @@ impl Zstd {
     }
 
     pub fn decompress(array: &ZstdArray, ctx: &mut ExecutionCtx) -> VortexResult<ArrayRef> {
-        let unsliced_validity =
-            child_to_validity(&array.as_ref().slots()[0], array.dtype().nullability());
+        let unsliced_validity = child_to_validity(
+            array.as_ref().slots()[0].as_ref(),
+            array.dtype().nullability(),
+        );
         array
             .data()
             .decompress(array.dtype(), &unsliced_validity, ctx)
@@ -1042,7 +1046,8 @@ impl ZstdData {
 
 impl ValidityVTable<Zstd> for Zstd {
     fn validity(array: ArrayView<'_, Zstd>) -> VortexResult<Validity> {
-        let unsliced_validity = child_to_validity(&array.slots()[0], array.dtype().nullability());
+        let unsliced_validity =
+            child_to_validity(array.slots()[0].as_ref(), array.dtype().nullability());
         unsliced_validity.slice(array.slice_start()..array.slice_stop())
     }
 }
@@ -1053,7 +1058,8 @@ impl OperationsVTable<Zstd> for Zstd {
         index: usize,
         ctx: &mut ExecutionCtx,
     ) -> VortexResult<Scalar> {
-        let unsliced_validity = child_to_validity(&array.slots()[0], array.dtype().nullability());
+        let unsliced_validity =
+            child_to_validity(array.slots()[0].as_ref(), array.dtype().nullability());
         let sliced = array.data().with_slice(index, index + 1);
         sliced
             .decompress(array.dtype(), &unsliced_validity, ctx)?
diff --git a/encodings/zstd/src/compute/cast.rs b/encodings/zstd/src/compute/cast.rs
index 05eb1d16c03..ae3032cdc03 100644
--- a/encodings/zstd/src/compute/cast.rs
+++ b/encodings/zstd/src/compute/cast.rs
@@ -34,7 +34,7 @@ impl CastReduce for Zstd {
             (Nullability::NonNullable, Nullability::Nullable) => {
                 // nonnull => null, trivial cast by altering the validity
                 let unsliced_validity =
-                    child_to_validity(&array.slots()[0], array.dtype().nullability());
+                    child_to_validity(array.slots()[0].as_ref(), array.dtype().nullability());
                 Ok(Some(
                     Zstd::try_new(
                         dtype.clone(),
@@ -53,7 +53,7 @@ impl CastReduce for Zstd {
             (Nullability::Nullable, Nullability::NonNullable) => {
                 // null => non-null works if there are no nulls in the sliced range
                 let unsliced_validity =
-                    child_to_validity(&array.slots()[0], array.dtype().nullability());
+                    child_to_validity(array.slots()[0].as_ref(), array.dtype().nullability());
                 let has_nulls = !matches!(
                     unsliced_validity.slice(array.slice_start()..array.slice_stop())?,
                     Validity::AllValid | Validity::NonNullable
diff --git a/encodings/zstd/src/slice.rs b/encodings/zstd/src/slice.rs
index 6b6906a1628..54f4441635d 100644
--- a/encodings/zstd/src/slice.rs
+++ b/encodings/zstd/src/slice.rs
@@ -14,7 +14,8 @@ use crate::Zstd;
 
 impl SliceReduce for Zstd {
     fn slice(array: ArrayView<'_, Self>, range: Range<usize>) -> VortexResult<Option<ArrayRef>> {
-        let unsliced_validity = child_to_validity(&array.slots()[0], array.dtype().nullability());
+        let unsliced_validity =
+            child_to_validity(array.slots()[0].as_ref(), array.dtype().nullability());
         Ok(Some(
             Zstd::try_new(
                 array.dtype().clone(),
diff --git a/vortex-array/public-api.lock b/vortex-array/public-api.lock
index 0675fa157ad..2f08865b1c3 100644
--- a/vortex-array/public-api.lock
+++ b/vortex-array/public-api.lock
@@ -21630,7 +21630,7 @@ impl<V> vortex_array::ValidityVTable<V> for vortex_array::ValidityVTableFromChil
 
 pub fn vortex_array::ValidityVTableFromChild::validity(array: vortex_array::ArrayView<'_, V>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-pub fn vortex_array::vtable::child_to_validity(child: &core::option::Option<vortex_array::ArrayRef>, nullability: vortex_array::dtype::Nullability) -> vortex_array::validity::Validity
+pub fn vortex_array::vtable::child_to_validity(child: core::option::Option<&vortex_array::ArrayRef>, nullability: vortex_array::dtype::Nullability) -> vortex_array::validity::Validity
 
 pub fn vortex_array::vtable::patches_child(patches: &vortex_array::patches::Patches, idx: usize) -> vortex_array::ArrayRef
 
@@ -25552,7 +25552,7 @@ impl vortex_array::VortexSessionExecute for vortex_session::VortexSession
 
 pub fn vortex_session::VortexSession::create_execution_ctx(&self) -> vortex_array::ExecutionCtx
 
-pub fn vortex_array::child_to_validity(child: &core::option::Option<vortex_array::ArrayRef>, nullability: vortex_array::dtype::Nullability) -> vortex_array::validity::Validity
+pub fn vortex_array::child_to_validity(child: core::option::Option<&vortex_array::ArrayRef>, nullability: vortex_array::dtype::Nullability) -> vortex_array::validity::Validity
 
 pub fn vortex_array::patches_child(patches: &vortex_array::patches::Patches, idx: usize) -> vortex_array::ArrayRef
 
diff --git a/vortex-array/src/array/vtable/mod.rs b/vortex-array/src/array/vtable/mod.rs
index 2b65853bb88..7006c55b076 100644
--- a/vortex-array/src/array/vtable/mod.rs
+++ b/vortex-array/src/array/vtable/mod.rs
@@ -254,7 +254,7 @@ pub fn validity_to_child(validity: &Validity, len: usize) -> Option<ArrayRef> {
 ///
 /// This is the inverse of [`validity_to_child`].
 #[inline]
-pub fn child_to_validity(child: &Option<ArrayRef>, nullability: Nullability) -> Validity {
+pub fn child_to_validity(child: Option<&ArrayRef>, nullability: Nullability) -> Validity {
     match child {
         Some(arr) => {
             // Detect constant bool arrays created by validity_to_child.
diff --git a/vortex-array/src/arrays/bool/array.rs b/vortex-array/src/arrays/bool/array.rs
index 6500badc7dc..0cfc55869b1 100644
--- a/vortex-array/src/arrays/bool/array.rs
+++ b/vortex-array/src/arrays/bool/array.rs
@@ -91,7 +91,10 @@ pub trait BoolArrayExt: TypedArrayRef<Bool> {
     }
 
     fn validity(&self) -> Validity {
-        child_to_validity(&self.as_ref().slots()[VALIDITY_SLOT], self.nullability())
+        child_to_validity(
+            self.as_ref().slots()[VALIDITY_SLOT].as_ref(),
+            self.nullability(),
+        )
     }
 
     fn to_bit_buffer(&self) -> BitBuffer {
diff --git a/vortex-array/src/arrays/bool/vtable/mod.rs b/vortex-array/src/arrays/bool/vtable/mod.rs
index 44ba2204a85..270699ec9b0 100644
--- a/vortex-array/src/arrays/bool/vtable/mod.rs
+++ b/vortex-array/src/arrays/bool/vtable/mod.rs
@@ -17,8 +17,10 @@ use crate::ArrayRef;
 use crate::ExecutionCtx;
 use crate::ExecutionResult;
 use crate::array::Array;
+use crate::array::ArrayParts;
 use crate::array::ArrayView;
 use crate::array::VTable;
+use crate::array::child_to_validity;
 use crate::arrays::bool::BoolData;
 use crate::arrays::bool::array::SLOT_NAMES;
 use crate::buffer::BufferHandle;
@@ -121,7 +123,7 @@ impl VTable for Bool {
             data.bits.len() * 8
         );
 
-        let validity = crate::array::child_to_validity(&slots[0], *nullability);
+        let validity = child_to_validity(slots[0].as_ref(), *nullability);
         if let Some(validity_len) = validity.maybe_len() {
             vortex_ensure!(
                 validity_len == len,
@@ -139,11 +141,10 @@ impl VTable for Bool {
         dtype: &DType,
         len: usize,
         metadata: &[u8],
-
         buffers: &[BufferHandle],
         children: &dyn ArrayChildren,
         _session: &VortexSession,
-    ) -> VortexResult<crate::array::ArrayParts<Self>> {
+    ) -> VortexResult<ArrayParts<Self>> {
         let metadata = BoolMetadata::decode(metadata)?;
         if buffers.len() != 1 {
             vortex_bail!("Expected 1 buffer, got {}", buffers.len());
@@ -161,7 +162,7 @@ impl VTable for Bool {
         let buffer = buffers[0].clone();
         let slots = BoolData::make_slots(&validity, len);
         let data = BoolData::try_new_from_handle(buffer, metadata.offset as usize, len, validity)?;
-        Ok(crate::array::ArrayParts::new(self.clone(), dtype.clone(), len, data).with_slots(slots))
+        Ok(ArrayParts::new(self.clone(), dtype.clone(), len, data).with_slots(slots))
     }
 
     fn slot_name(_array: ArrayView<'_, Self>, idx: usize) -> String {
diff --git a/vortex-array/src/arrays/decimal/array.rs b/vortex-array/src/arrays/decimal/array.rs
index ae6ccad60b3..eb461337752 100644
--- a/vortex-array/src/arrays/decimal/array.rs
+++ b/vortex-array/src/arrays/decimal/array.rs
@@ -145,7 +145,10 @@ pub trait DecimalArrayExt: TypedArrayRef<Decimal> {
     }
 
     fn validity(&self) -> Validity {
-        child_to_validity(&self.as_ref().slots()[VALIDITY_SLOT], self.nullability())
+        child_to_validity(
+            self.as_ref().slots()[VALIDITY_SLOT].as_ref(),
+            self.nullability(),
+        )
     }
 
     fn values_type(&self) -> DecimalType {
diff --git a/vortex-array/src/arrays/decimal/vtable/mod.rs b/vortex-array/src/arrays/decimal/vtable/mod.rs
index 4fce4915013..5360aba5eb0 100644
--- a/vortex-array/src/arrays/decimal/vtable/mod.rs
+++ b/vortex-array/src/arrays/decimal/vtable/mod.rs
@@ -121,7 +121,7 @@ impl VTable for Decimal {
             data.len(),
             len
         );
-        let validity = crate::array::child_to_validity(&slots[0], *nullability);
+        let validity = crate::array::child_to_validity(slots[0].as_ref(), *nullability);
         if let Some(validity_len) = validity.maybe_len() {
             vortex_ensure!(
                 validity_len == len,
diff --git a/vortex-array/src/arrays/fixed_size_list/array.rs b/vortex-array/src/arrays/fixed_size_list/array.rs
index 22dd34b46bb..e885ecce0f4 100644
--- a/vortex-array/src/arrays/fixed_size_list/array.rs
+++ b/vortex-array/src/arrays/fixed_size_list/array.rs
@@ -228,7 +228,7 @@ pub trait FixedSizeListArrayExt: TypedArrayRef<FixedSizeList> {
 
     fn fixed_size_list_validity(&self) -> Validity {
         let (_, _, nullability) = self.dtype_parts();
-        child_to_validity(&self.as_ref().slots()[VALIDITY_SLOT], nullability)
+        child_to_validity(self.as_ref().slots()[VALIDITY_SLOT].as_ref(), nullability)
     }
 
     fn fixed_size_list_elements_at(&self, index: usize) -> VortexResult<ArrayRef> {
diff --git a/vortex-array/src/arrays/list/array.rs b/vortex-array/src/arrays/list/array.rs
index 033845088b5..140b112ff39 100644
--- a/vortex-array/src/arrays/list/array.rs
+++ b/vortex-array/src/arrays/list/array.rs
@@ -285,7 +285,10 @@ pub trait ListArrayExt: TypedArrayRef<List> {
     }
 
     fn list_validity(&self) -> Validity {
-        child_to_validity(&self.as_ref().slots()[VALIDITY_SLOT], self.nullability())
+        child_to_validity(
+            self.as_ref().slots()[VALIDITY_SLOT].as_ref(),
+            self.nullability(),
+        )
     }
 
     fn offset_at(&self, index: usize) -> VortexResult<usize> {
diff --git a/vortex-array/src/arrays/list/vtable/mod.rs b/vortex-array/src/arrays/list/vtable/mod.rs
index 8563c4ed27a..38d1959219d 100644
--- a/vortex-array/src/arrays/list/vtable/mod.rs
+++ b/vortex-array/src/arrays/list/vtable/mod.rs
@@ -22,6 +22,7 @@ use crate::IntoArray;
 use crate::Precision;
 use crate::array::Array;
 use crate::array::ArrayId;
+use crate::array::ArrayParts;
 use crate::array::ArrayView;
 use crate::array::VTable;
 use crate::arrays::list::ListArrayExt;
@@ -148,7 +149,7 @@ impl VTable for List {
         _buffers: &[BufferHandle],
         children: &dyn ArrayChildren,
         _session: &VortexSession,
-    ) -> VortexResult<crate::array::ArrayParts<Self>> {
+    ) -> VortexResult<ArrayParts<Self>> {
         let metadata = ListMetadata::decode(metadata)?;
         let validity = if children.len() == 2 {
             Validity::from(dtype.nullability())
@@ -176,7 +177,7 @@ impl VTable for List {
 
         let data = ListData::try_build(elements.clone(), offsets.clone(), validity.clone())?;
         let slots = ListData::make_slots(&elements, &offsets, &validity, len);
-        Ok(crate::array::ArrayParts::new(self.clone(), dtype.clone(), len, data).with_slots(slots))
+        Ok(ArrayParts::new(self.clone(), dtype.clone(), len, data).with_slots(slots))
     }
 
     fn slot_name(_array: ArrayView<'_, Self>, idx: usize) -> String {
diff --git a/vortex-array/src/arrays/listview/array.rs b/vortex-array/src/arrays/listview/array.rs
index cae55bf0828..e22809cf4c7 100644
--- a/vortex-array/src/arrays/listview/array.rs
+++ b/vortex-array/src/arrays/listview/array.rs
@@ -336,7 +336,10 @@ pub trait ListViewArrayExt: TypedArrayRef<ListView> {
     }
 
     fn listview_validity(&self) -> Validity {
-        child_to_validity(&self.as_ref().slots()[VALIDITY_SLOT], self.nullability())
+        child_to_validity(
+            self.as_ref().slots()[VALIDITY_SLOT].as_ref(),
+            self.nullability(),
+        )
     }
 
     fn offset_at(&self, index: usize) -> usize {
diff --git a/vortex-array/src/arrays/masked/array.rs b/vortex-array/src/arrays/masked/array.rs
index 5253156d1fb..ce828020111 100644
--- a/vortex-array/src/arrays/masked/array.rs
+++ b/vortex-array/src/arrays/masked/array.rs
@@ -38,8 +38,10 @@ impl Display for MaskedData {
 
 pub trait MaskedArrayExt: TypedArrayRef<Masked> + MaskedArraySlotsExt {
     fn masked_validity(&self) -> Validity {
-        let x = &self.as_ref().slots()[MaskedSlots::VALIDITY];
-        child_to_validity(x, self.as_ref().dtype().nullability())
+        child_to_validity(
+            self.as_ref().slots()[MaskedSlots::VALIDITY].as_ref(),
+            self.as_ref().dtype().nullability(),
+        )
     }
 }
 impl<T: TypedArrayRef<Masked>> MaskedArrayExt for T {}
diff --git a/vortex-array/src/arrays/patched/compute/compare.rs b/vortex-array/src/arrays/patched/compute/compare.rs
index 17f5333e52d..c7d879323cb 100644
--- a/vortex-array/src/arrays/patched/compute/compare.rs
+++ b/vortex-array/src/arrays/patched/compute/compare.rs
@@ -53,7 +53,7 @@ impl CompareKernel for Patched {
             .execute::<Canonical>(ctx)?
             .into_bool();
 
-        let validity = child_to_validity(&result.slots()[0], result.dtype().nullability());
+        let validity = child_to_validity(result.slots()[0].as_ref(), result.dtype().nullability());
         let len = result.len();
         let BoolDataParts { bits, offset, len } = result.into_data().into_parts(len);
 
diff --git a/vortex-array/src/arrays/primitive/array/mod.rs b/vortex-array/src/arrays/primitive/array/mod.rs
index 21b474984a4..254c4b0baee 100644
--- a/vortex-array/src/arrays/primitive/array/mod.rs
+++ b/vortex-array/src/arrays/primitive/array/mod.rs
@@ -123,7 +123,10 @@ pub trait PrimitiveArrayExt: TypedArrayRef<Primitive> {
     }
 
     fn validity(&self) -> Validity {
-        child_to_validity(&self.as_ref().slots()[VALIDITY_SLOT], self.nullability())
+        child_to_validity(
+            self.as_ref().slots()[VALIDITY_SLOT].as_ref(),
+            self.nullability(),
+        )
     }
 
     fn buffer_handle(&self) -> &BufferHandle {
diff --git a/vortex-array/src/arrays/primitive/vtable/mod.rs b/vortex-array/src/arrays/primitive/vtable/mod.rs
index c1cdfc20d28..cb28f96631e 100644
--- a/vortex-array/src/arrays/primitive/vtable/mod.rs
+++ b/vortex-array/src/arrays/primitive/vtable/mod.rs
@@ -103,7 +103,7 @@ impl VTable for Primitive {
             data.len(),
             len
         );
-        let validity = crate::array::child_to_validity(&slots[0], *nullability);
+        let validity = crate::array::child_to_validity(slots[0].as_ref(), *nullability);
         if let Some(validity_len) = validity.maybe_len() {
             vortex_ensure!(
                 validity_len == len,
diff --git a/vortex-array/src/arrays/struct_/array.rs b/vortex-array/src/arrays/struct_/array.rs
index 8e3192728e0..0a3cb30d8b5 100644
--- a/vortex-array/src/arrays/struct_/array.rs
+++ b/vortex-array/src/arrays/struct_/array.rs
@@ -180,7 +180,10 @@ pub trait StructArrayExt: TypedArrayRef<Struct> {
     }
 
     fn struct_validity(&self) -> Validity {
-        child_to_validity(&self.as_ref().slots()[VALIDITY_SLOT], self.nullability())
+        child_to_validity(
+            self.as_ref().slots()[VALIDITY_SLOT].as_ref(),
+            self.nullability(),
+        )
     }
 
     fn iter_unmasked_fields(&self) -> impl Iterator<Item = &ArrayRef> + '_ {
diff --git a/vortex-array/src/arrays/struct_/vtable/mod.rs b/vortex-array/src/arrays/struct_/vtable/mod.rs
index 5da40b56f24..6a7a2cd8dd8 100644
--- a/vortex-array/src/arrays/struct_/vtable/mod.rs
+++ b/vortex-array/src/arrays/struct_/vtable/mod.rs
@@ -70,7 +70,7 @@ impl VTable for Struct {
             );
         }
 
-        let validity = child_to_validity(&slots[VALIDITY_SLOT], *nullability);
+        let validity = child_to_validity(slots[VALIDITY_SLOT].as_ref(), *nullability);
         if let Some(validity_len) = validity.maybe_len()
             && validity_len != len
         {
diff --git a/vortex-array/src/arrays/varbin/array.rs b/vortex-array/src/arrays/varbin/array.rs
index 8d22f2ea451..805eb68aaa2 100644
--- a/vortex-array/src/arrays/varbin/array.rs
+++ b/vortex-array/src/arrays/varbin/array.rs
@@ -320,7 +320,10 @@ pub trait VarBinArrayExt: TypedArrayRef<VarBin> {
     }
 
     fn varbin_validity(&self) -> Validity {
-        child_to_validity(&self.as_ref().slots()[VALIDITY_SLOT], self.nullability())
+        child_to_validity(
+            self.as_ref().slots()[VALIDITY_SLOT].as_ref(),
+            self.nullability(),
+        )
     }
 
     fn offset_at(&self, index: usize) -> usize {
diff --git a/vortex-array/src/arrays/varbinview/array.rs b/vortex-array/src/arrays/varbinview/array.rs
index 7db90077628..06256bfa77c 100644
--- a/vortex-array/src/arrays/varbinview/array.rs
+++ b/vortex-array/src/arrays/varbinview/array.rs
@@ -541,7 +541,10 @@ pub trait VarBinViewArrayExt: TypedArrayRef<VarBinView> {
     }
 
     fn varbinview_validity(&self) -> Validity {
-        child_to_validity(&self.as_ref().slots()[VALIDITY_SLOT], self.dtype_parts().1)
+        child_to_validity(
+            self.as_ref().slots()[VALIDITY_SLOT].as_ref(),
+            self.dtype_parts().1,
+        )
     }
 }
 impl<T: TypedArrayRef<VarBinView>> VarBinViewArrayExt for T {}
diff --git a/vortex-array/src/canonical.rs b/vortex-array/src/canonical.rs
index 3190c462691..150172b0df8 100644
--- a/vortex-array/src/canonical.rs
+++ b/vortex-array/src/canonical.rs
@@ -559,7 +559,7 @@ impl Executable for CanonicalValidity {
         match array.execute::<Canonical>(ctx)? {
             n @ Canonical::Null(_) => Ok(CanonicalValidity(n)),
             Canonical::Bool(b) => {
-                let validity = child_to_validity(&b.slots()[0], b.dtype().nullability());
+                let validity = child_to_validity(b.slots()[0].as_ref(), b.dtype().nullability());
                 let len = b.len();
                 let BoolDataParts { bits, offset, len } = b.into_data().into_parts(len);
                 Ok(CanonicalValidity(Canonical::Bool(
@@ -678,7 +678,7 @@ impl Executable for RecursiveCanonical {
         match array.execute::<Canonical>(ctx)? {
             n @ Canonical::Null(_) => Ok(RecursiveCanonical(n)),
             Canonical::Bool(b) => {
-                let validity = child_to_validity(&b.slots()[0], b.dtype().nullability());
+                let validity = child_to_validity(b.slots()[0].as_ref(), b.dtype().nullability());
                 let len = b.len();
                 let BoolDataParts { bits, offset, len } = b.into_data().into_parts(len);
                 Ok(RecursiveCanonical(Canonical::Bool(
diff --git a/vortex-array/src/scalar_fn/fns/mask/mod.rs b/vortex-array/src/scalar_fn/fns/mask/mod.rs
index 7e45d2e40ee..b4841576cf6 100644
--- a/vortex-array/src/scalar_fn/fns/mask/mod.rs
+++ b/vortex-array/src/scalar_fn/fns/mask/mod.rs
@@ -181,7 +181,7 @@ fn execute_canonical(
     mask_array: ArrayRef,
     ctx: &mut ExecutionCtx,
 ) -> VortexResult<ArrayRef> {
-    let validity = child_to_validity(&Some(mask_array), Nullability::Nullable);
+    let validity = child_to_validity(Some(&mask_array), Nullability::Nullable);
     let canonical = input.execute::<Canonical>(ctx)?;
     Ok(mask_validity_canonical(canonical, validity, ctx)?.into_array())
 }
diff --git a/vortex-array/src/serde.rs b/vortex-array/src/serde.rs
index c560aa9fb7e..26eb20faa66 100644
--- a/vortex-array/src/serde.rs
+++ b/vortex-array/src/serde.rs
@@ -29,6 +29,7 @@ use vortex_utils::aliases::hash_map::HashMap;
 
 use crate::ArrayContext;
 use crate::ArrayRef;
+use crate::array::ArrayId;
 use crate::array::new_foreign_array;
 use crate::buffer::BufferHandle;
 use crate::dtype::DType;
@@ -377,7 +378,7 @@ impl SerializedArray {
 
     fn decode_foreign(
         &self,
-        encoding_id: crate::array::ArrayId,
+        encoding_id: ArrayId,
         dtype: &DType,
         len: usize,
         ctx: &ReadContext,
diff --git a/vortex-cuda/benches/zstd_cuda.rs b/vortex-cuda/benches/zstd_cuda.rs
index 68e411a2253..a1b9400e6c0 100644
--- a/vortex-cuda/benches/zstd_cuda.rs
+++ b/vortex-cuda/benches/zstd_cuda.rs
@@ -149,7 +149,7 @@ fn benchmark_zstd_cuda_decompress(c: &mut Criterion) {
                             frames, metadata, ..
                         } = {
                             let validity = child_to_validity(
-                                &zstd_array.as_ref().slots()[0],
+                                zstd_array.as_ref().slots()[0].as_ref(),
                                 zstd_array.dtype().nullability(),
                             );
                             zstd_array.clone().into_data().into_parts(validity)
diff --git a/vortex-cuda/src/kernel/encodings/date_time_parts.rs b/vortex-cuda/src/kernel/encodings/date_time_parts.rs
index 39d1a394a33..d8c655c2558 100644
--- a/vortex-cuda/src/kernel/encodings/date_time_parts.rs
+++ b/vortex-cuda/src/kernel/encodings/date_time_parts.rs
@@ -22,7 +22,7 @@ use vortex::dtype::NativePType;
 use vortex::dtype::Nullability;
 use vortex::dtype::PType;
 use vortex::encodings::datetime_parts::DateTimeParts;
-use vortex::encodings::datetime_parts::DateTimePartsArrayExt;
+use vortex::encodings::datetime_parts::DateTimePartsArraySlotsExt;
 use vortex::error::VortexResult;
 use vortex::error::vortex_bail;
 use vortex::error::vortex_err;
diff --git a/vortex-cuda/src/kernel/encodings/zstd.rs b/vortex-cuda/src/kernel/encodings/zstd.rs
index 0364950d148..abadeb1698f 100644
--- a/vortex-cuda/src/kernel/encodings/zstd.rs
+++ b/vortex-cuda/src/kernel/encodings/zstd.rs
@@ -218,7 +218,7 @@ impl CudaExecute for ZstdExecutor {
 
 async fn decode_zstd(array: ZstdArray, ctx: &mut CudaExecutionCtx) -> VortexResult<Canonical> {
     let dtype = array.dtype().clone();
-    let validity = child_to_validity(&array.as_ref().slots()[0], dtype.nullability());
+    let validity = child_to_validity(array.as_ref().slots()[0].as_ref(), dtype.nullability());
     let ZstdDataParts {
         frames,
         metadata,
diff --git a/vortex-ffi/src/dtype.rs b/vortex-ffi/src/dtype.rs
index d3fe6f1a5c4..4e720fc6243 100644
--- a/vortex-ffi/src/dtype.rs
+++ b/vortex-ffi/src/dtype.rs
@@ -360,6 +360,7 @@ mod tests {
     use super::*;
     use crate::array::vx_array;
     use crate::array::vx_array_dtype;
+    use crate::array::vx_array_free;
     use crate::dtype::vx_dtype;
     use crate::dtype::vx_dtype_free;
     use crate::dtype::vx_dtype_get_variant;
@@ -674,7 +675,7 @@ mod tests {
 
         // Cleanup in reverse order - this is the safest order
         unsafe {
-            crate::array::vx_array_free(vx_arr);
+            vx_array_free(vx_arr);
         }
     }
 
@@ -699,7 +700,7 @@ mod tests {
         // Cleanup in careful order
         unsafe {
             // Field name is now a borrowed reference - do not free it
-            crate::array::vx_array_free(vx_arr);
+            vx_array_free(vx_arr);
         }
     }
 
@@ -732,7 +733,7 @@ mod tests {
 
         // Cleanup
         unsafe {
-            crate::array::vx_array_free(vx_arr);
+            vx_array_free(vx_arr);
         }
     }
 }