Make serde optional and return VortexError

vortex-alp/src/array.rs

@@ -127,8 +127,8 @@ impl Array for ALPArray {
         self.encoded().nbytes() + self.patches().map(|p| p.nbytes()).unwrap_or(0)
     }
 
-    fn serde(&self) -> &dyn ArraySerde {
-        self
+    fn serde(&self) -> Option<&dyn ArraySerde> {
+        Some(self)
     }
 }
 

vortex-alp/src/serde.rs

@@ -1,16 +1,14 @@
-use std::io;
-use std::io::ErrorKind;
-
 use crate::alp::Exponents;
 use vortex::array::{Array, ArrayRef};
 use vortex::dtype::{DType, FloatWidth, Signedness};
+use vortex::error::{VortexError, VortexResult};
 use vortex::serde::{ArraySerde, EncodingSerde, ReadCtx, WriteCtx};
 
 use crate::ALPArray;
 use crate::ALPEncoding;
 
 impl ArraySerde for ALPArray {
-    fn write(&self, ctx: &mut WriteCtx) -> io::Result<()> {
+    fn write(&self, ctx: &mut WriteCtx) -> VortexResult<()> {
         ctx.write_option_tag(self.patches().is_some())?;
         if let Some(p) = self.patches() {
             ctx.write(p.as_ref())?;
@@ -21,7 +19,7 @@ impl ArraySerde for ALPArray {
 }
 
 impl EncodingSerde for ALPEncoding {
-    fn read(&self, ctx: &mut ReadCtx) -> io::Result<ArrayRef> {
+    fn read(&self, ctx: &mut ReadCtx) -> VortexResult<ArrayRef> {
         let patches_tag = ctx.read_nbytes::<1>()?[0];
         let patches = if patches_tag == 0x01 {
             Some(ctx.read()?)
@@ -33,9 +31,9 @@ impl EncodingSerde for ALPEncoding {
             DType::Float(width, nullability) => match width {
                 FloatWidth::_32 => DType::Int(32.into(), Signedness::Signed, *nullability),
                 FloatWidth::_64 => DType::Int(64.into(), Signedness::Signed, *nullability),
-                _ => return Err(io::Error::new(ErrorKind::InvalidData, "invalid dtype")),
+                _ => return Err(VortexError::InvalidDType(ctx.schema().clone())),
             },
-            _ => return Err(io::Error::new(ErrorKind::InvalidData, "invalid dtype")),
+            _ => return Err(VortexError::InvalidDType(ctx.schema().clone())),
         };
         let encoded = ctx.with_schema(&encoded_dtype).read()?;
         Ok(ALPArray::new(
@@ -52,17 +50,16 @@ impl EncodingSerde for ALPEncoding {
 
 #[cfg(test)]
 mod test {
-    use std::io;
-
     use vortex::array::downcast::DowncastArrayBuiltin;
     use vortex::array::primitive::PrimitiveArray;
     use vortex::array::{Array, ArrayRef};
+    use vortex::error::VortexResult;
     use vortex::serde::{ReadCtx, WriteCtx};
 
     use crate::compress::alp_encode;
     use crate::downcast::DowncastALP;
 
-    fn roundtrip_array(array: &dyn Array) -> io::Result<ArrayRef> {
+    fn roundtrip_array(array: &dyn Array) -> VortexResult<ArrayRef> {
         let mut buf = Vec::<u8>::new();
         let mut write_ctx = WriteCtx::new(&mut buf);
         write_ctx.write(array)?;

vortex-array/src/array/bool/mod.rs

@@ -152,8 +152,8 @@ impl Array for BoolArray {
         (self.len() + 7) / 8
     }
 
-    fn serde(&self) -> &dyn ArraySerde {
-        self
+    fn serde(&self) -> Option<&dyn ArraySerde> {
+        Some(self)
     }
 }
 

vortex-array/src/array/bool/serde.rs

@@ -1,13 +1,12 @@
-use std::io;
-
 use arrow_buffer::buffer::BooleanBuffer;
 
 use crate::array::bool::{BoolArray, BoolEncoding};
 use crate::array::{Array, ArrayRef};
+use crate::error::VortexResult;
 use crate::serde::{ArraySerde, EncodingSerde, ReadCtx, WriteCtx};
 
 impl ArraySerde for BoolArray {
-    fn write(&self, ctx: &mut WriteCtx) -> io::Result<()> {
+    fn write(&self, ctx: &mut WriteCtx) -> VortexResult<()> {
         if let Some(v) = self.validity() {
             ctx.write(v.as_ref())?;
         }
@@ -16,7 +15,7 @@ impl ArraySerde for BoolArray {
 }
 
 impl EncodingSerde for BoolEncoding {
-    fn read(&self, ctx: &mut ReadCtx) -> io::Result<ArrayRef> {
+    fn read(&self, ctx: &mut ReadCtx) -> VortexResult<ArrayRef> {
         let validity = if ctx.schema().is_nullable() {
             Some(ctx.validity().read()?)
         } else {

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

@@ -167,8 +167,8 @@ impl Array for ChunkedArray {
         self.chunks().iter().map(|arr| arr.nbytes()).sum()
     }
 
-    fn serde(&self) -> &dyn ArraySerde {
-        self
+    fn serde(&self) -> Option<&dyn ArraySerde> {
+        Some(self)
     }
 }
 

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

@@ -1,11 +1,10 @@
-use std::io;
-
 use crate::array::chunked::{ChunkedArray, ChunkedEncoding};
 use crate::array::{Array, ArrayRef};
+use crate::error::VortexResult;
 use crate::serde::{ArraySerde, EncodingSerde, ReadCtx, WriteCtx};
 
 impl ArraySerde for ChunkedArray {
-    fn write(&self, ctx: &mut WriteCtx) -> io::Result<()> {
+    fn write(&self, ctx: &mut WriteCtx) -> VortexResult<()> {
         ctx.write_usize(self.chunks().len())?;
         for c in self.chunks() {
             ctx.write(c.as_ref())?;
@@ -15,7 +14,7 @@ impl ArraySerde for ChunkedArray {
 }
 
 impl EncodingSerde for ChunkedEncoding {
-    fn read(&self, ctx: &mut ReadCtx) -> io::Result<ArrayRef> {
+    fn read(&self, ctx: &mut ReadCtx) -> VortexResult<ArrayRef> {
         let chunk_len = ctx.read_usize()?;
         let mut chunks = Vec::<ArrayRef>::with_capacity(chunk_len);
         // TODO(robert): Use read_vectored

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

@@ -129,8 +129,8 @@ impl Array for ConstantArray {
         self.scalar.nbytes()
     }
 
-    fn serde(&self) -> &dyn ArraySerde {
-        self
+    fn serde(&self) -> Option<&dyn ArraySerde> {
+        Some(self)
     }
 }
 

vortex-array/src/array/constant/serde.rs

@@ -1,18 +1,17 @@
-use std::io;
-
 use crate::array::constant::{ConstantArray, ConstantEncoding};
 use crate::array::{Array, ArrayRef};
+use crate::error::VortexResult;
 use crate::serde::{ArraySerde, EncodingSerde, ReadCtx, WriteCtx};
 
 impl ArraySerde for ConstantArray {
-    fn write(&self, ctx: &mut WriteCtx<'_>) -> io::Result<()> {
+    fn write(&self, ctx: &mut WriteCtx<'_>) -> VortexResult<()> {
         ctx.write_usize(self.len())?;
         ctx.scalar(self.scalar())
     }
 }
 
 impl EncodingSerde for ConstantEncoding {
-    fn read(&self, ctx: &mut ReadCtx) -> io::Result<ArrayRef> {
+    fn read(&self, ctx: &mut ReadCtx) -> VortexResult<ArrayRef> {
         let len = ctx.read_usize()?;
         let scalar = ctx.scalar()?;
         Ok(ConstantArray::new(scalar, len).boxed())

vortex-array/src/array/mod.rs

@@ -70,7 +70,9 @@ pub trait Array:
     /// Approximate size in bytes of the array. Only takes into account variable size portion of the array
     fn nbytes(&self) -> usize;
 
-    fn serde(&self) -> &dyn ArraySerde;
+    fn serde(&self) -> Option<&dyn ArraySerde> {
+        None
+    }
 }
 
 dyn_clone::clone_trait_object!(Array);

vortex-array/src/array/primitive/mod.rs

@@ -224,8 +224,8 @@ impl Array for PrimitiveArray {
         self.buffer.len()
     }
 
-    fn serde(&self) -> &dyn ArraySerde {
-        self
+    fn serde(&self) -> Option<&dyn ArraySerde> {
+        Some(self)
     }
 }
 

vortex-array/src/array/primitive/serde.rs

@@ -3,11 +3,12 @@ use std::io::ErrorKind;
 
 use crate::array::primitive::{PrimitiveArray, PrimitiveEncoding};
 use crate::array::{Array, ArrayRef};
+use crate::error::VortexResult;
 use crate::ptype::PType;
 use crate::serde::{ArraySerde, EncodingSerde, ReadCtx, WriteCtx};
 
 impl ArraySerde for PrimitiveArray {
-    fn write(&self, ctx: &mut WriteCtx) -> io::Result<()> {
+    fn write(&self, ctx: &mut WriteCtx) -> VortexResult<()> {
         if let Some(v) = self.validity() {
             ctx.write(v.as_ref())?;
         }
@@ -16,7 +17,7 @@ impl ArraySerde for PrimitiveArray {
 }
 
 impl EncodingSerde for PrimitiveEncoding {
-    fn read(&self, ctx: &mut ReadCtx) -> io::Result<ArrayRef> {
+    fn read(&self, ctx: &mut ReadCtx) -> VortexResult<ArrayRef> {
         let validity = if ctx.schema().is_nullable() {
             Some(ctx.validity().read()?)
         } else {

vortex-array/src/array/sparse/mod.rs

@@ -183,8 +183,8 @@ impl Array for SparseArray {
         self.indices.nbytes() + self.values.nbytes()
     }
 
-    fn serde(&self) -> &dyn ArraySerde {
-        self
+    fn serde(&self) -> Option<&dyn ArraySerde> {
+        Some(self)
     }
 }
 

vortex-array/src/array/sparse/serde.rs

@@ -4,10 +4,11 @@ use std::io::ErrorKind;
 use crate::array::sparse::{SparseArray, SparseEncoding};
 use crate::array::{Array, ArrayRef};
 use crate::dtype::DType;
+use crate::error::VortexResult;
 use crate::serde::{ArraySerde, EncodingSerde, ReadCtx, WriteCtx};
 
 impl ArraySerde for SparseArray {
-    fn write(&self, ctx: &mut WriteCtx) -> io::Result<()> {
+    fn write(&self, ctx: &mut WriteCtx) -> VortexResult<()> {
         ctx.write_usize(self.len())?;
         // TODO(robert): Rewrite indices and don't store offset
         ctx.write_usize(self.indices_offset())?;
@@ -17,7 +18,7 @@ impl ArraySerde for SparseArray {
 }
 
 impl EncodingSerde for SparseEncoding {
-    fn read(&self, ctx: &mut ReadCtx) -> io::Result<ArrayRef> {
+    fn read(&self, ctx: &mut ReadCtx) -> VortexResult<ArrayRef> {
         let len = ctx.read_usize()?;
         let offset = ctx.read_usize()?;
         let indices = ctx.with_schema(&DType::IDX).read()?;

vortex-array/src/array/struct_/mod.rs

@@ -156,8 +156,8 @@ impl Array for StructArray {
         self.fields.iter().map(|arr| arr.nbytes()).sum()
     }
 
-    fn serde(&self) -> &dyn ArraySerde {
-        self
+    fn serde(&self) -> Option<&dyn ArraySerde> {
+        Some(self)
     }
 }
 

vortex-array/src/array/struct_/serde.rs

@@ -1,13 +1,11 @@
-use std::io;
-use std::io::ErrorKind;
-
 use crate::array::struct_::{StructArray, StructEncoding};
 use crate::array::{Array, ArrayRef};
 use crate::dtype::DType;
+use crate::error::{VortexError, VortexResult};
 use crate::serde::{ArraySerde, EncodingSerde, ReadCtx, WriteCtx};
 
 impl ArraySerde for StructArray {
-    fn write(&self, ctx: &mut WriteCtx) -> io::Result<()> {
+    fn write(&self, ctx: &mut WriteCtx) -> VortexResult<()> {
         ctx.write_usize(self.fields().len())?;
         for f in self.fields() {
             ctx.write(f.as_ref())?;
@@ -17,18 +15,15 @@ impl ArraySerde for StructArray {
 }
 
 impl EncodingSerde for StructEncoding {
-    fn read(&self, ctx: &mut ReadCtx) -> io::Result<ArrayRef> {
+    fn read(&self, ctx: &mut ReadCtx) -> VortexResult<ArrayRef> {
         let num_fields = ctx.read_usize()?;
         let mut fields = Vec::<ArrayRef>::with_capacity(num_fields);
         // TODO(robert): use read_vectored
         for i in 0..num_fields {
             fields.push(ctx.subfield(i).read()?);
         }
         let DType::Struct(ns, _) = ctx.schema() else {
-            return Err(io::Error::new(
-                ErrorKind::InvalidData,
-                "invalid schema type",
-            ));
+            return Err(VortexError::InvalidDType(ctx.schema().clone()));
         };
         Ok(StructArray::new(ns.clone(), fields).boxed())
     }

vortex-array/src/array/typed/mod.rs

@@ -108,8 +108,8 @@ impl Array for TypedArray {
         self.array.nbytes()
     }
 
-    fn serde(&self) -> &dyn ArraySerde {
-        self
+    fn serde(&self) -> Option<&dyn ArraySerde> {
+        Some(self)
     }
 }
 

vortex-array/src/array/typed/serde.rs

@@ -1,18 +1,17 @@
-use std::io;
-
 use crate::array::typed::{TypedArray, TypedEncoding};
 use crate::array::{Array, ArrayRef};
+use crate::error::VortexResult;
 use crate::serde::{ArraySerde, EncodingSerde, ReadCtx, WriteCtx};
 
 impl ArraySerde for TypedArray {
-    fn write(&self, ctx: &mut WriteCtx) -> io::Result<()> {
+    fn write(&self, ctx: &mut WriteCtx) -> VortexResult<()> {
         ctx.dtype(self.untyped_array().dtype())?;
         ctx.write(self.untyped_array())
     }
 }
 
 impl EncodingSerde for TypedEncoding {
-    fn read(&self, ctx: &mut ReadCtx) -> io::Result<ArrayRef> {
+    fn read(&self, ctx: &mut ReadCtx) -> VortexResult<ArrayRef> {
         let inner_dtype = ctx.dtype()?;
         Ok(TypedArray::new(ctx.with_schema(&inner_dtype).read()?, ctx.schema().clone()).boxed())
     }

vortex-array/src/array/varbin/mod.rs

@@ -301,8 +301,8 @@ impl Array for VarBinArray {
         self.bytes.nbytes() + self.offsets.nbytes()
     }
 
-    fn serde(&self) -> &dyn ArraySerde {
-        self
+    fn serde(&self) -> Option<&dyn ArraySerde> {
+        Some(self)
     }
 }
 

vortex-array/src/array/varbin/serde.rs

@@ -1,11 +1,10 @@
-use std::io;
-
 use crate::array::varbin::{VarBinArray, VarBinEncoding};
 use crate::array::{Array, ArrayRef};
+use crate::error::VortexResult;
 use crate::serde::{ArraySerde, EncodingSerde, ReadCtx, WriteCtx};
 
 impl ArraySerde for VarBinArray {
-    fn write(&self, ctx: &mut WriteCtx) -> io::Result<()> {
+    fn write(&self, ctx: &mut WriteCtx) -> VortexResult<()> {
         if let Some(v) = self.validity() {
             ctx.write(v.as_ref())?;
         }
@@ -16,7 +15,7 @@ impl ArraySerde for VarBinArray {
 }
 
 impl EncodingSerde for VarBinEncoding {
-    fn read(&self, ctx: &mut ReadCtx) -> io::Result<ArrayRef> {
+    fn read(&self, ctx: &mut ReadCtx) -> VortexResult<ArrayRef> {
         let validity = if ctx.schema().is_nullable() {
             Some(ctx.validity().read()?)
         } else {

vortex-array/src/array/varbinview/mod.rs

@@ -301,8 +301,8 @@ impl Array for VarBinViewArray {
         self.views.nbytes() + self.data.iter().map(|arr| arr.nbytes()).sum::<usize>()
     }
 
-    fn serde(&self) -> &dyn ArraySerde {
-        self
+    fn serde(&self) -> Option<&dyn ArraySerde> {
+        Some(self)
     }
 }