parquet 0.6.2 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dfd19103b2414e7feeaa6d1ec3c9a9c25ce42cf5c8362baa37e3b9d8d5245f82
-  data.tar.gz: c5c1170dbdc3635577738a568688c36adc9670710f4b0d570fae29294e337754
+  metadata.gz: de6b7f5c61eb1e796e7066790e2c1e0ada9ba4519140cee4e2378cd402db2586
+  data.tar.gz: 5b1dc2e442b1be17af82dd3a431b6f3a66254410229055cdbd8713aa1c009be2
 SHA512:
-  metadata.gz: c9bf72b4e708c750ab7ae30afd97aef7f456a4249904fe3eb74f916557e28ca1a53bc262a6492db38c38162ab3e3f684e30f0c70dabbaf8f8f4145ef4d9af259
-  data.tar.gz: 164c5b0569d3d13242bcff7c09d66edf67b279d8289f97def043000a508b4333dd1387a4f47517be09023cd270cf3b6dfd57fdf658ac1b52e25f3f5b2b5ca30c
+  metadata.gz: 7635247bc9627cdafe79ee9be1072c13b0f8ec11549506f9a8b6170d9b095883ede0f8a8165d0340572d89e1501c1d5f144c20f963ab960171dcb5813f15022c
+  data.tar.gz: abb59172a54c8d63ca39f24bdda4c64b98a60015622fc7f4a7a2a4c42ff03c3327f134de8ec66e006eb38a8cb38da90824a987b44f6e2fcc2af1c01bd4d85ee1

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
 ///
@@ -1398,7 +1399,10 @@ pub fn parquet_to_ruby(value: ParquetValue) -> Result<Value> {
         ParquetValue::Float32(OrderedFloat(f)) => Ok((f as f64).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 +1493,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 +1521,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 +1530,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.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: parquet
 version: !ruby/object:Gem::Version
-  version: 0.6.2
+  version: 0.7.0
 platform: ruby
 authors:
 - Nathan Jaremko