parquet 0.5.3 → 0.5.5

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

@@ -101,31 +101,48 @@ impl FromStr for ParquetSchemaType<'_> {
         // Check if it's a decimal type with precision and scale
         if let Some(decimal_params) = s.strip_prefix("decimal(").and_then(|s| s.strip_suffix(")")) {
             let parts: Vec<&str> = decimal_params.split(',').collect();
-            if parts.len() != 2 {
+
+            // Handle both single parameter (precision only) and two parameters (precision and scale)
+            if parts.len() == 1 {
+                // Only precision provided, scale defaults to 0
+                let precision = parts[0].trim().parse::<u8>().map_err(|_| {
+                    MagnusError::new(
+                        magnus::exception::runtime_error(),
+                        format!("Invalid precision value in decimal type: {}", parts[0]),
+                    )
+                })?;
+
+                return Ok(ParquetSchemaType::Primitive(PrimitiveType::Decimal128(
+                    precision, 0,
+                )));
+            } else if parts.len() == 2 {
+                // Both precision and scale provided
+                let precision = parts[0].trim().parse::<u8>().map_err(|_| {
+                    MagnusError::new(
+                        magnus::exception::runtime_error(),
+                        format!("Invalid precision value in decimal type: {}", parts[0]),
+                    )
+                })?;
+
+                let scale = parts[1].trim().parse::<i8>().map_err(|_| {
+                    MagnusError::new(
+                        magnus::exception::runtime_error(),
+                        format!("Invalid scale value in decimal type: {}", parts[1]),
+                    )
+                })?;
+
+                return Ok(ParquetSchemaType::Primitive(PrimitiveType::Decimal128(
+                    precision, scale,
+                )));
+            } else {
                 return Err(MagnusError::new(
                     magnus::exception::runtime_error(),
                     format!(
-                        "Invalid decimal format. Expected 'decimal(precision,scale)', got '{}'",
+                        "Invalid decimal format. Expected 'decimal(precision)' or 'decimal(precision,scale)', got '{}'",
                         s
                     ),
                 ));
             }
-
-            let precision = parts[0].trim().parse::<u8>().map_err(|_| {
-                MagnusError::new(
-                    magnus::exception::runtime_error(),
-                    format!("Invalid precision value in decimal type: {}", parts[0]),
-                )
-            })?;
-
-            let scale = parts[1].trim().parse::<i8>().map_err(|_| {
-                MagnusError::new(
-                    magnus::exception::runtime_error(),
-                    format!("Invalid scale value in decimal type: {}", parts[1]),
-                )
-            })?;
-
-            return Ok(ParquetSchemaType::Primitive(PrimitiveType::Decimal128(precision, scale)));
         }
 
         // Handle primitive types
@@ -146,7 +163,9 @@ impl FromStr for ParquetSchemaType<'_> {
             "date32" => Ok(ParquetSchemaType::Primitive(PrimitiveType::Date32)),
             "timestamp_millis" => Ok(ParquetSchemaType::Primitive(PrimitiveType::TimestampMillis)),
             "timestamp_micros" => Ok(ParquetSchemaType::Primitive(PrimitiveType::TimestampMicros)),
-            "decimal" => Ok(ParquetSchemaType::Primitive(PrimitiveType::Decimal128(18, 2))), // Default precision 18, scale 2
+            "decimal" => Ok(ParquetSchemaType::Primitive(PrimitiveType::Decimal128(
+                38, 0,
+            ))),
             "list" => Ok(ParquetSchemaType::List(Box::new(ListField {
                 item_type: ParquetSchemaType::Primitive(PrimitiveType::String),
                 format: None,

data/lib/parquet/schema.rb

@@ -58,7 +58,7 @@ module Parquet
       #   - `key:, value:` if type == :map
       #   - `key_nullable:, value_nullable:` controls nullability of map keys/values (default: true)
       #   - `format:` if you want to store some format string
-      #   - `precision:, scale:` if type == :decimal (precision defaults to 18, scale to 2)
+      #   - `precision:, scale:` if type == :decimal (precision defaults to 38, scale to 0)
       #   - `nullable:` default to true if not specified
       def field(name, type, nullable: true, **kwargs, &block)
         field_hash = { name: name.to_s, type: type, nullable: !!nullable }
@@ -77,12 +77,18 @@ module Parquet
           raise ArgumentError, "list field `#{name}` requires `item:` type" unless item_type
           # Pass item_nullable if provided, otherwise use true as default
           item_nullable = kwargs[:item_nullable].nil? ? true : !!kwargs[:item_nullable]
-          
+
           # Pass precision and scale if type is decimal
           if item_type == :decimal
             precision = kwargs[:precision]
             scale = kwargs[:scale]
-            field_hash[:item] = wrap_subtype(item_type, nullable: item_nullable, precision: precision, scale: scale, &block)
+            field_hash[:item] = wrap_subtype(
+              item_type,
+              nullable: item_nullable,
+              precision: precision,
+              scale: scale,
+              &block
+            )
           else
             field_hash[:item] = wrap_subtype(item_type, nullable: item_nullable, &block)
           end
@@ -94,14 +100,20 @@ module Parquet
           # Pass key_nullable and value_nullable if provided, otherwise use true as default
           key_nullable = kwargs[:key_nullable].nil? ? true : !!kwargs[:key_nullable]
           value_nullable = kwargs[:value_nullable].nil? ? true : !!kwargs[:value_nullable]
-          
+
           field_hash[:key] = wrap_subtype(key_type, nullable: key_nullable)
-          
+
           # Pass precision and scale if value type is decimal
           if value_type == :decimal
             precision = kwargs[:precision]
             scale = kwargs[:scale]
-            field_hash[:value] = wrap_subtype(value_type, nullable: value_nullable, precision: precision, scale: scale, &block)
+            field_hash[:value] = wrap_subtype(
+              value_type,
+              nullable: value_nullable,
+              precision: precision,
+              scale: scale,
+              &block
+            )
           else
             field_hash[:value] = wrap_subtype(value_type, nullable: value_nullable, &block)
           end
@@ -111,7 +123,7 @@ module Parquet
           # 2. When only precision is provided, scale defaults to 0
           # 3. When only scale is provided, use maximum precision (38)
           # 4. When both are provided, use the provided values
-          
+
           if kwargs[:precision].nil? && kwargs[:scale].nil?
             # No precision or scale provided - use maximum precision
             field_hash[:precision] = 38
@@ -192,7 +204,7 @@ module Parquet
         elsif t == :decimal
           # Handle decimal type with precision and scale
           result = { type: t, nullable: nullable, name: "item" }
-          
+
           # Follow the same rules as in field() method:
           # 1. When neither precision nor scale is provided, use maximum precision (38)
           # 2. When only precision is provided, scale defaults to 0
@@ -215,7 +227,7 @@ module Parquet
             result[:precision] = precision
             result[:scale] = scale
           end
-          
+
           result
         else
           # e.g. :int32 => { type: :int32, nullable: true }

data/lib/parquet/version.rb

@@ -1,3 +1,3 @@
 module Parquet
-  VERSION = "0.5.3"
+  VERSION = "0.5.5"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: parquet
 version: !ruby/object:Gem::Version
-  version: 0.5.3
+  version: 0.5.5
 platform: ruby
 authors:
 - Nathan Jaremko
@@ -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