ArrayRef

Signed-off-by: Nicholas Gates <nick@nickgates.com>

Author: gatesn

ARRAYVIEW_PLAN.md

@@ -154,7 +154,7 @@ impl ChunkedData {
 
     #[inline]
     pub fn chunk_offsets(&self) -> Buffer<u64> {
-        self.chunk_offsets.to_buffer()
+        self.chunk_offsets_data().to_buffer()
     }
 
     pub(crate) fn find_chunk_idx(&self, index: usize) -> VortexResult<(usize, usize)> {

PLAN.md

@@ -19,6 +19,8 @@ use crate::Precision;
 use crate::ToCanonical;
 use crate::arrays::ChunkedData;
 use crate::arrays::PrimitiveData;
+use crate::arrays::chunked::array::CHUNK_OFFSETS_SLOT;
+use crate::arrays::chunked::array::CHUNKS_OFFSET;
 use crate::arrays::chunked::compute::kernel::PARENT_KERNELS;
 use crate::arrays::chunked::compute::rules::PARENT_RULES;
 use crate::arrays::chunked::vtable::canonical::_canonicalize;
@@ -210,17 +212,17 @@ impl VTable for Chunked {
 
     fn slot_name(_array: ArrayView<'_, Self>, idx: usize) -> String {
         match idx {
-            0 => "chunk_offsets".to_string(),
-            n => format!("chunks[{}]", n - 1),
+            CHUNK_OFFSETS_SLOT => "chunk_offsets".to_string(),
+            n => format!("chunks[{}]", n - CHUNKS_OFFSET),
         }
     }
 
     fn with_slots(array: &mut Self::ArrayData, slots: Vec<Option<ArrayRef>>) -> VortexResult<()> {
         // Slots: chunk_offsets, then chunks...
         vortex_ensure!(!slots.is_empty(), "Chunked array needs at least one slot");
 
-        let nchunks = slots.len() - 1;
-        let chunk_offsets_ref = slots[0]
+        let nchunks = slots.len() - CHUNKS_OFFSET;
+        let chunk_offsets_ref = slots[CHUNK_OFFSETS_SLOT]
             .as_ref()
             .ok_or_else(|| vortex_err!("chunk_offsets slot must not be None"))?;
         let chunk_offsets_buf = chunk_offsets_ref.to_primitive().to_buffer::<u64>();
@@ -232,7 +234,7 @@ impl VTable for Chunked {
             chunk_offsets_buf.len()
         );
 
-        let chunks: Vec<ArrayRef> = slots[1..]
+        let chunks: Vec<ArrayRef> = slots[CHUNKS_OFFSET..]
             .iter()
             .map(|s| {
                 s.clone()

vortex-array/src/arrays/chunked/array.rs

@@ -17,6 +17,7 @@ use crate::ExecutionResult;
 use crate::IntoArray;
 use crate::Precision;
 use crate::arrays::ConstantData;
+use crate::arrays::constant::array::NUM_SLOTS;
 use crate::arrays::constant::compute::rules::PARENT_RULES;
 use crate::arrays::constant::vtable::canonical::constant_canonicalize;
 use crate::buffer::BufferHandle;
@@ -176,8 +177,9 @@ impl VTable for Constant {
 
     fn with_slots(_array: &mut Self::ArrayData, slots: Vec<Option<ArrayRef>>) -> VortexResult<()> {
         vortex_ensure!(
-            slots.is_empty(),
-            "ConstantArray has no slots, got {}",
+            slots.len() == NUM_SLOTS,
+            "ConstantArray expects exactly {} slots, got {}",
+            NUM_SLOTS,
             slots.len()
         );
         Ok(())

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

@@ -131,8 +131,9 @@ impl VTable for Null {
 
     fn with_slots(_array: &mut Self::ArrayData, slots: Vec<Option<ArrayRef>>) -> VortexResult<()> {
         vortex_ensure!(
-            slots.is_empty(),
-            "NullArray has no slots, got {}",
+            slots.len() == NUM_SLOTS,
+            "NullArray expects exactly {} slots, got {}",
+            NUM_SLOTS,
             slots.len()
         );
         Ok(())

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

@@ -235,7 +235,7 @@ impl<V: VTable> Array<V> {
         // NOTE(ngates): use downcast_unchecked when it becomes stable
         debug_assert!(any.is::<ArrayInner<V>>());
         // SAFETY: caller guarantees that T is the correct type
-        unsafe { &*(self as *const dyn Any as *const ArrayInner<V>) }
+        unsafe { &*(any as *const dyn Any as *const ArrayInner<V>) }
     }
 }