parquet 0.6.2 → 0.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dfd19103b2414e7feeaa6d1ec3c9a9c25ce42cf5c8362baa37e3b9d8d5245f82
-  data.tar.gz: c5c1170dbdc3635577738a568688c36adc9670710f4b0d570fae29294e337754
+  metadata.gz: c1f3c1598e0557dfbf9ea851624342aa4e04865b3d84c4125617b17e7e3f016a
+  data.tar.gz: 00aeec0e5d3db34d6d405492d69ca1f5ba0a6398796fcdce1a7f8676784d3fe9
 SHA512:
-  metadata.gz: c9bf72b4e708c750ab7ae30afd97aef7f456a4249904fe3eb74f916557e28ca1a53bc262a6492db38c38162ab3e3f684e30f0c70dabbaf8f8f4145ef4d9af259
-  data.tar.gz: 164c5b0569d3d13242bcff7c09d66edf67b279d8289f97def043000a508b4333dd1387a4f47517be09023cd270cf3b6dfd57fdf658ac1b52e25f3f5b2b5ca30c
+  metadata.gz: 03b488f3cc83e31d8cd9bc61f67c3c7234837c2a0f7f2262b563fdc5094148f66072d3a748a37cda8fc74de8d37f63457d0c5cc63b7f83e6993e0c8f4d504462
+  data.tar.gz: 6a11d5c74536784fb96421d3c46da9608e30b77e42adbe60eb43b6fad96750d75b194b7243383bf512f32b0a9af3c10ddc27652bffdcf54b546245a2faa53ac5

data/ext/parquet-core/src/arrow_conversion.rs

