parquet 0.5.10 → 0.5.12

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

@@ -1,4 +1,107 @@
 use super::*;
+use magnus::{TryConvert, Value};
+
+/// Parses a fixed offset timezone string (e.g., "+09:00", "-05:30", "+0800")
+/// Returns the offset in minutes from UTC
+fn parse_fixed_offset(tz: &str) -> Result<i32, ParquetGemError> {
+    // Remove any whitespace
+    let tz = tz.trim();
+
+    // Check if it starts with + or -
+    if !tz.starts_with('+') && !tz.starts_with('-') {
+        return Err(MagnusError::new(
+            magnus::exception::arg_error(),
+            format!(
+                "Invalid timezone offset format: '{}'. Expected format like '+09:00' or '-0530'",
+                tz
+            ),
+        ))?;
+    }
+
+    let sign = if tz.starts_with('-') { -1 } else { 1 };
+    let offset_str = &tz[1..]; // Remove the sign
+
+    // Parse different formats: "+09:00", "+0900", "+09"
+    let (hours, minutes) = if offset_str.contains(':') {
+        // Format: "+09:00" or "+9:30"
+        let parts: Vec<&str> = offset_str.split(':').collect();
+        if parts.len() != 2 {
+            return Err(MagnusError::new(
+                magnus::exception::arg_error(),
+                format!("Invalid timezone offset format: '{}'. Expected HH:MM", tz),
+            ))?;
+        }
+
+        let h = parts[0].parse::<i32>().map_err(|e| {
+            MagnusError::new(
+                magnus::exception::arg_error(),
+                format!("Invalid hour in timezone offset '{}': {}", tz, e),
+            )
+        })?;
+
+        let m = parts[1].parse::<i32>().map_err(|e| {
+            MagnusError::new(
+                magnus::exception::arg_error(),
+                format!("Invalid minute in timezone offset '{}': {}", tz, e),
+            )
+        })?;
+
+        (h, m)
+    } else if offset_str.len() == 4 {
+        // Format: "+0900"
+        let h = offset_str[0..2].parse::<i32>().map_err(|e| {
+            MagnusError::new(
+                magnus::exception::arg_error(),
+                format!("Invalid hour in timezone offset '{}': {}", tz, e),
+            )
+        })?;
+
+        let m = offset_str[2..4].parse::<i32>().map_err(|e| {
+            MagnusError::new(
+                magnus::exception::arg_error(),
+                format!("Invalid minute in timezone offset '{}': {}", tz, e),
+            )
+        })?;
+
+        (h, m)
+    } else if offset_str.len() == 2
+        || (offset_str.len() == 1 && offset_str.chars().all(|c| c.is_numeric()))
+    {
+        // Format: "+09" or "+9"
+        let h = offset_str.parse::<i32>().map_err(|e| {
+            MagnusError::new(
+                magnus::exception::arg_error(),
+                format!("Invalid hour in timezone offset '{}': {}", tz, e),
+            )
+        })?;
+        (h, 0)
+    } else {
+        return Err(MagnusError::new(
+            magnus::exception::arg_error(),
+            format!("Invalid timezone offset format: '{}'. Expected formats: '+HH:MM', '+HHMM', or '+HH'", tz),
+        ))?;
+    };
+
+    // Validate ranges
+    if hours < 0 || hours > 23 {
+        return Err(MagnusError::new(
+            magnus::exception::arg_error(),
+            format!("Invalid hour in timezone offset: {}. Must be 0-23", hours),
+        ))?;
+    }
+
+    if minutes < 0 || minutes > 59 {
+        return Err(MagnusError::new(
+            magnus::exception::arg_error(),
+            format!(
+                "Invalid minute in timezone offset: {}. Must be 0-59",
+                minutes
+            ),
+        ))?;
+    }
+
+    Ok(sign * (hours * 60 + minutes))
+}
 
 pub fn parse_zoned_timestamp(value: &ParquetValue) -> Result<jiff::Timestamp, ParquetGemError> {
     let (ts, tz) = match value {
@@ -18,37 +121,40 @@ pub fn parse_zoned_timestamp(value: &ParquetValue) -> Result<jiff::Timestamp, Pa
 
     // If timezone is provided, convert to zoned timestamp
     if let Some(tz) = tz {
-        // Handle fixed offset timezones like "+09:00" first
+        // Handle fixed offset timezones first
         if tz.starts_with('+') || tz.starts_with('-') {
-            // Parse the offset string into hours and minutes
-            let (hours, minutes) = if tz.len() >= 5 && tz.contains(':') {
-                // Format: "+09:00" or "-09:00"
-                let h = tz[1..3].parse::<i32>().unwrap_or(0);
-                let m = tz[4..6].parse::<i32>().unwrap_or(0);
-                (h, m)
-            } else if tz.len() >= 3 {
-                // Format: "+09" or "-09"
-                let h = tz[1..3].parse::<i32>().unwrap_or(0);
-                (h, 0)
-            } else {
-                (0, 0)
-            };
+            let total_minutes = parse_fixed_offset(tz)?;
+
+            // Create fixed timezone using the parsed offset
+            let offset_hours = total_minutes / 60;
+            let offset_minutes = total_minutes % 60;
 
-            // Apply sign
-            let total_minutes = if tz.starts_with('-') {
-                -(hours * 60 + minutes)
+            // jiff expects offset in hours, but we can be more precise
+            let tz = if offset_minutes == 0 {
+                jiff::tz::TimeZone::fixed(jiff::tz::offset(offset_hours as i8))
             } else {
-                hours * 60 + minutes
+                // For non-zero minutes, we need to create a custom offset
+                // jiff doesn't directly support minute-precision offsets in the simple API,
+                // so we'll use the timestamp directly with the offset applied
+                return Ok(ts);
             };
 
-            // Create fixed timezone
-            let tz = jiff::tz::TimeZone::fixed(jiff::tz::offset((total_minutes / 60) as i8));
             Ok(ts.to_zoned(tz).timestamp())
+        } else if tz.eq_ignore_ascii_case("UTC") || tz.eq_ignore_ascii_case("GMT") {
+            // Common UTC aliases
+            Ok(ts)
         } else {
             // Try IANA timezone
             match ts.in_tz(tz) {
                 Ok(zoned) => Ok(zoned.timestamp()),
-                Err(_) => Ok(ts), // Fall back to UTC if timezone is invalid
+                Err(e) => {
+                    // Log the error but don't fail - fall back to UTC
+                    eprintln!(
+                        "Warning: Failed to parse timezone '{}': {}. Using UTC.",
+                        tz, e
+                    );
+                    Ok(ts)
+                }
             }
         }
     } else {
@@ -57,21 +163,112 @@ pub fn parse_zoned_timestamp(value: &ParquetValue) -> Result<jiff::Timestamp, Pa
     }
 }
 
+/// Validates and normalizes a timezone string
+/// Returns the normalized timezone string or None if invalid
+pub fn validate_timezone(tz: &str) -> Option<String> {
+    let tz = tz.trim();
+
+    // Check for empty timezone
+    if tz.is_empty() {
+        return None;
+    }
+
+    // Fixed offset timezones
+    if tz.starts_with('+') || tz.starts_with('-') {
+        // Validate it can be parsed
+        if parse_fixed_offset(tz).is_ok() {
+            return Some(tz.to_string());
+        }
+    }
+
+    // Common UTC aliases
+    if tz.eq_ignore_ascii_case("UTC")
+        || tz.eq_ignore_ascii_case("GMT")
+        || tz.eq_ignore_ascii_case("Z")
+    {
+        return Some("UTC".to_string());
+    }
+
+    // Try to validate as IANA timezone by attempting to use it
+    // This is a bit expensive but ensures we only store valid timezones
+    if let Ok(tz_obj) = jiff::tz::TimeZone::get(tz) {
+        // Use the canonical name from jiff
+        return Some(
+            tz_obj
+                .iana_name()
+                .map(|s| s.to_string())
+                .unwrap_or_else(|| tz.to_string()),
+        );
+    }
+
+    None
+}
+
+/// Converts a Ruby Time object to a timestamp with timezone
+pub fn ruby_time_to_timestamp_with_tz(
+    value: Value,
+    unit: &str,
+) -> Result<(i64, Option<Arc<str>>), MagnusError> {
+    // Get seconds and microseconds
+    let secs = i64::try_convert(value.funcall::<_, _, Value>("to_i", ())?)?;
+    let usecs = i64::try_convert(value.funcall::<_, _, Value>("usec", ())?)?;
+
+    // Get timezone information from Ruby Time object
+    let tz_str = if let Ok(zone) = value.funcall::<_, _, Value>("zone", ()) {
+        if zone.is_nil() {
+            None
+        } else if let Ok(s) = String::try_convert(zone) {
+            validate_timezone(&s).map(|tz| Arc::from(tz.as_str()))
+        } else {
+            None
+        }
+    } else {
+        None
+    };
+
+    // Convert to appropriate unit
+    let timestamp = match unit {
+        "millis" => secs * 1000 + (usecs / 1000),
+        "micros" => secs * 1_000_000 + usecs,
+        "seconds" => secs,
+        "nanos" => secs * 1_000_000_000 + (usecs * 1000),
+        _ => {
+            return Err(MagnusError::new(
+                magnus::exception::arg_error(),
+                format!("Invalid timestamp unit: {}", unit),
+            ))
+        }
+    };
+
+    Ok((timestamp, tz_str))
+}
+
 // Macro for handling timestamp conversions
 #[macro_export]
 macro_rules! impl_timestamp_conversion {
     ($value:expr, $unit:ident, $handle:expr) => {{
         match $value {
             ParquetValue::$unit(ts, tz) => {
-                let ts = parse_zoned_timestamp(&ParquetValue::$unit(ts, tz))?;
+                let ts = parse_zoned_timestamp(&ParquetValue::$unit(ts, tz.clone()))?;
                 let time_class = $handle.class_time();
-                Ok(time_class
+
+                // Convert timestamp to Time object
+                let time_obj = time_class
                     .funcall::<_, _, Value>("parse", (ts.to_string(),))?
-                    .into_value_with($handle))
+                    .into_value_with($handle);
+
+                // If we have timezone info, we've already handled it in parse_zoned_timestamp
+                // The resulting Time object will be in the correct timezone
+
+                Ok(time_obj)
             }
             _ => Err(MagnusError::new(
                 magnus::exception::type_error(),
-                "Invalid timestamp type".to_string(),
+                format!(
+                    "Invalid timestamp type. Expected {}, got {:?}",
+                    stringify!($unit),
+                    $value
+                ),
             ))?,
         }
     }};

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

@@ -250,6 +250,8 @@ pub fn parquet_schema_type_to_arrow_data_type(
             PrimitiveType::Date32 => DataType::Date32,
             PrimitiveType::TimestampMillis => DataType::Timestamp(TimeUnit::Millisecond, None),
             PrimitiveType::TimestampMicros => DataType::Timestamp(TimeUnit::Microsecond, None),
+            PrimitiveType::TimeMillis => DataType::Time32(TimeUnit::Millisecond),
+            PrimitiveType::TimeMicros => DataType::Time64(TimeUnit::Microsecond),
         },
         // For a List<T>, create a standard List in Arrow with nullable items
         ParquetSchemaType::List(list_field) => {
@@ -416,6 +418,12 @@ fn create_arrow_builder_for_type(
         ParquetSchemaType::Primitive(PrimitiveType::TimestampMicros) => {
             Ok(Box::new(TimestampMicrosecondBuilder::with_capacity(cap)))
         }
+        ParquetSchemaType::Primitive(PrimitiveType::TimeMillis) => {
+            Ok(Box::new(Time32MillisecondBuilder::with_capacity(cap)))
+        }
+        ParquetSchemaType::Primitive(PrimitiveType::TimeMicros) => {
+            Ok(Box::new(Time64MicrosecondBuilder::with_capacity(cap)))
+        }
         ParquetSchemaType::List(list_field) => {
             // For a list, we create a ListBuilder whose child builder is determined by item_type.
             // Pass through capacity to ensure consistent sizing
@@ -1165,6 +1173,44 @@ fn fill_builder(
             }
             Ok(())
         }
+        ParquetSchemaType::Primitive(PrimitiveType::TimeMillis) => {
+            let typed_builder = builder
+                .as_any_mut()
+                .downcast_mut::<Time32MillisecondBuilder>()
+                .expect("Builder mismatch: expected Time32MillisecondBuilder");
+            for val in values {
+                match val {
+                    ParquetValue::TimeMillis(t) => typed_builder.append_value(*t),
+                    ParquetValue::Null => typed_builder.append_null(),
+                    other => {
+                        return Err(MagnusError::new(
+                            magnus::exception::type_error(),
+                            format!("Expected TimeMillis, got {:?}", other),
+                        ))
+                    }
+                }
+            }
+            Ok(())
+        }
+        ParquetSchemaType::Primitive(PrimitiveType::TimeMicros) => {
+            let typed_builder = builder
+                .as_any_mut()
+                .downcast_mut::<Time64MicrosecondBuilder>()
+                .expect("Builder mismatch: expected Time64MicrosecondBuilder");
+            for val in values {
+                match val {
+                    ParquetValue::TimeMicros(t) => typed_builder.append_value(*t),
+                    ParquetValue::Null => typed_builder.append_null(),
+                    other => {
+                        return Err(MagnusError::new(
+                            magnus::exception::type_error(),
+                            format!("Expected TimeMicros, got {:?}", other),
+                        ))
+                    }
+                }
+            }
+            Ok(())
+        }
 
         // ------------------
         // NESTED LIST - using helper function
@@ -1433,6 +1479,24 @@ fn fill_builder(
                                             )
                                         })?
                                         .append_value(*x),
+                                    ParquetValue::TimeMillis(x) => typed_builder
+                                        .field_builder::<Time32MillisecondBuilder>(i)
+                                        .ok_or_else(|| {
+                                            MagnusError::new(
+                                                magnus::exception::type_error(),
+                                                "Failed to coerce into Time32MillisecondBuilder",
+                                            )
+                                        })?
+                                        .append_value(*x),
+                                    ParquetValue::TimeMicros(x) => typed_builder
+                                        .field_builder::<Time64MicrosecondBuilder>(i)
+                                        .ok_or_else(|| {
+                                            MagnusError::new(
+                                                magnus::exception::type_error(),
+                                                "Failed to coerce into Time64MicrosecondBuilder",
+                                            )
+                                        })?
+                                        .append_value(*x),
                                     ParquetValue::List(items) => {
                                         let list_builder = typed_builder
                                             .field_builder::<ListBuilder<Box<dyn ArrayBuilder>>>(i)
@@ -1647,6 +1711,24 @@ fn fill_builder(
                                                 )
                                             })?
                                             .append_null(),
+                                        ParquetSchemaType::Primitive(PrimitiveType::TimeMillis) => typed_builder
+                                            .field_builder::<Time32MillisecondBuilder>(i)
+                                            .ok_or_else(|| {
+                                                MagnusError::new(
+                                                    magnus::exception::type_error(),
+                                                    "Failed to coerce into Time32MillisecondBuilder",
+                                                )
+                                            })?
+                                            .append_null(),
+                                        ParquetSchemaType::Primitive(PrimitiveType::TimeMicros) => typed_builder
+                                            .field_builder::<Time64MicrosecondBuilder>(i)
+                                            .ok_or_else(|| {
+                                                MagnusError::new(
+                                                    magnus::exception::type_error(),
+                                                    "Failed to coerce into Time64MicrosecondBuilder",
+                                                )
+                                            })?
+                                            .append_null(),
                                         ParquetSchemaType::List(_) => typed_builder
                                             .field_builder::<ListBuilder<Box<dyn ArrayBuilder>>>(i)
                                             .ok_or_else(|| {
@@ -1743,3 +1825,125 @@ pub fn convert_ruby_array_to_arrow(
     }
     convert_parquet_values_to_arrow(parquet_values, type_)
 }
+
+pub fn convert_to_time_millis(
+    ruby: &Ruby,
+    value: Value,
+    format: Option<&str>,
+) -> Result<i32, MagnusError> {
+    if value.is_kind_of(ruby.class_time()) {
+        // Extract time components
+        let hour = i32::try_convert(value.funcall::<_, _, Value>("hour", ())?)?;
+        let min = i32::try_convert(value.funcall::<_, _, Value>("min", ())?)?;
+        let sec = i32::try_convert(value.funcall::<_, _, Value>("sec", ())?)?;
+        let usec = i32::try_convert(value.funcall::<_, _, Value>("usec", ())?)?;
+
+        // Convert to milliseconds since midnight
+        Ok(hour * 3600000 + min * 60000 + sec * 1000 + usec / 1000)
+    } else if value.is_kind_of(ruby.class_string()) {
+        let s = String::try_convert(value)?;
+
+        if let Some(fmt) = format {
+            // Parse using the provided format
+            match jiff::civil::Time::strptime(fmt, &s) {
+                Ok(time) => {
+                    let millis = time.hour() as i32 * 3600000
+                        + time.minute() as i32 * 60000
+                        + time.second() as i32 * 1000
+                        + time.millisecond() as i32;
+                    Ok(millis)
+                }
+                Err(e) => Err(MagnusError::new(
+                    magnus::exception::type_error(),
+                    format!(
+                        "Failed to parse '{}' with format '{}' as time: {}",
+                        s, fmt, e
+                    ),
+                )),
+            }
+        } else {
+            // Try to parse as standard time format
+            match s.parse::<jiff::civil::Time>() {
+                Ok(time) => {
+                    let millis = time.hour() as i32 * 3600000
+                        + time.minute() as i32 * 60000
+                        + time.second() as i32 * 1000
+                        + time.millisecond() as i32;
+                    Ok(millis)
+                }
+                Err(e) => Err(MagnusError::new(
+                    magnus::exception::type_error(),
+                    format!("Failed to parse '{}' as time: {}", s, e),
+                )),
+            }
+        }
+    } else {
+        Err(MagnusError::new(
+            magnus::exception::type_error(),
+            format!("Cannot convert {} to time_millis", unsafe {
+                value.classname()
+            }),
+        ))
+    }
+}
+
+pub fn convert_to_time_micros(
+    ruby: &Ruby,
+    value: Value,
+    format: Option<&str>,
+) -> Result<i64, MagnusError> {
+    if value.is_kind_of(ruby.class_time()) {
+        // Extract time components
+        let hour = i64::try_convert(value.funcall::<_, _, Value>("hour", ())?)?;
+        let min = i64::try_convert(value.funcall::<_, _, Value>("min", ())?)?;
+        let sec = i64::try_convert(value.funcall::<_, _, Value>("sec", ())?)?;
+        let usec = i64::try_convert(value.funcall::<_, _, Value>("usec", ())?)?;
+
+        // Convert to microseconds since midnight
+        Ok(hour * 3600000000 + min * 60000000 + sec * 1000000 + usec)
+    } else if value.is_kind_of(ruby.class_string()) {
+        let s = String::try_convert(value)?;
+
+        if let Some(fmt) = format {
+            // Parse using the provided format
+            match jiff::civil::Time::strptime(fmt, &s) {
+                Ok(time) => {
+                    let micros = time.hour() as i64 * 3600000000
+                        + time.minute() as i64 * 60000000
+                        + time.second() as i64 * 1000000
+                        + time.microsecond() as i64;
+                    Ok(micros)
+                }
+                Err(e) => Err(MagnusError::new(
+                    magnus::exception::type_error(),
+                    format!(
+                        "Failed to parse '{}' with format '{}' as time: {}",
+                        s, fmt, e
+                    ),
+                )),
+            }
+        } else {
+            // Try to parse as standard time format
+            match s.parse::<jiff::civil::Time>() {
+                Ok(time) => {
+                    let micros = time.hour() as i64 * 3600000000
+                        + time.minute() as i64 * 60000000
+                        + time.second() as i64 * 1000000
+                        + time.microsecond() as i64;
+                    Ok(micros)
+                }
+                Err(e) => Err(MagnusError::new(
+                    magnus::exception::type_error(),
+                    format!("Failed to parse '{}' as time: {}", s, e),
+                )),
+            }
+        }
+    } else {
+        Err(MagnusError::new(
+            magnus::exception::type_error(),
+            format!("Cannot convert {} to time_micros", unsafe {
+                value.classname()
+            }),
+        ))
+    }
+}

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

@@ -146,7 +146,10 @@ impl FromStr for ParquetSchemaType<'_> {
         }
 
         // Check if it's a decimal256 type with precision and scale
-        if let Some(decimal_params) = s.strip_prefix("decimal256(").and_then(|s| s.strip_suffix(")")) {
+        if let Some(decimal_params) = s
+            .strip_prefix("decimal256(")
+            .and_then(|s| s.strip_suffix(")"))
+        {
             let parts: Vec<&str> = decimal_params.split(',').collect();
 
             // Handle both single parameter (precision only) and two parameters (precision and scale)
@@ -210,6 +213,8 @@ impl FromStr for ParquetSchemaType<'_> {
             "date32" => Ok(ParquetSchemaType::Primitive(PrimitiveType::Date32)),
             "timestamp_millis" => Ok(ParquetSchemaType::Primitive(PrimitiveType::TimestampMillis)),
             "timestamp_micros" => Ok(ParquetSchemaType::Primitive(PrimitiveType::TimestampMicros)),
+            "time_millis" => Ok(ParquetSchemaType::Primitive(PrimitiveType::TimeMillis)),
+            "time_micros" => Ok(ParquetSchemaType::Primitive(PrimitiveType::TimeMicros)),
             "decimal" => Ok(ParquetSchemaType::Primitive(PrimitiveType::Decimal128(
                 38, 0,
             ))),

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

@@ -230,6 +230,16 @@ fn arrow_data_type_to_parquet_schema_type(dt: &DataType) -> Result<ParquetSchema
                 "TimestampNanos not supported, please adjust your schema or code.",
             ))
         }
+        DataType::Time32(TimeUnit::Millisecond) => Ok(PST::Primitive(PrimitiveType::TimeMillis)),
+        DataType::Time64(TimeUnit::Microsecond) => Ok(PST::Primitive(PrimitiveType::TimeMicros)),
+        DataType::Time32(_) => Err(MagnusError::new(
+            magnus::exception::runtime_error(),
+            "Time32 only supports millisecond unit",
+        )),
+        DataType::Time64(_) => Err(MagnusError::new(
+            magnus::exception::runtime_error(),
+            "Time64 only supports microsecond unit",
+        )),
         DataType::Utf8 => Ok(PST::Primitive(PrimitiveType::String)),
         DataType::Binary => Ok(PST::Primitive(PrimitiveType::Binary)),
         DataType::LargeUtf8 => {

data/ext/parquet/src/writer/write_columns.rs

@@ -170,6 +170,12 @@ fn write_columns_impl(ruby: Rc<Ruby>, args: &[Value]) -> Result<(), ParquetGemEr
                                     PrimitiveType::TimestampMicros => {
                                         PST::Primitive(PrimitiveType::TimestampMicros)
                                     }
+                                    PrimitiveType::TimeMillis => {
+                                        PST::Primitive(PrimitiveType::TimeMillis)
+                                    }
+                                    PrimitiveType::TimeMicros => {
+                                        PST::Primitive(PrimitiveType::TimeMicros)
+                                    }
                                     PrimitiveType::Decimal256(precision, scale) => {
                                         PST::Primitive(PrimitiveType::Decimal256(precision, scale))
                                     }

data/ext/parquet/src/writer/write_rows.rs

@@ -259,9 +259,11 @@ pub fn estimate_value_size(
         PST::Primitive(PrimitiveType::Boolean) => Ok(1),
         PST::Primitive(PrimitiveType::Decimal128(_, _)) => Ok(16),
         PST::Primitive(PrimitiveType::Decimal256(_, _)) => Ok(32),
-        PST::Primitive(PrimitiveType::Date32)
-        | PST::Primitive(PrimitiveType::TimestampMillis)
-        | PST::Primitive(PrimitiveType::TimestampMicros) => Ok(8),
+        PST::Primitive(PrimitiveType::Date32) => Ok(4), // Date32 is 4 bytes
+        PST::Primitive(PrimitiveType::TimestampMillis)
+        | PST::Primitive(PrimitiveType::TimestampMicros) => Ok(8), // Timestamps are 8 bytes
+        PST::Primitive(PrimitiveType::TimeMillis) => Ok(4), // TimeMillis is 4 bytes
+        PST::Primitive(PrimitiveType::TimeMicros) => Ok(8), // TimeMicros is 8 bytes
         PST::Primitive(PrimitiveType::String) | PST::Primitive(PrimitiveType::Binary) => {
             if let Ok(s) = String::try_convert(value) {
                 // Account for string length plus Rust String's capacity+pointer overhead

data/lib/parquet/version.rb

@@ -1,3 +1,3 @@
 module Parquet
-  VERSION = "0.5.10"
+  VERSION = "0.5.12"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: parquet
 version: !ruby/object:Gem::Version
-  version: 0.5.10
+  version: 0.5.12
 platform: ruby
 authors:
 - Nathan Jaremko
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-06-17 00:00:00.000000000 Z
+date: 2025-06-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rb_sys
@@ -62,9 +62,7 @@ files:
 - ext/parquet/src/header_cache.rs
 - ext/parquet/src/lib.rs
 - ext/parquet/src/logger.rs
-- ext/parquet/src/reader/arrow_reader.rs
 - ext/parquet/src/reader/common.rs
-- ext/parquet/src/reader/format_detector.rs
 - ext/parquet/src/reader/mod.rs
 - ext/parquet/src/reader/parquet_column_reader.rs
 - ext/parquet/src/reader/parquet_row_reader.rs