parquet 0.5.0 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 252c96a0dc96337e1d64514ee24ec0a470621fd25b5e1497de75f666e060e32e
-  data.tar.gz: 38749e71de16f448404bedf5f316a7b1cebbf51121bff05b76e83b50e7081968
+  metadata.gz: 0d72c16371c10a011af5118f2915de9bbeb33cde133369bdac2050e3c035572e
+  data.tar.gz: b39c6ec9a8232eca5b5b156bf28992ed59c05e9a36e4c13db2b8933a74485ba0
 SHA512:
-  metadata.gz: 5b4cc0e162f2f823e127167d93963b778c56f0ebaa1deda6bee87f5ff453b36cad1c7a77e6e53f35fde6c24492fcb6d002da0dab8749afcafd4ee7e084e81042
-  data.tar.gz: 39112b58e3c859b589a0b89d9ff59b18294c336c0d43357c5859a10153e5345b4fdc79cb1e1b09e5649441bb957c8c45506c3818bd1b13aaec8c5fa63a1415a8
+  metadata.gz: c7f338b1d010fa59c2344065b233ff20a08d4a17c6ca987ef72677150dd1cbf55d134855585d68e187b748dc5121f13d5e86cb82aabc1eeb3562a3326aca459c
+  data.tar.gz: 69eaa6b133123944138a826612a7b48d9f87acb202ecbe172e253be02a1a1c7009e3d7182e8bb31ae423098bc34bb5dddc4ce042453f0d1cb41505d56d02c21e

data/README.md

@@ -294,7 +294,7 @@ The Schema DSL supports:
 - **Complex types**: Structs, lists, and maps with arbitrary nesting
 - **Nullability control**: Specify which fields can contain null values with `nullable: false/true`
 - **List item nullability**: Control whether list items can be null with `item_nullable: false/true`
-- **Map key/value nullability**: Control whether map keys or values can be null with `key_nullable: false/true` and `value_nullable: false/true`
+- **Map key/value nullability**: Control whether map keys or values can be null with `value_nullable: false/true`
 
 Note: When using List and Map types, you need to provide at least:
 - For lists: The `item:` parameter specifying the item type

data/ext/parquet/src/header_cache.rs

@@ -6,10 +6,7 @@
 /// so this optimization could be removed if any issues arise.
 use std::{
     collections::HashMap,
-    sync::{
-        atomic::{AtomicU32, Ordering},
-        LazyLock, Mutex,
-    },
+    sync::{LazyLock, Mutex},
 };
 
 use magnus::{IntoValue, RString, Ruby, Value};
@@ -24,7 +21,7 @@ pub enum CacheError {
     RStringConversion(String),
 }
 
-static STRING_CACHE: LazyLock<Mutex<HashMap<&'static str, (StringCacheKey, AtomicU32)>>> =
+static STRING_CACHE: LazyLock<Mutex<HashMap<&'static str, StringCacheKey>>> =
     LazyLock::new(|| Mutex::new(HashMap::with_capacity(100)));
 
 pub struct StringCache;