@@ -208,12 +208,14 @@ pub fn arrow_to_parquet_value(
 
             let key_field = map_value
                 .fields()
-                .iter().find(|f| f.name() == "key")
+                .iter()
+                .find(|f| f.name() == "key")
                 .ok_or_else(|| ParquetError::Conversion("No value field found".to_string()))?;
 
             let value_field = map_value
                 .fields()
-                .iter().find(|f| f.name() == "value")
+                .iter()
+                .find(|f| f.name() == "value")
                 .ok_or_else(|| ParquetError::Conversion("No value field found".to_string()))?;
 
             let mut map_vec = Vec::with_capacity(keys.len());

data/ext/parquet-ruby-adapter/src/converter.rs

@@ -4,13 +4,14 @@ use indexmap::IndexMap;
 use magnus::r_hash::ForEach;
 use magnus::value::ReprValue;
 use magnus::{
-    Error as MagnusError, IntoValue, Module, RArray, RHash, RString, Ruby, Symbol, TryConvert,
-    Value,
+    kwargs, Error as MagnusError, IntoValue, Module, RArray, RHash, RString, Ruby, Symbol,
+    TryConvert, Value,
 };
 use ordered_float::OrderedFloat;
 use parquet_core::{ParquetError, ParquetValue, Result};
 use std::cell::RefCell;
 use std::sync::Arc;
+use uuid::Uuid;
 
 /// Ruby value converter
 ///
@@ -1394,11 +1395,64 @@ pub fn parquet_to_ruby(value: ParquetValue) -> Result<Value> {
         ParquetValue::UInt16(i) => Ok((i as u64).into_value_with(&ruby)),
         ParquetValue::UInt32(i) => Ok((i as u64).into_value_with(&ruby)),
         ParquetValue::UInt64(i) => Ok(i.into_value_with(&ruby)),
-        ParquetValue::Float16(OrderedFloat(f)) => Ok((f as f64).into_value_with(&ruby)),
-        ParquetValue::Float32(OrderedFloat(f)) => Ok((f as f64).into_value_with(&ruby)),
+        ParquetValue::Float16(OrderedFloat(f)) => {
+            let cleaned = {
+                // Fast-path the specials.
+                if f.is_nan() || f.is_infinite() {
+                    f as f64
+                } else if f == 0.0 {
+                    // Keep the IEEE-754 sign bit for −0.0.
+                    if f.is_sign_negative() {
+                        -0.0
+                    } else {
+                        0.0
+                    }
+                } else {
+                    // `to_string` gives the shortest exact, round-trippable decimal.
+                    // Parsing it back to `f64` cannot fail, but fall back defensively.
+                    match f.to_string().parse::<f64>() {
+                        Ok(v) => v,
+                        Err(e) => {
+                            dbg!(e);
+                            f as f64
+                        } // extremely unlikely
+                    }
+                }
+            };
+            Ok(cleaned.into_value_with(&ruby))
+        }
+        ParquetValue::Float32(OrderedFloat(f)) => {
+            let cleaned = {
+                // Fast-path the specials.
+                if f.is_nan() || f.is_infinite() {
+                    f as f64
+                } else if f == 0.0 {
+                    // Keep the IEEE-754 sign bit for −0.0.
+                    if f.is_sign_negative() {
+                        -0.0
+                    } else {
+                        0.0
+                    }
+                } else {
+                    // `to_string` gives the shortest exact, round-trippable decimal.
+                    // Parsing it back to `f64` cannot fail, but fall back defensively.
+                    match f.to_string().parse::<f64>() {
+                        Ok(v) => v,
+                        Err(e) => {
+                            dbg!(e);
+                            f as f64
+                        } // extremely unlikely
+                    }
+                }
+            };
+            Ok(cleaned.into_value_with(&ruby))
+        }
         ParquetValue::Float64(OrderedFloat(f)) => Ok(f.into_value_with(&ruby)),
         ParquetValue::String(s) => Ok(s.into_value_with(&ruby)),
-        ParquetValue::Uuid(u) => Ok(u.to_string().into_value_with(&ruby)),
+        ParquetValue::Uuid(u) => Ok(u
+            .hyphenated()
+            .encode_lower(&mut Uuid::encode_buffer())
+            .into_value_with(&ruby)),
         ParquetValue::Bytes(b) => Ok(ruby.enc_str_new(&b, ruby.ascii8bit_encoding()).as_value()),
         ParquetValue::Date32(days) => {
             // Convert days since epoch to Date object
@@ -1489,10 +1543,26 @@ pub fn parquet_to_ruby(value: ParquetValue) -> Result<Value> {
                 .funcall("utc", (year, month, day, hours, minutes, seconds, us))
                 .map_err(|e| ParquetError::Conversion(e.to_string()))
         }
+        ParquetValue::TimeNanos(nanos) => {
+            let time_class = ruby.class_time();
+            let secs = nanos / 1_000_000_000;
+            let nsec = nanos % 1_000_000_000;
+            time_class
+                .funcall(
+                    "at",
+                    (
+                        secs,
+                        nsec,
+                        Symbol::new("nanosecond"),
+                        kwargs!("in" => "UTC"),
+                    ),
+                )
+                .map_err(|e| ParquetError::Conversion(e.to_string()))
+        }
         ParquetValue::TimestampSecond(secs, tz) => {
             let time_class = ruby.class_time();
             let time = time_class
-                .funcall::<_, _, Value>("at", (secs,))
+                .funcall::<_, _, Value>("at", (secs, kwargs!("in" => "UTC")))
                 .map_err(|e| ParquetError::Conversion(e.to_string()))?;
             apply_timezone(time, &tz)
         }
@@ -1501,7 +1571,7 @@ pub fn parquet_to_ruby(value: ParquetValue) -> Result<Value> {
             let secs = millis / 1000;
             let usec = (millis % 1000) * 1000; // Convert millisecond remainder to microseconds
             let time = time_class
-                .funcall::<_, _, Value>("at", (secs, usec))
+                .funcall::<_, _, Value>("at", (secs, usec, kwargs!("in" => "UTC")))
                 .map_err(|e| ParquetError::Conversion(e.to_string()))?;
             apply_timezone(time, &tz)
         }
@@ -1510,25 +1580,25 @@ pub fn parquet_to_ruby(value: ParquetValue) -> Result<Value> {
             let secs = micros / 1_000_000;
             let usec = micros % 1_000_000; // Already in microseconds
             let time = time_class
-                .funcall::<_, _, Value>("at", (secs, usec))
+                .funcall::<_, _, Value>("at", (secs, usec, kwargs!("in" => "UTC")))
                 .map_err(|e| ParquetError::Conversion(e.to_string()))?;
             apply_timezone(time, &tz)
         }
-        ParquetValue::TimeNanos(nanos) => {
-            let time_class = ruby.class_time();
-            let secs = nanos / 1_000_000_000;
-            let nsec = nanos % 1_000_000_000;
-            time_class
-                .funcall("at", (secs, nsec, Symbol::new("nanosecond")))
-                .map_err(|e| ParquetError::Conversion(e.to_string()))
-        }
         ParquetValue::TimestampNanos(nanos, tz) => {
             let time_class = ruby.class_time();
             let secs = nanos / 1_000_000_000;
             let nsec = nanos % 1_000_000_000;
             // Use the nanosecond form of Time.at
             let time = time_class
-                .funcall::<_, _, Value>("at", (secs, nsec, Symbol::new("nanosecond")))
+                .funcall::<_, _, Value>(
+                    "at",
+                    (
+                        secs,
+                        nsec,
+                        Symbol::new("nanosecond"),
+                        kwargs!("in" => "UTC"),
+                    ),
+                )
                 .map_err(|e| ParquetError::Conversion(e.to_string()))?;
             apply_timezone(time, &tz)
         }

data/ext/parquet-ruby-adapter/src/metadata.rs

@@ -115,9 +115,111 @@ impl TryIntoValue for RubyParquetMetaData {
                 .map_err(|e| {
                     RubyAdapterError::metadata(format!("Failed to set converted_type: {}", e))
                 })?;
+
             if let Some(logical_type) = basic_info.logical_type() {
+                let logical_type_value = match logical_type {
+                    parquet::basic::LogicalType::Decimal { scale, precision } => {
+                        let logical_hash = handle.hash_new();
+                        logical_hash.aset("type", "Decimal").map_err(|e| {
+                            RubyAdapterError::metadata(format!("Failed to set type: {}", e))
+                        })?;
+                        logical_hash.aset("scale", scale).map_err(|e| {
+                            RubyAdapterError::metadata(format!("Failed to set scale: {}", e))
+                        })?;
+                        logical_hash.aset("precision", precision).map_err(|e| {
+                            RubyAdapterError::metadata(format!("Failed to set precision: {}", e))
+                        })?;
+                        logical_hash.as_value()
+                    }
+                    parquet::basic::LogicalType::Time {
+                        is_adjusted_to_u_t_c,
+                        unit,
+                    } => {
+                        let logical_hash = handle.hash_new();
+                        logical_hash.aset("type", "Time").map_err(|e| {
+                            RubyAdapterError::metadata(format!("Failed to set type: {}", e))
+                        })?;
+                        logical_hash
+                            .aset(
+                                "is_adjusted_to_utc",
+                                is_adjusted_to_u_t_c.to_string().as_str(),
+                            )
+                            .map_err(|e| {
+                                RubyAdapterError::metadata(format!(
+                                    "Failed to set is_adjusted_to_u_t_c: {}",
+                                    e
+                                ))
+                            })?;
+
+                        let unit_str = match unit {
+                            parquet::basic::TimeUnit::MILLIS(_) => "millis",
+                            parquet::basic::TimeUnit::MICROS(_) => "micros",
+                            parquet::basic::TimeUnit::NANOS(_) => "nanos",
+                        };
+                        logical_hash.aset("unit", unit_str).map_err(|e| {
+                            RubyAdapterError::metadata(format!("Failed to set unit: {}", e))
+                        })?;
+                        logical_hash.as_value()
+                    }
+                    parquet::basic::LogicalType::Timestamp {
+                        is_adjusted_to_u_t_c,
+                        unit,
+                    } => {
+                        let logical_hash = handle.hash_new();
+                        logical_hash.aset("type", "Timestamp").map_err(|e| {
+                            RubyAdapterError::metadata(format!("Failed to set type: {}", e))
+                        })?;
+                        logical_hash
+                            .aset("is_adjusted_to_utc", is_adjusted_to_u_t_c)
+                            .map_err(|e| {
+                                RubyAdapterError::metadata(format!(
+                                    "Failed to set is_adjusted_to_u_t_c: {}",
+                                    e
+                                ))
+                            })?;
+                        let unit_str = match unit {
+                            parquet::basic::TimeUnit::MILLIS(_) => "millis",
+                            parquet::basic::TimeUnit::MICROS(_) => "micros",
+                            parquet::basic::TimeUnit::NANOS(_) => "nanos",
+                        };
+                        logical_hash.aset("unit", unit_str).map_err(|e| {
+                            RubyAdapterError::metadata(format!("Failed to set unit: {}", e))
+                        })?;
+                        logical_hash.as_value()
+                    }
+                    parquet::basic::LogicalType::Integer {
+                        bit_width,
+                        is_signed,
+                    } => {
+                        let logical_hash = handle.hash_new();
+                        logical_hash.aset("type", "Integer").map_err(|e| {
+                            RubyAdapterError::metadata(format!("Failed to set type: {}", e))
+                        })?;
+                        logical_hash.aset("bit_width", bit_width).map_err(|e| {
+                            RubyAdapterError::metadata(format!("Failed to set bit_width: {}", e))
+                        })?;
+                        logical_hash
+                            .aset("is_signed", is_signed.to_string().as_str())
+                            .map_err(|e| {
+                                RubyAdapterError::metadata(format!(
+                                    "Failed to set is_signed: {}",
+                                    e
+                                ))
+                            })?;
+                        logical_hash.as_value()
+                    }
+                    _ => {
+                        let logical_hash = handle.hash_new();
+                        logical_hash
+                            .aset("type", format!("{:?}", logical_type))
+                            .map_err(|e| {
+                                RubyAdapterError::metadata(format!("Failed to set type: {}", e))
+                            })?;
+                        logical_hash.as_value()
+                    }
+                };
                 field_hash
-                    .aset("logical_type", format!("{:?}", logical_type))
+                    .aset("logical_type", logical_type_value)
                     .map_err(|e| {
                         RubyAdapterError::metadata(format!("Failed to set logical_type: {}", e))
                     })?;

data/lib/parquet/version.rb

@@ -1,3 +1,3 @@
 module Parquet
-  VERSION = "0.6.2"
+  VERSION = "0.7.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: parquet
 version: !ruby/object:Gem::Version
-  version: 0.6.2
+  version: 0.7.1
 platform: ruby
 authors:
 - Nathan Jaremko
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-07-04 00:00:00.000000000 Z
+date: 2025-07-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rb_sys