chore: fallible canonical (#6006)

Adding `ScalarFnArray` meant now canonical can fail

# break

`to_canonical` now return a `VortexResult<Canonical>`
`append_to_builder` now return `VortexResult<()>`

---------

Signed-off-by: Joe Isaacs <joe.isaacs@live.co.uk>

Author: joseph-isaacs

benchmarks/compress-bench/src/lib.rs

@@ -23,7 +23,7 @@ pub fn chunked_to_vec_record_batch(
         .map(|array| {
             // TODO(connor)[ListView]: The rust Parquet implementation does not support writing
             // `ListView` to Parquet files yet.
-            let converted_array = recursive_list_from_list_view(array.clone());
+            let converted_array = recursive_list_from_list_view(array.clone())?;
             Ok(RecordBatch::try_from(converted_array.as_ref())?)
         })
         .collect::<anyhow::Result<Vec<_>>>()?;

encodings/alp/src/alp/array.rs

@@ -460,8 +460,8 @@ impl BaseArrayVTable<ALPVTable> for ALPVTable {
 }
 
 impl CanonicalVTable<ALPVTable> for ALPVTable {
-    fn canonicalize(array: &ALPArray) -> Canonical {
-        Canonical::Primitive(decompress_into_array(array.clone()))
+    fn canonicalize(array: &ALPArray) -> VortexResult<Canonical> {
+        Ok(Canonical::Primitive(decompress_into_array(array.clone())))
     }
 }
 

encodings/alp/src/alp/compute/cast.rs

@@ -60,56 +60,58 @@ mod tests {
     use vortex_dtype::DType;
     use vortex_dtype::Nullability;
     use vortex_dtype::PType;
+    use vortex_error::VortexExpect;
+    use vortex_error::VortexResult;
 
     use crate::ALPVTable;
 
     #[test]
-    fn test_cast_alp_f32_to_f64() {
+    fn test_cast_alp_f32_to_f64() -> VortexResult<()> {
         let values = buffer![1.5f32, 2.5, 3.5, 4.5].into_array();
         let alp = ALPVTable
             .as_vtable()
-            .encode(&values.to_canonical(), None)
-            .unwrap()
-            .unwrap();
+            .encode(&values.to_canonical()?, None)?
+            .vortex_expect("must encode");
 
         let casted = cast(
             alp.as_ref(),
             &DType::Primitive(PType::F64, Nullability::NonNullable),
-        )
-        .unwrap();
+        )?;
         assert_eq!(
             casted.dtype(),
             &DType::Primitive(PType::F64, Nullability::NonNullable)
         );
 
-        let decoded = casted.to_canonical().into_primitive();
+        let decoded = casted.to_canonical()?.into_primitive();
         let values = decoded.as_slice::<f64>();
         assert_eq!(values.len(), 4);
         assert!((values[0] - 1.5).abs() < f64::EPSILON);
         assert!((values[1] - 2.5).abs() < f64::EPSILON);
+
+        Ok(())
     }
 
     #[test]
-    fn test_cast_alp_to_int() {
+    fn test_cast_alp_to_int() -> VortexResult<()> {
         let values = buffer![1.0f32, 2.0, 3.0, 4.0].into_array();
         let alp = ALPVTable
             .as_vtable()
-            .encode(&values.to_canonical(), None)
-            .unwrap()
-            .unwrap();
+            .encode(&values.to_canonical()?, None)?
+            .vortex_expect("must encode");
 
         let casted = cast(
             alp.as_ref(),
             &DType::Primitive(PType::I32, Nullability::NonNullable),
-        )
-        .unwrap();
+        )?;
         assert_eq!(
             casted.dtype(),
             &DType::Primitive(PType::I32, Nullability::NonNullable)
         );
 
-        let decoded = casted.to_canonical().into_primitive();
+        let decoded = casted.to_canonical()?.into_primitive();
         assert_arrays_eq!(decoded, PrimitiveArray::from_iter([1i32, 2, 3, 4]));
+
+        Ok(())
     }
 
     #[rstest]
@@ -118,12 +120,13 @@ mod tests {
     #[case(PrimitiveArray::from_option_iter([Some(1.1f32), None, Some(2.2), Some(3.3), None]).into_array())]
     #[case(buffer![42.42f64].into_array())]
     #[case(buffer![0.0f32, -1.5, 2.5, -3.5, 4.5].into_array())]
-    fn test_cast_alp_conformance(#[case] array: vortex_array::ArrayRef) {
+    fn test_cast_alp_conformance(#[case] array: vortex_array::ArrayRef) -> VortexResult<()> {
         let alp = ALPVTable
             .as_vtable()
-            .encode(&array.to_canonical(), None)
-            .unwrap()
-            .unwrap();
+            .encode(&array.to_canonical()?, None)?
+            .vortex_expect("cannot fail");
         test_cast_conformance(alp.as_ref());
+
+        Ok(())
     }
 }

encodings/alp/src/alp/compute/filter.rs

@@ -59,7 +59,7 @@ mod test {
     fn test_filter_alp_conformance(#[case] array: ArrayRef) {
         let alp = ALPVTable
             .as_vtable()
-            .encode(&array.to_canonical(), None)
+            .encode(&array.to_canonical().unwrap(), None)
             .unwrap()
             .unwrap();
         test_filter_conformance(alp.as_ref());

encodings/alp/src/alp/compute/mask.rs

@@ -57,7 +57,7 @@ mod test {
     fn test_mask_alp_conformance(#[case] array: vortex_array::ArrayRef) {
         let alp = ALPVTable
             .as_vtable()
-            .encode(&array.to_canonical(), None)
+            .encode(&array.to_canonical().unwrap(), None)
             .unwrap()
             .unwrap();
         test_mask_conformance(alp.as_ref());

encodings/alp/src/alp/compute/take.rs

@@ -54,7 +54,7 @@ mod test {
     fn test_take_alp_conformance(#[case] array: vortex_array::ArrayRef) {
         let alp = ALPVTable
             .as_vtable()
-            .encode(&array.to_canonical(), None)
+            .encode(&array.to_canonical().unwrap(), None)
             .unwrap()
             .unwrap();
         test_take_conformance(alp.as_ref());

encodings/alp/src/alp_rd/array.rs

@@ -430,7 +430,7 @@ impl BaseArrayVTable<ALPRDVTable> for ALPRDVTable {
 }
 
 impl CanonicalVTable<ALPRDVTable> for ALPRDVTable {
-    fn canonicalize(array: &ALPRDArray) -> Canonical {
+    fn canonicalize(array: &ALPRDArray) -> VortexResult<Canonical> {
         let left_parts = array.left_parts().to_primitive();
         let right_parts = array.right_parts().to_primitive();
 
@@ -461,7 +461,7 @@ impl CanonicalVTable<ALPRDVTable> for ALPRDVTable {
             )
         };
 
-        Canonical::Primitive(decoded_array)
+        Ok(Canonical::Primitive(decoded_array))
     }
 }
 

encodings/bytebool/src/array.rs

@@ -215,10 +215,13 @@ impl BaseArrayVTable<ByteBoolVTable> for ByteBoolVTable {
 }
 
 impl CanonicalVTable<ByteBoolVTable> for ByteBoolVTable {
-    fn canonicalize(array: &ByteBoolArray) -> Canonical {
+    fn canonicalize(array: &ByteBoolArray) -> VortexResult<Canonical> {
         let boolean_buffer = BitBuffer::from(array.as_slice());
         let validity = array.validity().clone();
-        Canonical::Bool(BoolArray::from_bit_buffer(boolean_buffer, validity))
+        Ok(Canonical::Bool(BoolArray::from_bit_buffer(
+            boolean_buffer,
+            validity,
+        )))
     }
 }
 

encodings/datetime-parts/src/canonical.rs

@@ -17,14 +17,15 @@ use vortex_dtype::datetime::TemporalMetadata;
 use vortex_dtype::datetime::TimeUnit;
 use vortex_dtype::match_each_integer_ptype;
 use vortex_error::VortexExpect as _;
+use vortex_error::VortexResult;
 use vortex_error::vortex_panic;
 
 use crate::DateTimePartsArray;
 use crate::DateTimePartsVTable;
 
 impl CanonicalVTable<DateTimePartsVTable> for DateTimePartsVTable {
-    fn canonicalize(array: &DateTimePartsArray) -> Canonical {
-        Canonical::Extension(decode_to_temporal(array).into())
+    fn canonicalize(array: &DateTimePartsArray) -> VortexResult<Canonical> {
+        Ok(Canonical::Extension(decode_to_temporal(array).into()))
     }
 }
 

encodings/decimal-byte-parts/src/decimal_byte_parts/mod.rs

@@ -235,13 +235,13 @@ impl BaseArrayVTable<DecimalBytePartsVTable> for DecimalBytePartsVTable {
 }
 
 impl CanonicalVTable<DecimalBytePartsVTable> for DecimalBytePartsVTable {
-    fn canonicalize(array: &DecimalBytePartsArray) -> Canonical {
+    fn canonicalize(array: &DecimalBytePartsArray) -> VortexResult<Canonical> {
         // TODO(joe): support parts len != 1
         let prim = array.msp.to_primitive();
         // Depending on the decimal type and the min/max of the primitive array we can choose
         // the correct buffer size
 
-        match_each_signed_integer_ptype!(prim.ptype(), |P| {
+        Ok(match_each_signed_integer_ptype!(prim.ptype(), |P| {
             // SAFETY: The primitive array's buffer is already validated with correct type.
             // The decimal dtype matches the array's dtype, and validity is preserved.
             Canonical::Decimal(unsafe {
@@ -251,7 +251,7 @@ impl CanonicalVTable<DecimalBytePartsVTable> for DecimalBytePartsVTable {
                     prim.validity().clone(),
                 )
             })
-        })
+        }))
     }
 }