parquet 0.5.4 → 0.5.6

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

@@ -121,7 +121,8 @@ pub fn parse_legacy_schema(
                         ruby.exception_type_error(),
                         "Schema must be an array of field definitions or nil",
                     )
-                })?.is_empty())
+                })?
+                .is_empty())
     {
         // If schema is nil or an empty array, we'll handle this in the caller
         return Ok(Vec::new());
@@ -206,101 +207,39 @@ pub fn parse_legacy_schema(
 
                 // Handle decimal type with precision and scale
                 let mut type_result = PST::try_convert(type_str)?;
-                
+
                 // If it's a decimal type and we have precision and scale, override the type
                 if let PST::Primitive(PrimitiveType::Decimal128(_, _)) = type_result {
-                    let precision_value = precision.unwrap_or_else(|| {
-                        let val: u8 = 18;
-                        val.into_value_with(ruby)
-                    });
-                    let scale_value = scale.unwrap_or_else(|| {
-                        let val: i8 = 2;
-                        val.into_value_with(ruby)
-                    });
-                    
-                    let precision_u8 = u8::try_convert(precision_value).map_err(|_| {
-                        MagnusError::new(
-                            ruby.exception_type_error(),
-                            "Invalid precision value for decimal type, expected a positive integer".to_string(),
-                        )
-                    })?;
-                    
-                    // Validate precision is in a valid range
-                    if precision_u8 < 1 {
-                        return Err(MagnusError::new(
-                            ruby.exception_arg_error(),
-                            format!(
-                                "Precision for decimal type must be at least 1, got {}", 
-                                precision_u8
-                            ),
-                        ));
-                    }
-                    
-                    if precision_u8 > 38 {
-                        return Err(MagnusError::new(
-                            ruby.exception_arg_error(),
-                            format!(
-                                "Precision for decimal type cannot exceed 38, got {}", 
-                                precision_u8
-                            ),
-                        ));
-                    }
-                    
-                    let scale_i8 = i8::try_convert(scale_value).map_err(|_| {
-                        MagnusError::new(
-                            ruby.exception_type_error(),
-                            "Invalid scale value for decimal type, expected an integer".to_string(),
-                        )
-                    })?;
-                    
-                    // Validate scale is in a valid range relative to precision
-                    if scale_i8 < 0 {
-                        return Err(MagnusError::new(
-                            ruby.exception_arg_error(),
-                            format!(
-                                "Scale for decimal type cannot be negative, got {}", 
-                                scale_i8
-                            ),
-                        ));
-                    }
-                    
-                    if scale_i8 as u8 > precision_u8 {
-                        return Err(MagnusError::new(
-                            ruby.exception_arg_error(),
-                            format!(
-                                "Scale ({}) cannot be larger than precision ({}) for decimal type", 
-                                scale_i8, precision_u8
-                            ),
-                        ));
-                    }
-                    
-                    type_result = PST::Primitive(PrimitiveType::Decimal128(precision_u8, scale_i8));
+                    // Do nothing
                 } else if let Some(type_name) = parse_string_or_symbol(ruby, type_str)? {
                     if type_name == "decimal" {
                         let precision_value = precision.unwrap_or_else(|| {
-                            let val: u8 = 18;
+                            let val: u8 = 38;
                             val.into_value_with(ruby)
                         });
+
                         let scale_value = scale.unwrap_or_else(|| {
-                            let val: i8 = 2;
+                            let val: i8 = 0;
                             val.into_value_with(ruby)
                         });
-                        
+
                         let precision_u8 = u8::try_convert(precision_value).map_err(|_| {
                             MagnusError::new(
                                 ruby.exception_type_error(),
                                 "Invalid precision value for decimal type, expected a positive integer".to_string(),
                             )
                         })?;
-                        
+
                         let scale_i8 = i8::try_convert(scale_value).map_err(|_| {
                             MagnusError::new(
                                 ruby.exception_type_error(),
-                                "Invalid scale value for decimal type, expected an integer".to_string(),
+                                "Invalid scale value for decimal type, expected an integer"
+                                    .to_string(),
                             )
                         })?;
-                        
-                        type_result = PST::Primitive(PrimitiveType::Decimal128(precision_u8, scale_i8));
+
+                        type_result =
+                            PST::Primitive(PrimitiveType::Decimal128(precision_u8, scale_i8));
                     }
                 }
 

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

@@ -2,8 +2,8 @@ use std::str::FromStr;
 use std::sync::Arc;
 
 use super::*;
-use arrow_array::builder::*;
 use arrow_array::builder::MapFieldNames;
+use arrow_array::builder::*;
 use arrow_schema::{DataType, Field, Fields, TimeUnit};
 use jiff::tz::{Offset, TimeZone};
 use magnus::{RArray, RString, TryConvert};
@@ -368,15 +368,17 @@ fn create_arrow_builder_for_type(
         ParquetSchemaType::Primitive(PrimitiveType::Decimal128(precision, scale)) => {
             // Create a Decimal128Builder with specific precision and scale
             let builder = Decimal128Builder::with_capacity(cap);
-            
+
             // Set precision and scale for the decimal and return the new builder
-            let builder_with_precision = builder.with_precision_and_scale(*precision, *scale).map_err(|e| {
-                MagnusError::new(
-                    magnus::exception::runtime_error(),
-                    format!("Failed to set precision and scale: {}", e),
-                )
-            })?;
-            
+            let builder_with_precision = builder
+                .with_precision_and_scale(*precision, *scale)
+                .map_err(|e| {
+                    MagnusError::new(
+                        magnus::exception::runtime_error(),
+                        format!("Failed to set precision and scale: {}", e),
+                    )
+                })?;
+
             Ok(Box::new(builder_with_precision))
         }
         ParquetSchemaType::Primitive(PrimitiveType::String) => {
@@ -857,7 +859,7 @@ fn fill_builder(
 
             for val in values {
                 match val {
-                    ParquetValue::Decimal128(d) => typed_builder.append_value(*d),
+                    ParquetValue::Decimal128(d, _scale) => typed_builder.append_value(*d),
                     ParquetValue::Float64(f) => {
                         // Scale the float to the desired precision and scale
                         let scaled_value = (*f * 10_f64.powi(*scale as i32)) as i128;
@@ -1161,7 +1163,7 @@ fn fill_builder(
                                             )
                                         })?
                                         .append_value(bytes),
-                                    ParquetValue::Decimal128(x) => typed_builder
+                                    ParquetValue::Decimal128(x, _scale) => typed_builder
                                         .field_builder::<Decimal128Builder>(i)
                                         .ok_or_else(|| {
                                             MagnusError::new(

data/lib/parquet/version.rb

@@ -1,3 +1,3 @@
 module Parquet
-  VERSION = "0.5.4"
+  VERSION = "0.5.6"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: parquet
 version: !ruby/object:Gem::Version
-  version: 0.5.4
+  version: 0.5.6
 platform: ruby
 authors:
 - Nathan Jaremko
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-04-01 00:00:00.000000000 Z
+date: 2025-05-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rb_sys
@@ -66,6 +66,7 @@ files:
 - ext/parquet/src/reader/mod.rs
 - ext/parquet/src/reader/parquet_column_reader.rs
 - ext/parquet/src/reader/parquet_row_reader.rs
+- ext/parquet/src/reader/unified/mod.rs
 - ext/parquet/src/ruby_reader.rs
 - ext/parquet/src/types/core_types.rs
 - ext/parquet/src/types/mod.rs