@@ -84,18 +81,16 @@ impl StringCache {
     pub fn intern_many<AsStr: AsRef<str>>(
         strings: &[AsStr],
     ) -> Result<Vec<StringCacheKey>, CacheError> {
-        let mut cache = STRING_CACHE
+        let cache = STRING_CACHE
             .lock()
             .map_err(|e| CacheError::LockError(e.to_string()))?;
 
         let mut result: Vec<StringCacheKey> = Vec::with_capacity(strings.len());
         for string in strings {
-            if let Some((_, (interned_string, counter))) = cache.get_key_value(string.as_ref()) {
-                counter.fetch_add(1, Ordering::Relaxed);
+            if let Some((_, interned_string)) = cache.get_key_value(string.as_ref()) {
                 result.push(*interned_string);
             } else {
                 let interned = StringCacheKey::new(string.as_ref())?;
-                cache.insert(interned.0, (interned, AtomicU32::new(1)));
                 result.push(interned);
             }
         }

data/ext/parquet/src/logger.rs

@@ -5,7 +5,7 @@ use std::str::FromStr;
 
 use magnus::{exception::runtime_error, value::ReprValue, Error as MagnusError, Ruby, Value};
 
-use crate::{reader::ReaderError, utils::parse_string_or_symbol};
+use crate::{types::ParquetGemError, utils::parse_string_or_symbol};
 
 /// Severity levels that match Ruby's Logger levels
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
@@ -45,7 +45,7 @@ pub struct RubyLogger {
 
 #[allow(dead_code)]
 impl RubyLogger {
-    pub fn new(ruby: &Ruby, logger_value: Option<Value>) -> Result<Self, ReaderError> {
+    pub fn new(ruby: &Ruby, logger_value: Option<Value>) -> Result<Self, ParquetGemError> {
         let environment_level = std::env::var("PARQUET_GEM_LOG_LEVEL")
             .unwrap_or_else(|_| "warn".to_string())
             .parse::<LogLevel>()

data/ext/parquet/src/reader/common.rs

@@ -8,32 +8,29 @@ use std::fs::File;
 use std::sync::Arc;
 
 use magnus::value::ReprValue;
-use magnus::{Error as MagnusError, Value};
+use magnus::{Error as MagnusError, Ruby, Value};
 
 use crate::header_cache::StringCache;
 use crate::ruby_reader::{RubyReader, ThreadSafeRubyReader};
-use crate::types::TryIntoValue;
+use crate::types::{ParquetGemError, TryIntoValue};
 use crate::ColumnRecord;
 
-use super::ReaderError;
-
 /// Opens a parquet file or IO-like object for reading
 ///
 /// This function handles both file paths (as strings) and IO-like objects,
 /// returning either a File or a ThreadSafeRubyReader that can be used with
 /// parquet readers.
 pub fn open_parquet_source(
+    ruby: Arc<Ruby>,
     to_read: Value,
-) -> Result<Either<File, ThreadSafeRubyReader>, ReaderError> {
-    let ruby = unsafe { magnus::Ruby::get_unchecked() };
-
+) -> Result<Either<File, ThreadSafeRubyReader>, ParquetGemError> {
     if to_read.is_kind_of(ruby.class_string()) {
         let path_string = to_read.to_r_string()?;
         let file_path = unsafe { path_string.as_str()? };
-        let file = File::open(file_path).map_err(ReaderError::from)?;
+        let file = File::open(file_path).map_err(ParquetGemError::from)?;
         Ok(Either::Left(file))
     } else {
-        let readable = ThreadSafeRubyReader::new(RubyReader::try_from(to_read)?);
+        let readable = ThreadSafeRubyReader::new(RubyReader::new(ruby, to_read)?);
         Ok(Either::Right(readable))
     }
 }
@@ -60,9 +57,9 @@ pub fn create_batch_reader<T: parquet::file::reader::ChunkReader + 'static>(
     reader: T,
     columns: &Option<Vec<String>>,
     batch_size: Option<usize>,
-) -> Result<(ParquetRecordBatchReader, std::sync::Arc<Schema>, i64), ReaderError> {
-    let mut builder =
-        ParquetRecordBatchReaderBuilder::try_new(reader).map_err(|e| ReaderError::Parquet(e))?;
+) -> Result<(ParquetRecordBatchReader, std::sync::Arc<Schema>, i64), ParquetGemError> {
+    let mut builder = ParquetRecordBatchReaderBuilder::try_new(reader)
+        .map_err(|e| ParquetGemError::Parquet(e))?;
 
     let schema = builder.schema().clone();
     let num_rows = builder.metadata().file_metadata().num_rows();
@@ -81,7 +78,7 @@ pub fn create_batch_reader<T: parquet::file::reader::ChunkReader + 'static>(
         builder = builder.with_batch_size(batch_size);
     }
 
-    let reader = builder.build().map_err(|e| ReaderError::Parquet(e))?;
+    let reader = builder.build().map_err(|e| ParquetGemError::Parquet(e))?;
     Ok((reader, schema, num_rows))
 }
 
@@ -91,7 +88,7 @@ pub fn handle_empty_file(
     ruby: &magnus::Ruby,
     schema: &Arc<Schema>,
     num_rows: i64,
-) -> Result<bool, ReaderError> {
+) -> Result<bool, ParquetGemError> {
     if num_rows == 0 {
         let mut map =
             HashMap::with_capacity_and_hasher(schema.fields().len(), RandomState::default());
@@ -101,7 +98,7 @@ pub fn handle_empty_file(
             .map(|field| field.name().to_string())
             .collect();
         let interned_headers =
-            StringCache::intern_many(&headers).map_err(|e| ReaderError::HeaderIntern(e))?;
+            StringCache::intern_many(&headers).map_err(|e| ParquetGemError::HeaderIntern(e))?;
         for field in interned_headers.iter() {
             map.insert(*field, vec![]);
         }

data/ext/parquet/src/reader/mod.rs

@@ -2,61 +2,5 @@ mod common;
 mod parquet_column_reader;
 mod parquet_row_reader;
 
-use std::io;
-
-use magnus::Error as MagnusError;
-use thiserror::Error;
-
-use crate::header_cache::CacheError;
 pub use parquet_column_reader::parse_parquet_columns;
 pub use parquet_row_reader::parse_parquet_rows;
-
-#[derive(Error, Debug)]
-pub enum ReaderError {
-    #[error("Failed to open file: {0}")]
-    FileOpen(#[from] io::Error),
-    #[error("Failed to intern headers: {0}")]
-    HeaderIntern(#[from] CacheError),
-    #[error("Ruby error: {0}")]
-    Ruby(#[from] MagnusErrorWrapper),
-    #[error("Parquet error: {0}")]
-    Parquet(#[from] parquet::errors::ParquetError),
-    #[error("Arrow error: {0}")]
-    Arrow(#[from] arrow_schema::ArrowError),
-    #[error("UTF-8 error: {0}")]
-    Utf8Error(#[from] simdutf8::basic::Utf8Error),
-    #[error("Jiff error: {0}")]
-    Jiff(#[from] jiff::Error),
-}
-
-#[derive(Debug)]
-pub struct MagnusErrorWrapper(pub MagnusError);
-
-impl From<MagnusError> for MagnusErrorWrapper {
-    fn from(err: MagnusError) -> Self {
-        Self(err)
-    }
-}
-
-impl std::fmt::Display for MagnusErrorWrapper {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", self.0)
-    }
-}
-
-impl std::error::Error for MagnusErrorWrapper {}
-
-impl From<MagnusError> for ReaderError {
-    fn from(err: MagnusError) -> Self {
-        Self::Ruby(MagnusErrorWrapper(err))
-    }
-}
-
-impl Into<MagnusError> for ReaderError {
-    fn into(self) -> MagnusError {
-        match self {
-            Self::Ruby(MagnusErrorWrapper(err)) => err.into(),
-            _ => MagnusError::new(magnus::exception::runtime_error(), self.to_string()),
-        }
-    }
-}

data/ext/parquet/src/reader/parquet_column_reader.rs

@@ -1,6 +1,6 @@
 use crate::header_cache::StringCache;
 use crate::logger::RubyLogger;
-use crate::types::{ArrayWrapper, TryIntoValue};
+use crate::types::{ArrayWrapper, ParquetGemError, TryIntoValue};
 use crate::{
     create_column_enumerator, utils::*, ColumnEnumeratorArgs, ColumnRecord, ParquetValueVec,
     ParserResultType,
@@ -10,25 +10,29 @@ use either::Either;
 use magnus::IntoValue;
 use magnus::{Error as MagnusError, Ruby, Value};
 use std::collections::HashMap;
-use std::sync::OnceLock;
+use std::sync::{Arc, OnceLock};
 
 use super::common::{
     create_batch_reader, handle_block_or_enum, handle_empty_file, open_parquet_source,
 };
-use super::ReaderError;
 
 #[inline]
 pub fn parse_parquet_columns<'a>(rb_self: Value, args: &[Value]) -> Result<Value, MagnusError> {
-    Ok(parse_parquet_columns_impl(rb_self, args).map_err(|e| {
-        let z: MagnusError = e.into();
-        z
-    })?)
+    let ruby = unsafe { Ruby::get_unchecked() };
+    Ok(
+        parse_parquet_columns_impl(Arc::new(ruby), rb_self, args).map_err(|e| {
+            let z: MagnusError = e.into();
+            z
+        })?,
+    )
 }
 
 #[inline]
-fn parse_parquet_columns_impl<'a>(rb_self: Value, args: &[Value]) -> Result<Value, ReaderError> {
-    let ruby = unsafe { Ruby::get_unchecked() };
-
+fn parse_parquet_columns_impl<'a>(
+    ruby: Arc<Ruby>,
+    rb_self: Value,
+    args: &[Value],
+) -> Result<Value, ParquetGemError> {
     let ParquetColumnsArgs {
         to_read,
         result_type,
@@ -63,7 +67,7 @@ fn parse_parquet_columns_impl<'a>(rb_self: Value, args: &[Value]) -> Result<Valu
         return Ok(enum_value);
     }
 
-    let source = open_parquet_source(to_read)?;
+    let source = open_parquet_source(ruby.clone(), to_read)?;
 
     // Use the common function to create the batch reader
 
@@ -82,7 +86,7 @@ fn parse_parquet_columns_impl<'a>(rb_self: Value, args: &[Value]) -> Result<Valu
             let headers = OnceLock::new();
             let headers_clone = headers.clone();
             let iter = batch_reader.map(move |batch| {
-                batch.map_err(ReaderError::Arrow).and_then(|batch| {
+                batch.map_err(ParquetGemError::Arrow).and_then(|batch| {
                     let local_headers = headers_clone
                         .get_or_init(|| {
                             let schema = batch.schema();
@@ -94,7 +98,7 @@ fn parse_parquet_columns_impl<'a>(rb_self: Value, args: &[Value]) -> Result<Valu
                             StringCache::intern_many(&header_string)
                         })
                         .as_ref()
-                        .map_err(|e| ReaderError::HeaderIntern(e.clone()))?;
+                        .map_err(|e| ParquetGemError::HeaderIntern(e.clone()))?;
 
                     let mut map = HashMap::with_capacity_and_hasher(
                         local_headers.len(),
@@ -112,7 +116,7 @@ fn parse_parquet_columns_impl<'a>(rb_self: Value, args: &[Value]) -> Result<Valu
                                 strict: strict,
                             })?;
                             map.insert(header, values.into_inner());
-                            Ok::<_, ReaderError>(())
+                            Ok::<_, ParquetGemError>(())
                         })?;
 
                     Ok(ColumnRecord::Map::<RandomState>(map))
@@ -126,7 +130,7 @@ fn parse_parquet_columns_impl<'a>(rb_self: Value, args: &[Value]) -> Result<Valu
         }
         ParserResultType::Array => {
             let iter = batch_reader.map(|batch| {
-                batch.map_err(ReaderError::Arrow).and_then(|batch| {
+                batch.map_err(ParquetGemError::Arrow).and_then(|batch| {
                     let vec = batch
                         .columns()
                         .into_iter()
@@ -135,7 +139,7 @@ fn parse_parquet_columns_impl<'a>(rb_self: Value, args: &[Value]) -> Result<Valu
                                 array: &*column,
                                 strict: strict,
                             })?;
-                            Ok::<_, ReaderError>(values.into_inner())
+                            Ok::<_, ParquetGemError>(values.into_inner())
                         })
                         .collect::<Result<Vec<_>, _>>()?;
                     Ok(ColumnRecord::Vec::<RandomState>(vec))

data/ext/parquet/src/reader/parquet_row_reader.rs

@@ -2,7 +2,7 @@ use crate::header_cache::StringCache;
 use crate::logger::RubyLogger;
 use crate::types::TryIntoValue;
 use crate::{
-    create_row_enumerator, utils::*, ParquetField, ParserResultType, ReaderError,
+    create_row_enumerator, utils::*, ParquetField, ParquetGemError, ParserResultType,
     RowEnumeratorArgs, RowRecord,
 };
 use ahash::RandomState;
@@ -13,22 +13,27 @@ use parquet::file::reader::{FileReader, SerializedFileReader};
 use parquet::record::reader::RowIter as ParquetRowIter;
 use parquet::schema::types::{Type as SchemaType, TypePtr};
 use std::collections::HashMap;
-use std::sync::OnceLock;
+use std::sync::{Arc, OnceLock};
 
 use super::common::{handle_block_or_enum, open_parquet_source};
 
 #[inline]
 pub fn parse_parquet_rows<'a>(rb_self: Value, args: &[Value]) -> Result<Value, MagnusError> {
-    Ok(parse_parquet_rows_impl(rb_self, args).map_err(|e| {
-        let z: MagnusError = e.into();
-        z
-    })?)
+    let ruby = unsafe { Ruby::get_unchecked() };
+    Ok(
+        parse_parquet_rows_impl(Arc::new(ruby), rb_self, args).map_err(|e| {
+            let z: MagnusError = e.into();
+            z
+        })?,
+    )
 }
 
 #[inline]
-fn parse_parquet_rows_impl<'a>(rb_self: Value, args: &[Value]) -> Result<Value, ReaderError> {
-    let ruby = unsafe { Ruby::get_unchecked() };
-
+fn parse_parquet_rows_impl<'a>(
+    ruby: Arc<Ruby>,
+    rb_self: Value,
+    args: &[Value],
+) -> Result<Value, ParquetGemError> {
     let ParquetRowsArgs {
         to_read,
         result_type,
@@ -58,11 +63,13 @@ fn parse_parquet_rows_impl<'a>(rb_self: Value, args: &[Value]) -> Result<Value,
         return Ok(enum_value);
     }
 
-    let source = open_parquet_source(to_read)?;
+    let source = open_parquet_source(ruby.clone(), to_read)?;
     let reader: Box<dyn FileReader> = match source {
-        Either::Left(file) => Box::new(SerializedFileReader::new(file).map_err(ReaderError::from)?),
+        Either::Left(file) => {
+            Box::new(SerializedFileReader::new(file).map_err(ParquetGemError::from)?)
+        }
         Either::Right(readable) => {
-            Box::new(SerializedFileReader::new(readable).map_err(ReaderError::from)?)
+            Box::new(SerializedFileReader::new(readable).map_err(ParquetGemError::from)?)
         }
     };
 
@@ -109,7 +116,7 @@ fn parse_parquet_rows_impl<'a>(rb_self: Value, args: &[Value]) -> Result<Value,
                     Ok(map)
                 })
                 .and_then(|row| Ok(RowRecord::Map::<RandomState>(row)))
-                .map_err(|e| ReaderError::from(e))
+                .map_err(|e| ParquetGemError::from(e))
             });
 
             for result in iter {
@@ -128,7 +135,7 @@ fn parse_parquet_rows_impl<'a>(rb_self: Value, args: &[Value]) -> Result<Value,
                     Ok(vec)
                 })
                 .and_then(|row| Ok(RowRecord::Vec::<RandomState>(row)))
-                .map_err(|e| ReaderError::from(e))
+                .map_err(|e| ParquetGemError::from(e))
             });
 
             for result in iter {

data/ext/parquet/src/ruby_reader.rs

@@ -13,14 +13,18 @@ use std::{
     sync::Arc,
 };
 
+use crate::types::ParquetGemError;
+
 /// A reader that can handle various Ruby input types (String, StringIO, IO-like objects)
 /// and provide a standard Read implementation for them.
 pub enum RubyReader {
     String {
+        ruby: Arc<Ruby>,
         inner: Opaque<RString>,
         offset: usize,
     },
     RubyIoLike {
+        ruby: Arc<Ruby>,
         inner: Opaque<Value>,
     },
     NativeProxyIoLike {
@@ -28,26 +32,15 @@ pub enum RubyReader {
     },
 }
 
-impl RubyReader {
-    fn is_io_like(value: &Value) -> bool {
-        value.respond_to("read", false).unwrap_or(false)
-    }
-
-    // For now, don't use this. Having to use seek in length is scary.
-    fn is_seekable_io_like(value: &Value) -> bool {
-        Self::is_io_like(value)
-            && value.respond_to("seek", false).unwrap_or(false)
-            && value.respond_to("pos", false).unwrap_or(false)
-    }
-}
-
-impl TryFrom<Value> for RubyReader {
-    type Error = magnus::Error;
+// Sending is technically not safe, but the only things that threatens to
+// do this is the parquet gem, and they don't seem to actually do it.
+unsafe impl Send for RubyReader {}
 
-    fn try_from(value: Value) -> Result<Self, Self::Error> {
-        let ruby = unsafe { Ruby::get_unchecked() };
+impl RubyReader {
+    pub fn new(ruby: Arc<Ruby>, value: Value) -> Result<Self, ParquetGemError> {
         if RubyReader::is_seekable_io_like(&value) {
             Ok(RubyReader::RubyIoLike {
+                ruby,
                 inner: Opaque::from(value),
             })
         } else if RubyReader::is_io_like(&value) {
@@ -56,6 +49,7 @@ impl TryFrom<Value> for RubyReader {
 
             // This is safe, because we won't call seek
             let inner_readable = RubyReader::RubyIoLike {
+                ruby: ruby.clone(),
                 inner: Opaque::from(value),
             };
             let mut reader = BufReader::new(inner_readable);
@@ -74,19 +68,31 @@ impl TryFrom<Value> for RubyReader {
                 .funcall::<_, _, RString>("to_str", ())
                 .or_else(|_| value.funcall::<_, _, RString>("to_s", ()))?;
             Ok(RubyReader::String {
+                ruby,
                 inner: Opaque::from(string_content),
                 offset: 0,
             })
         }
     }
+
+    fn is_io_like(value: &Value) -> bool {
+        value.respond_to("read", false).unwrap_or(false)
+    }
+
+    // For now, don't use this. Having to use seek in length is scary.
+    fn is_seekable_io_like(value: &Value) -> bool {
+        Self::is_io_like(value)
+            && value.respond_to("seek", false).unwrap_or(false)
+            && value.respond_to("pos", false).unwrap_or(false)
+    }
 }
 
 impl Seek for RubyReader {
     fn seek(&mut self, pos: io::SeekFrom) -> io::Result<u64> {
-        let ruby = unsafe { Ruby::get_unchecked() };
         match self {
             RubyReader::NativeProxyIoLike { proxy_file } => proxy_file.seek(pos),
             RubyReader::String {
+                ruby,
                 inner,
                 offset: original_offset,
             } => {
@@ -107,7 +113,7 @@ impl Seek for RubyReader {
                 *original_offset = new_offset.min(unwrapped_inner.len());
                 Ok(*original_offset as u64)
             }
-            RubyReader::RubyIoLike { inner } => {
+            RubyReader::RubyIoLike { ruby, inner } => {
                 let unwrapped_inner = ruby.get_inner(*inner);
 
                 let (whence, ruby_offset) = match pos {
@@ -132,10 +138,13 @@ impl Seek for RubyReader {
 
 impl Read for RubyReader {
     fn read(&mut self, mut buf: &mut [u8]) -> io::Result<usize> {
-        let ruby = unsafe { Ruby::get_unchecked() };
         match self {
             RubyReader::NativeProxyIoLike { proxy_file } => proxy_file.read(buf),
-            RubyReader::String { inner, offset } => {
+            RubyReader::String {
+                ruby,
+                inner,
+                offset,
+            } => {
                 let unwrapped_inner = ruby.get_inner(*inner);
 
                 let string_buffer = unsafe { unwrapped_inner.as_slice() };
@@ -151,7 +160,7 @@ impl Read for RubyReader {
 
                 Ok(copy_size)
             }
-            RubyReader::RubyIoLike { inner } => {
+            RubyReader::RubyIoLike { ruby, inner } => {
                 let unwrapped_inner = ruby.get_inner(*inner);
 
                 let bytes = unwrapped_inner
@@ -175,14 +184,17 @@ impl Read for RubyReader {
 
 impl Length for RubyReader {
     fn len(&self) -> u64 {
-        let ruby = unsafe { Ruby::get_unchecked() };
         match self {
             RubyReader::NativeProxyIoLike { proxy_file } => proxy_file.len(),
-            RubyReader::String { inner, offset: _ } => {
+            RubyReader::String {
+                ruby,
+                inner,
+                offset: _,
+            } => {
                 let unwrapped_inner = ruby.get_inner(*inner);
                 unwrapped_inner.len() as u64
             }
-            RubyReader::RubyIoLike { inner } => {
+            RubyReader::RubyIoLike { ruby, inner } => {
                 let unwrapped_inner = ruby.get_inner(*inner);
 
                 // Get current position

data/ext/parquet/src/types/core_types.rs

@@ -62,22 +62,7 @@ pub struct StructField<'a> {
 
 #[derive(Clone, Debug)]
 pub enum ParquetSchemaType<'a> {
-    Int8,
-    Int16,
-    Int32,
-    Int64,
-    UInt8,
-    UInt16,
-    UInt32,
-    UInt64,
-    Float,
-    Double,
-    String,
-    Binary,
-    Boolean,
-    Date32,
-    TimestampMillis,
-    TimestampMicros,
+    Primitive(PrimitiveType),
     List(Box<ListField<'a>>),
     Map(Box<MapField<'a>>),
     Struct(Box<StructField<'a>>),
@@ -110,7 +95,7 @@ pub enum SchemaNode {
     },
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
 pub enum PrimitiveType {
     Int8,
     Int16,

data/ext/parquet/src/types/mod.rs

@@ -35,3 +35,59 @@ use parquet::record::Field;
 use std::{collections::HashMap, hash::BuildHasher, sync::Arc};
 
 use crate::header_cache::StringCacheKey;
+
+use crate::header_cache::CacheError;
+
+use std::io;
+
+use thiserror::Error;
+
+#[derive(Error, Debug)]
+pub enum ParquetGemError {
+    #[error("Failed to open file: {0}")]
+    FileOpen(#[from] io::Error),
+    #[error("Failed to intern headers: {0}")]
+    HeaderIntern(#[from] CacheError),
+    #[error("Ruby error: {0}")]
+    Ruby(#[from] MagnusErrorWrapper),
+    #[error("Parquet error: {0}")]
+    Parquet(#[from] parquet::errors::ParquetError),
+    #[error("Arrow error: {0}")]
+    Arrow(#[from] arrow_schema::ArrowError),
+    #[error("UTF-8 error: {0}")]
+    Utf8Error(#[from] simdutf8::basic::Utf8Error),
+    #[error("Jiff error: {0}")]
+    Jiff(#[from] jiff::Error),
+}
+
+#[derive(Debug)]
+pub struct MagnusErrorWrapper(pub MagnusError);
+
+impl From<MagnusError> for MagnusErrorWrapper {
+    fn from(err: MagnusError) -> Self {
+        Self(err)
+    }
+}
+
+impl std::fmt::Display for MagnusErrorWrapper {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
+impl std::error::Error for MagnusErrorWrapper {}
+
+impl From<MagnusError> for ParquetGemError {
+    fn from(err: MagnusError) -> Self {
+        Self::Ruby(MagnusErrorWrapper(err))
+    }
+}
+
+impl Into<MagnusError> for ParquetGemError {
+    fn into(self) -> MagnusError {
+        match self {
+            Self::Ruby(MagnusErrorWrapper(err)) => err.into(),
+            _ => MagnusError::new(magnus::exception::runtime_error(), self.to_string()),
+        }
+    }
+}