patches has same dtype as array

Author: danking

encodings/alp/src/alp/array.rs

@@ -48,16 +48,24 @@ impl ALPArray {
         let mut children = Vec::with_capacity(2);
         children.push(encoded);
         if let Some(patches) = &patches {
-            if patches.dtype().is_nullable() {
-                vortex_bail!(MismatchedTypes: "patches should be non-nullable", patches.dtype());
+            if patches.dtype() != &dtype {
+                vortex_bail!(MismatchedTypes: dtype, patches.dtype());
             }
+
+            if !matches!(
+                patches.values().logical_validity(),
+                LogicalValidity::AllValid(_)
+            ) {
+                vortex_bail!("ALPArray: patches must not contain invalid entries");
+            }
+
             children.push(patches.indices().clone());
             children.push(patches.values().clone());
         }
 
         let patches = patches
             .as_ref()
-            .map(|p| p.to_metadata(length, &dtype.as_nonnullable()))
+            .map(|p| p.to_metadata(length, &dtype))
             .transpose()?;
 
         Self::try_from_parts(
@@ -96,7 +104,7 @@ impl ALPArray {
                     .child(1, &p.indices_dtype(), p.len())
                     .vortex_expect("ALPArray: patch indices"),
                 self.as_ref()
-                    .child(2, &self.dtype().as_nonnullable(), p.len())
+                    .child(2, &self.dtype(), p.len())
                     .vortex_expect("ALPArray: patch values"),
             )
         })

encodings/alp/src/alp/compress.rs

@@ -1,5 +1,6 @@
 use vortex_array::array::PrimitiveArray;
 use vortex_array::patches::Patches;
+use vortex_array::validity::Validity;
 use vortex_array::variants::PrimitiveArrayTrait;
 use vortex_array::{ArrayDType, ArrayData, IntoArrayData, IntoArrayVariant};
 use vortex_dtype::{NativePType, PType};
@@ -36,12 +37,21 @@ where
     let (exponents, encoded, exc_pos, exc) =
         T::encode(values.as_slice::<T>(), &values.validity(), exponents)?;
     let len = encoded.len();
+    let patches_validity = if values.dtype().is_nullable() {
+        Validity::AllValid
+    } else {
+        Validity::NonNullable
+    };
     Ok((
         exponents,
         PrimitiveArray::new(encoded, values.validity()).into_array(),
         (!exc.is_empty()).then(|| {
             let position_arr = exc_pos.into_array();
-            Patches::new(len, position_arr, exc.into_array())
+            Patches::new(
+                len,
+                position_arr,
+                PrimitiveArray::new(exc, patches_validity).into_array(),
+            )
         }),
     ))
 }