parquet 0.5.2 → 0.5.4

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

@@ -68,7 +68,7 @@ fn parse_struct_node(
     })?;
 
     // Check for empty struct immediately
-    if fields_arr.len() == 0 {
+    if fields_arr.is_empty() {
         return Err(MagnusError::new(
             ruby.exception_arg_error(),
             format!("Cannot create a struct with zero fields. Struct name: '{}'. Parquet doesn't support empty structs", name)
@@ -175,6 +175,83 @@ pub fn parse_schema_node(ruby: &Ruby, node_value: Value) -> Result<SchemaNode, M
         "struct" => parse_struct_node(ruby, &node_hash, name, nullable),
         "list" => parse_list_node(ruby, &node_hash, name, nullable),
         "map" => parse_map_node(ruby, &node_hash, name, nullable),
+        "decimal" => {
+            // Check for precision and scale
+            let precision_val = node_hash.get(Symbol::new("precision"));
+            let scale_val = node_hash.get(Symbol::new("scale"));
+
+            // Handle different precision/scale combinations:
+            // 1. When no precision or scale - use max precision (38)
+            // 2. When precision only - use scale 0
+            // 3. When scale only - use max precision (38)
+            let (precision, scale) = match (precision_val, scale_val) {
+                (None, None) => (38, 0),  // Maximum accuracy, scale 0
+                (Some(p), None) => {
+                    // Precision provided, scale defaults to 0
+                    let prec = u8::try_convert(p).map_err(|_| {
+                        MagnusError::new(
+                            ruby.exception_type_error(),
+                            "Invalid precision value for decimal type, expected a positive integer".to_string(),
+                        )
+                    })?;
+                    (prec, 0)
+                },
+                (None, Some(s)) => {
+                    // Scale provided, precision set to maximum (38)
+                    let scl = i8::try_convert(s).map_err(|_| {
+                        MagnusError::new(
+                            ruby.exception_type_error(),
+                            "Invalid scale value for decimal type, expected an integer".to_string(),
+                        )
+                    })?;
+                    (38, scl)
+                },
+                (Some(p), Some(s)) => {
+                    // Both provided
+                    let prec = u8::try_convert(p).map_err(|_| {
+                        MagnusError::new(
+                            ruby.exception_type_error(),
+                            "Invalid precision value for decimal type, expected a positive integer".to_string(),
+                        )
+                    })?;
+                    let scl = i8::try_convert(s).map_err(|_| {
+                        MagnusError::new(
+                            ruby.exception_type_error(),
+                            "Invalid scale value for decimal type, expected an integer".to_string(),
+                        )
+                    })?;
+                    (prec, scl)
+                }
+            };
+
+            // Validate precision is in a valid range
+            if precision < 1 {
+                return Err(MagnusError::new(
+                    ruby.exception_arg_error(),
+                    format!(
+                        "Precision for decimal type must be at least 1, got {}",
+                        precision
+                    ),
+                ));
+            }
+
+            if precision > 38 {
+                return Err(MagnusError::new(
+                    ruby.exception_arg_error(),
+                    format!(
+                        "Precision for decimal type cannot exceed 38, got {}",
+                        precision
+                    ),
+                ));
+            }
+
+            Ok(SchemaNode::Primitive {
+                name,
+                parquet_type: PrimitiveType::Decimal128(precision, scale),
+                nullable,
+                format,
+            })
+        }
         // For primitives, provide better error messages when type isn't recognized
         other => {
             if let Some(parquet_type) = parse_primitive_type(other) {
@@ -188,7 +265,7 @@ pub fn parse_schema_node(ruby: &Ruby, node_value: Value) -> Result<SchemaNode, M
                 Err(MagnusError::new(
                     magnus::exception::arg_error(),
                     format!(
-                        "Unknown type: '{}'. Supported types are: struct, list, map, int8, int16, int32, int64, uint8, uint16, uint32, uint64, float32, float64, boolean, string, binary, date32, timestamp_millis, timestamp_micros",
+                        "Unknown type: '{}'. Supported types are: struct, list, map, int8, int16, int32, int64, uint8, uint16, uint32, uint64, float32, float64, boolean, string, binary, date32, timestamp_millis, timestamp_micros, decimal",
                         other
                     )
                 ))
@@ -216,6 +293,7 @@ fn parse_primitive_type(s: &str) -> Option<PrimitiveType> {
         "date" | "date32" => Some(PrimitiveType::Date32),
         "timestamp_millis" | "timestamp_ms" => Some(PrimitiveType::TimestampMillis),
         "timestamp_micros" | "timestamp_us" => Some(PrimitiveType::TimestampMicros),
+        "decimal" => Some(PrimitiveType::Decimal128(38, 0)), // Maximum precision, scale 0
         _ => None,
     }
 }
@@ -240,6 +318,9 @@ pub fn schema_node_to_arrow_field(node: &SchemaNode) -> ArrowField {
                 PrimitiveType::UInt64 => ArrowDataType::UInt64,
                 PrimitiveType::Float32 => ArrowDataType::Float32,
                 PrimitiveType::Float64 => ArrowDataType::Float64,
+                PrimitiveType::Decimal128(precision, scale) => {
+                    ArrowDataType::Decimal128(*precision, *scale)
+                }
                 PrimitiveType::Boolean => ArrowDataType::Boolean,
                 PrimitiveType::String => ArrowDataType::Utf8,
                 PrimitiveType::Binary => ArrowDataType::Binary,

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

@@ -2,15 +2,11 @@ use super::*;
 
 pub fn parse_zoned_timestamp(value: &ParquetValue) -> Result<jiff::Timestamp, ParquetGemError> {
     let (ts, tz) = match value {
-        ParquetValue::TimestampSecond(ts, tz) => (jiff::Timestamp::from_second(*ts).unwrap(), tz),
-        ParquetValue::TimestampMillis(ts, tz) => {
-            (jiff::Timestamp::from_millisecond(*ts).unwrap(), tz)
-        }
-        ParquetValue::TimestampMicros(ts, tz) => {
-            (jiff::Timestamp::from_microsecond(*ts).unwrap(), tz)
-        }
+        ParquetValue::TimestampSecond(ts, tz) => (jiff::Timestamp::from_second(*ts)?, tz),
+        ParquetValue::TimestampMillis(ts, tz) => (jiff::Timestamp::from_millisecond(*ts)?, tz),
+        ParquetValue::TimestampMicros(ts, tz) => (jiff::Timestamp::from_microsecond(*ts)?, tz),
         ParquetValue::TimestampNanos(ts, tz) => {
-            (jiff::Timestamp::from_nanosecond(*ts as i128).unwrap(), tz)
+            (jiff::Timestamp::from_nanosecond(*ts as i128)?, tz)
         }
         _ => {
             return Err(MagnusError::new(
@@ -50,7 +46,7 @@ pub fn parse_zoned_timestamp(value: &ParquetValue) -> Result<jiff::Timestamp, Pa
             Ok(ts.to_zoned(tz).timestamp())
         } else {
             // Try IANA timezone
-            match ts.in_tz(&tz) {
+            match ts.in_tz(tz) {
                 Ok(zoned) => Ok(zoned.timestamp()),
                 Err(_) => Ok(ts), // Fall back to UTC if timezone is invalid
             }
@@ -85,7 +81,7 @@ macro_rules! impl_timestamp_conversion {
 #[macro_export]
 macro_rules! impl_date_conversion {
     ($value:expr, $handle:expr) => {{
-        let ts = jiff::Timestamp::from_second(($value as i64) * 86400).unwrap();
+        let ts = jiff::Timestamp::from_second(($value as i64) * 86400)?;
         let formatted = ts.strftime("%Y-%m-%d").to_string();
         Ok(formatted.into_value_with($handle))
     }};

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::MapFieldNames;
 use arrow_array::builder::*;
+use arrow_array::builder::MapFieldNames;
 use arrow_schema::{DataType, Field, Fields, TimeUnit};
 use jiff::tz::{Offset, TimeZone};
 use magnus::{RArray, RString, TryConvert};
@@ -41,9 +41,9 @@ pub fn convert_to_date32(
         let s = String::try_convert(value)?;
         // Parse string into Date using jiff
         let date = if let Some(fmt) = format {
-            jiff::civil::Date::strptime(&fmt, &s).or_else(|e1| {
+            jiff::civil::Date::strptime(fmt, &s).or_else(|e1| {
                 // Try parsing as DateTime and convert to Date with zero offset
-                jiff::civil::DateTime::strptime(&fmt, &s)
+                jiff::civil::DateTime::strptime(fmt, &s)
                     .and_then(|dt| dt.to_zoned(TimeZone::fixed(Offset::constant(0))))
                     .map(|dt| dt.date())
                     .map_err(|e2| {
@@ -78,7 +78,7 @@ pub fn convert_to_date32(
             .timestamp();
 
         // Convert to epoch days
-        Ok((x.as_second() as i64 / 86400) as i32)
+        Ok((x.as_second() / 86400) as i32)
     } else if value.is_kind_of(ruby.class_time()) {
         // Convert Time object to epoch days
         let secs = i64::try_convert(value.funcall::<_, _, Value>("to_i", ())?)?;
@@ -100,10 +100,10 @@ pub fn convert_to_timestamp_millis(
         let s = String::try_convert(value)?;
         // Parse string into Timestamp using jiff
         let timestamp = if let Some(fmt) = format {
-            jiff::Timestamp::strptime(&fmt, &s)
+            jiff::Timestamp::strptime(fmt, &s)
                 .or_else(|e1| {
                     // Try parsing as DateTime and convert to Timestamp with zero offset
-                    jiff::civil::DateTime::strptime(&fmt, &s)
+                    jiff::civil::DateTime::strptime(fmt, &s)
                         .and_then(|dt| dt.to_zoned(TimeZone::fixed(Offset::constant(0))))
                         .map(|dt| dt.timestamp())
                         .map_err(|e2| {
@@ -150,9 +150,9 @@ pub fn convert_to_timestamp_micros(
         let s = String::try_convert(value)?;
         // Parse string into Timestamp using jiff
         let timestamp = if let Some(fmt) = format {
-            jiff::Timestamp::strptime(&fmt, &s).or_else(|e1| {
+            jiff::Timestamp::strptime(fmt, &s).or_else(|e1| {
                 // Try parsing as DateTime and convert to Timestamp with zero offset
-                jiff::civil::DateTime::strptime(&fmt, &s).and_then(|dt| {
+                jiff::civil::DateTime::strptime(fmt, &s).and_then(|dt| {
                     dt.to_zoned(TimeZone::fixed(Offset::constant(0)))
                 })
                 .map(|dt| dt.timestamp())
@@ -242,6 +242,7 @@ pub fn parquet_schema_type_to_arrow_data_type(
             PrimitiveType::UInt64 => DataType::UInt64,
             PrimitiveType::Float32 => DataType::Float32,
             PrimitiveType::Float64 => DataType::Float64,
+            PrimitiveType::Decimal128(precision, scale) => DataType::Decimal128(*precision, *scale),
             PrimitiveType::String => DataType::Utf8,
             PrimitiveType::Binary => DataType::Binary,
             PrimitiveType::Boolean => DataType::Boolean,
@@ -364,6 +365,20 @@ fn create_arrow_builder_for_type(
         ParquetSchemaType::Primitive(PrimitiveType::Float64) => {
             Ok(Box::new(Float64Builder::with_capacity(cap)))
         }
+        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),
+                )
+            })?;
+            
+            Ok(Box::new(builder_with_precision))
+        }
         ParquetSchemaType::Primitive(PrimitiveType::String) => {
             Ok(Box::new(StringBuilder::with_capacity(cap, cap * 32)))
         }
@@ -415,7 +430,7 @@ fn create_arrow_builder_for_type(
         ParquetSchemaType::Struct(struct_field) => {
             // Check for empty struct immediately
             if struct_field.fields.is_empty() {
-                return Err(MagnusError::new(
+                Err(MagnusError::new(
                     magnus::exception::runtime_error(),
                     "Cannot build a struct with zero fields - Parquet doesn't support empty structs".to_string(),
                 ))?;
@@ -445,7 +460,7 @@ fn create_arrow_builder_for_type(
 
             // Make sure we have the right number of builders
             if child_field_builders.len() != arrow_fields.len() {
-                return Err(MagnusError::new(
+                Err(MagnusError::new(
                     magnus::exception::runtime_error(),
                     format!(
                         "Number of field builders ({}) doesn't match number of arrow fields ({})",
@@ -834,6 +849,46 @@ fn fill_builder(
             }
             Ok(())
         }
+        ParquetSchemaType::Primitive(PrimitiveType::Decimal128(_precision, scale)) => {
+            let typed_builder = builder
+                .as_any_mut()
+                .downcast_mut::<Decimal128Builder>()
+                .expect("Builder mismatch: expected Float64Builder");
+
+            for val in values {
+                match val {
+                    ParquetValue::Decimal128(d) => 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;
+                        typed_builder.append_value(scaled_value)
+                    }
+                    ParquetValue::Float32(flo) => {
+                        // Scale the float to the desired precision and scale
+                        let scaled_value = (*flo as f64 * 10_f64.powi(*scale as i32)) as i128;
+                        typed_builder.append_value(scaled_value)
+                    }
+                    ParquetValue::Int64(i) => {
+                        // Scale the integer to the desired scale
+                        let scaled_value = (*i as i128) * 10_i128.pow(*scale as u32);
+                        typed_builder.append_value(scaled_value)
+                    }
+                    ParquetValue::Int32(i) => {
+                        // Scale the integer to the desired scale
+                        let scaled_value = (*i as i128) * 10_i128.pow(*scale as u32);
+                        typed_builder.append_value(scaled_value)
+                    }
+                    ParquetValue::Null => typed_builder.append_null(),
+                    other => {
+                        return Err(MagnusError::new(
+                            magnus::exception::type_error(),
+                            format!("Expected Float64, got {:?}", other),
+                        ))
+                    }
+                }
+            }
+            Ok(())
+        }
         ParquetSchemaType::Primitive(PrimitiveType::Boolean) => {
             let typed_builder = builder
                 .as_any_mut()
@@ -954,7 +1009,7 @@ fn fill_builder(
                 .expect("Builder mismatch: expected BinaryBuilder");
             for val in values {
                 match val {
-                    ParquetValue::Bytes(b) => typed_builder.append_value(&b),
+                    ParquetValue::Bytes(b) => typed_builder.append_value(b),
                     ParquetValue::Null => typed_builder.append_null(),
                     other => {
                         return Err(MagnusError::new(
@@ -1106,6 +1161,15 @@ fn fill_builder(
                                             )
                                         })?
                                         .append_value(bytes),
+                                    ParquetValue::Decimal128(x) => typed_builder
+                                        .field_builder::<Decimal128Builder>(i)
+                                        .ok_or_else(|| {
+                                            MagnusError::new(
+                                                magnus::exception::type_error(),
+                                                "Failed to coerce into Decimal128Builder",
+                                            )
+                                        })?
+                                        .append_value(*x),
                                     ParquetValue::Date32(x) => typed_builder
                                         .field_builder::<Date32Builder>(i)
                                         .ok_or_else(|| {
@@ -1302,6 +1366,15 @@ fn fill_builder(
                                                 )
                                             })?
                                             .append_null(),
+                                            ParquetSchemaType::Primitive(PrimitiveType::Decimal128(_, _)) => typed_builder
+                                            .field_builder::<Decimal128Builder>(i)
+                                            .ok_or_else(|| {
+                                                MagnusError::new(
+                                                    magnus::exception::type_error(),
+                                                    "Failed to coerce into Decimal128Builder",
+                                                )
+                                            })?
+                                            .append_null(),
                                         ParquetSchemaType::Primitive(PrimitiveType::String) => typed_builder
                                             .field_builder::<StringBuilder>(i)
                                             .ok_or_else(|| {

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

@@ -59,7 +59,7 @@ impl Write for IoLikeValue {
     }
 }
 
-impl<'a> FromStr for ParquetSchemaType<'a> {
+impl FromStr for ParquetSchemaType<'_> {
     type Err = MagnusError;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
@@ -98,6 +98,53 @@ impl<'a> FromStr for ParquetSchemaType<'a> {
             })));
         }
 
+        // 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();
+
+            // 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)' or 'decimal(precision,scale)', got '{}'",
+                        s
+                    ),
+                ));
+            }
+        }
+
         // Handle primitive types
         match s {
             "int8" => Ok(ParquetSchemaType::Primitive(PrimitiveType::Int8)),
@@ -116,6 +163,9 @@ impl<'a> FromStr for ParquetSchemaType<'a> {
             "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(
+                38, 0,
+            ))),
             "list" => Ok(ParquetSchemaType::List(Box::new(ListField {
                 item_type: ParquetSchemaType::Primitive(PrimitiveType::String),
                 format: None,
@@ -129,7 +179,7 @@ impl<'a> FromStr for ParquetSchemaType<'a> {
     }
 }
 
-impl<'a> TryConvert for ParquetSchemaType<'a> {
+impl TryConvert for ParquetSchemaType<'_> {
     fn try_convert(value: Value) -> Result<Self, MagnusError> {
         let ruby = unsafe { Ruby::get_unchecked() };
         let schema_type = parse_string_or_symbol(&ruby, value)?;
@@ -144,7 +194,7 @@ impl<'a> TryConvert for ParquetSchemaType<'a> {
 
 // We know this type is safe to move between threads because it's just an enum
 // with simple primitive types and strings
-unsafe impl<'a> Send for ParquetSchemaType<'a> {}
+unsafe impl Send for ParquetSchemaType<'_> {}
 
 pub enum WriterOutput {
     File(ArrowWriter<Box<dyn SendableWrite>>),
@@ -202,14 +252,12 @@ impl<'a> ColumnCollector<'a> {
     pub fn push_value(&mut self, value: Value) -> Result<(), MagnusError> {
         use crate::types::ParquetValue;
 
-        if value.is_nil() {
-            if !self.nullable {
-                // For non-nullable fields, raise an error
-                return Err(MagnusError::new(
-                    magnus::exception::runtime_error(),
-                    "Cannot write nil value for non-nullable field",
-                ));
-            }
+        if value.is_nil() && !self.nullable {
+            // For non-nullable fields, raise an error
+            return Err(MagnusError::new(
+                magnus::exception::runtime_error(),
+                "Cannot write nil value for non-nullable field",
+            ));
         }
 
         // For all other types, proceed as normal

data/ext/parquet/src/utils.rs

@@ -13,12 +13,12 @@ pub fn parse_string_or_symbol(ruby: &Ruby, value: Value) -> Result<Option<String
         RString::from_value(value)
             .ok_or_else(|| Error::new(magnus::exception::type_error(), "Invalid string value"))?
             .to_string()
-            .map(|s| Some(s))
+            .map(Some)
     } else if value.is_kind_of(ruby.class_symbol()) {
         Symbol::from_value(value)
             .ok_or_else(|| Error::new(magnus::exception::type_error(), "Invalid symbol value"))?
             .funcall("to_s", ())
-            .map(|s| Some(s))
+            .map(Some)
     } else {
         Err(Error::new(
             magnus::exception::type_error(),
@@ -161,11 +161,11 @@ pub fn parse_parquet_columns_args(
     };
 
     let batch_size = kwargs.optional.2.flatten();
-    if let Some(sz) = batch_size {
-        if sz <= 0 {
+    if let Some(batch_size) = batch_size {
+        if batch_size == 0 {
             return Err(Error::new(
-                ruby.exception_arg_error(),
-                format!("batch_size must be > 0, got {}", sz),
+                magnus::exception::arg_error(),
+                "Batch size must be greater than 0",
             ));
         }
     }

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

@@ -111,13 +111,13 @@ pub fn parse_parquet_write_args(
     if let Some(type_val) = type_val {
         // If it has a type: :struct, it's the new DSL format
         // Use parse_string_or_symbol to handle both String and Symbol values
-        let ttype = parse_string_or_symbol(&ruby, type_val)?;
+        let ttype = parse_string_or_symbol(ruby, type_val)?;
         if let Some(ref type_str) = ttype {
             if type_str == "struct" {
                 // Parse using the new schema approach
-                let schema_node = crate::parse_schema_node(&ruby, schema_value)?;
+                let schema_node = crate::parse_schema_node(ruby, schema_value)?;
 
-                validate_schema_node(&ruby, &schema_node)?;
+                validate_schema_node(ruby, &schema_node)?;
 
                 return Ok(ParquetWriteArgs {
                     read_from,
@@ -143,22 +143,21 @@ pub fn parse_parquet_write_args(
                         "Schema fields must be an array",
                     )
                 })?
-                .len()
-                == 0)
+                .is_empty())
     {
         // If schema is nil or an empty array, we need to peek at the first value to determine column count
         let first_value = read_from.funcall::<_, _, Value>("peek", ())?;
         // Default to nullable:true for auto-inferred fields
-        crate::infer_schema_from_first_row(&ruby, first_value, true)?
+        crate::infer_schema_from_first_row(ruby, first_value, true)?
     } else {
         // Legacy array format - use our centralized parser
-        crate::parse_legacy_schema(&ruby, schema_value)?
+        crate::parse_legacy_schema(ruby, schema_value)?
     };
 
     // Convert the legacy schema fields to SchemaNode (DSL format)
-    let schema_node = crate::legacy_schema_to_dsl(&ruby, schema_fields)?;
+    let schema_node = crate::legacy_schema_to_dsl(ruby, schema_fields)?;
 
-    validate_schema_node(&ruby, &schema_node)?;
+    validate_schema_node(ruby, &schema_node)?;
 
     Ok(ParquetWriteArgs {
         read_from,
@@ -195,6 +194,9 @@ fn arrow_data_type_to_parquet_schema_type(dt: &DataType) -> Result<ParquetSchema
         }
         DataType::Float32 => Ok(PST::Primitive(PrimitiveType::Float32)),
         DataType::Float64 => Ok(PST::Primitive(PrimitiveType::Float64)),
+        DataType::Decimal128(precision, scale) => Ok(PST::Primitive(PrimitiveType::Decimal128(
+            *precision, *scale,
+        ))),
         DataType::Date32 => Ok(PST::Primitive(PrimitiveType::Date32)),
         DataType::Date64 => {
             // Our code typically uses Date32 or Timestamp for 64. But Arrow has Date64
@@ -414,15 +416,21 @@ fn create_writer(
     compression: Option<String>,
 ) -> Result<WriterOutput, ParquetGemError> {
     // Create writer properties with compression based on the option
+    let compression_setting = match compression.map(|s| s.to_lowercase()).as_deref() {
+        Some("none") | Some("uncompressed") => Ok(Compression::UNCOMPRESSED),
+        Some("snappy") => Ok(Compression::SNAPPY),
+        Some("gzip") => Ok(Compression::GZIP(GzipLevel::default())),
+        Some("lz4") => Ok(Compression::LZ4),
+        Some("zstd") => Ok(Compression::ZSTD(ZstdLevel::default())),
+        None => Ok(Compression::UNCOMPRESSED),
+        other => Err(MagnusError::new(
+            magnus::exception::arg_error(),
+            format!("Invalid compression option: {:?}", other),
+        )),
+    }?;
+
     let props = WriterProperties::builder()
-        .set_compression(match compression.as_deref() {
-            Some("none") | Some("uncompressed") => Compression::UNCOMPRESSED,
-            Some("snappy") => Compression::SNAPPY,
-            Some("gzip") => Compression::GZIP(GzipLevel::default()),
-            Some("lz4") => Compression::LZ4,
-            Some("zstd") => Compression::ZSTD(ZstdLevel::default()),
-            _ => Compression::UNCOMPRESSED,
-        })
+        .set_compression(compression_setting)
         .build();
 
     if write_to.is_kind_of(ruby.class_string()) {