parquet 0.5.9 → 0.5.10

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

@@ -1,7 +1,7 @@
 use crate::{impl_date_conversion, impl_timestamp_array_conversion, impl_timestamp_conversion};
 
+use super::record_types::{format_decimal_with_i8_scale, format_i256_decimal_with_scale};
 use super::*;
-use super::record_types::format_decimal_with_i8_scale;
 use arrow_array::MapArray;
 use magnus::{RArray, RString};
 
@@ -24,6 +24,7 @@ pub enum ParquetValue {
     Date32(i32),
     Date64(i64),
     Decimal128(i128, i8),
+    Decimal256(arrow_buffer::i256, i8),
     TimestampSecond(i64, Option<Arc<str>>),
     TimestampMillis(i64, Option<Arc<str>>),
     TimestampMicros(i64, Option<Arc<str>>),
@@ -94,6 +95,15 @@ impl PartialEq for ParquetValue {
                     a_val == b_val
                 }
             }
+            (ParquetValue::Decimal256(a, scale_a), ParquetValue::Decimal256(b, scale_b)) => {
+                if scale_a == scale_b {
+                    // Same scale, compare directly
+                    a == b
+                } else {
+                    // TODO: Implement decimal256 comparison
+                    todo!("decimal256 comparison");
+                }
+            }
             (ParquetValue::TimestampSecond(a, _), ParquetValue::TimestampSecond(b, _)) => a == b,
             (ParquetValue::TimestampMillis(a, _), ParquetValue::TimestampMillis(b, _)) => a == b,
             (ParquetValue::TimestampMicros(a, _), ParquetValue::TimestampMicros(b, _)) => a == b,
@@ -130,6 +140,10 @@ impl std::hash::Hash for ParquetValue {
                 d.hash(state);
                 scale.hash(state);
             }
+            ParquetValue::Decimal256(d, scale) => {
+                d.hash(state);
+                scale.hash(state);
+            }
             ParquetValue::TimestampSecond(ts, tz) => {
                 ts.hash(state);
                 tz.hash(state);
@@ -185,6 +199,17 @@ impl TryIntoValue for ParquetValue {
                 let kernel = handle.module_kernel();
                 Ok(kernel.funcall::<_, _, Value>("BigDecimal", (value,))?)
             }
+            ParquetValue::Decimal256(d, scale) => {
+                // Load the bigdecimal gem if it's not already loaded
+                LOADED_BIGDECIMAL.get_or_init(|| handle.require("bigdecimal").unwrap_or_default());
+
+                // Format with proper scaling based on the sign of scale
+                // Use specialized function to preserve full precision
+                let value = format_i256_decimal_with_scale(d, scale)?;
+
+                let kernel = handle.module_kernel();
+                Ok(kernel.funcall::<_, _, Value>("BigDecimal", (value,))?)
+            }
             ParquetValue::Date32(d) => impl_date_conversion!(d, handle),
             ParquetValue::Date64(d) => impl_date_conversion!(d, handle),
             timestamp @ ParquetValue::TimestampSecond(_, _) => {
@@ -292,9 +317,21 @@ impl ParquetValue {
                 }
                 PrimitiveType::Decimal128(_precision, scale) => {
                     if value.is_kind_of(ruby.class_string()) {
-                        convert_to_decimal128(value, *scale)
+                        convert_to_decimal(value, *scale)
                     } else if let Ok(s) = value.funcall::<_, _, RString>("to_s", ()) {
-                        convert_to_decimal128(s.as_value(), *scale)
+                        convert_to_decimal(s.as_value(), *scale)
+                    } else {
+                        Err(MagnusError::new(
+                            magnus::exception::type_error(),
+                            "Expected a string for a decimal type",
+                        ))
+                    }
+                }
+                PrimitiveType::Decimal256(_precision, scale) => {
+                    if value.is_kind_of(ruby.class_string()) {
+                        convert_to_decimal(value, *scale)
+                    } else if let Ok(s) = value.funcall::<_, _, RString>("to_s", ()) {
+                        convert_to_decimal(s.as_value(), *scale)
                     } else {
                         Err(MagnusError::new(
                             magnus::exception::type_error(),
@@ -425,8 +462,14 @@ impl ParquetValue {
         }
     }
 }
+
+enum ParsedDecimal {
+    Int128(i128),
+    Int256(arrow_buffer::i256),
+}
+
 /// Unified helper to parse a decimal string and apply scaling
-fn parse_decimal_string(input_str: &str, input_scale: i8) -> Result<i128, MagnusError> {
+fn parse_decimal_string(input_str: &str, input_scale: i8) -> Result<ParsedDecimal, MagnusError> {
     let s = input_str.trim();
 
     // 1. Handle scientific notation case (e.g., "0.12345e3")
@@ -445,12 +488,9 @@ fn parse_decimal_string(input_str: &str, input_scale: i8) -> Result<i128, Magnus
             )
         })?;
 
-        // Limit exponent to reasonable range to prevent overflow
+        // For very large exponents, we'll need to use BigInt
         if exp_val.abs() > 38 {
-            return Err(MagnusError::new(
-                magnus::exception::range_error(),
-                format!("Exponent {} is out of range for decimal value '{}'. Must be between -38 and 38.", exp_val, s),
-            ));
+            return parse_large_decimal_with_bigint(s, input_scale);
         }
 
         // Handle the base part which might contain a decimal point
@@ -460,30 +500,23 @@ fn parse_decimal_string(input_str: &str, input_scale: i8) -> Result<i128, Magnus
 
             let base_scale = base.len() - decimal_pos - 1;
 
-            let base_val = base_without_point.parse::<i128>().map_err(|e| {
-                MagnusError::new(
-                    magnus::exception::type_error(),
-                    format!(
-                        "Failed to parse base '{}' in scientific notation '{}': {}",
-                        base, s, e
-                    ),
-                )
-            })?;
-
-            (base_val, base_scale as i32)
+            // Try to parse as i128 first
+            match base_without_point.parse::<i128>() {
+                Ok(v) => (v, base_scale as i32),
+                Err(_) => {
+                    // Value too large for i128, use BigInt
+                    return parse_large_decimal_with_bigint(s, input_scale);
+                }
+            }
         } else {
             // No decimal point in base
-            let base_val = base.parse::<i128>().map_err(|e| {
-                MagnusError::new(
-                    magnus::exception::type_error(),
-                    format!(
-                        "Failed to parse base '{}' in scientific notation '{}': {}",
-                        base, s, e
-                    ),
-                )
-            })?;
-
-            (base_val, 0)
+            match base.parse::<i128>() {
+                Ok(v) => (v, 0),
+                Err(_) => {
+                    // Value too large for i128, use BigInt
+                    return parse_large_decimal_with_bigint(s, input_scale);
+                }
+            }
         };
 
         // Calculate the effective scale: base_scale - exp_val
@@ -495,12 +528,14 @@ fn parse_decimal_string(input_str: &str, input_scale: i8) -> Result<i128, Magnus
                 // Need to multiply to increase scale
                 let scale_diff = (input_scale as i32 - effective_scale) as u32;
                 if scale_diff > 38 {
-                    return Err(MagnusError::new(
-                        magnus::exception::range_error(),
-                        format!("Scale adjustment too large ({}) for decimal value '{}'. Consider using a smaller scale.", scale_diff, s),
-                    ));
+                    return parse_large_decimal_with_bigint(s, input_scale);
+                }
+
+                // Check for overflow
+                match base_val.checked_mul(10_i128.pow(scale_diff)) {
+                    Some(v) => Ok(ParsedDecimal::Int128(v)),
+                    None => parse_large_decimal_with_bigint(s, input_scale),
                 }
-                Ok(base_val * 10_i128.pow(scale_diff))
             }
             std::cmp::Ordering::Greater => {
                 // Need to divide to decrease scale
@@ -511,9 +546,9 @@ fn parse_decimal_string(input_str: &str, input_scale: i8) -> Result<i128, Magnus
                         format!("Scale adjustment too large ({}) for decimal value '{}'. Consider using a larger scale.", scale_diff, s),
                     ));
                 }
-                Ok(base_val / 10_i128.pow(scale_diff))
+                Ok(ParsedDecimal::Int128(base_val / 10_i128.pow(scale_diff)))
             }
-            std::cmp::Ordering::Equal => Ok(base_val),
+            std::cmp::Ordering::Equal => Ok(ParsedDecimal::Int128(base_val)),
         }
     }
     // 2. Handle decimal point in the string (e.g., "123.456")
@@ -524,16 +559,14 @@ fn parse_decimal_string(input_str: &str, input_scale: i8) -> Result<i128, Magnus
         // Calculate the actual scale from the decimal position
         let actual_scale = s.len() - decimal_pos - 1;
 
-        // Parse the string without decimal point as i128
-        let v = s_without_point.parse::<i128>().map_err(|e| {
-            MagnusError::new(
-                magnus::exception::type_error(),
-                format!(
-                    "Failed to parse decimal string '{}' (without decimal point: '{}'): {}",
-                    s, s_without_point, e
-                ),
-            )
-        })?;
+        // Try to parse as i128 first
+        let v = match s_without_point.parse::<i128>() {
+            Ok(v) => v,
+            Err(_) => {
+                // Value too large for i128, use BigInt
+                return parse_large_decimal_with_bigint(s, input_scale);
+            }
+        };
 
         // Scale the value if needed based on the difference between
         // the actual scale and the requested scale
@@ -542,12 +575,14 @@ fn parse_decimal_string(input_str: &str, input_scale: i8) -> Result<i128, Magnus
                 // Need to multiply to increase scale
                 let scale_diff = (input_scale - actual_scale as i8) as u32;
                 if scale_diff > 38 {
-                    return Err(MagnusError::new(
-                        magnus::exception::range_error(),
-                        format!("Scale adjustment too large ({}) for decimal value '{}'. Consider using a smaller scale.", scale_diff, s),
-                    ));
+                    return parse_large_decimal_with_bigint(s, input_scale);
+                }
+
+                // Check for overflow
+                match v.checked_mul(10_i128.pow(scale_diff)) {
+                    Some(v) => Ok(ParsedDecimal::Int128(v)),
+                    None => parse_large_decimal_with_bigint(s, input_scale),
                 }
-                Ok(v * 10_i128.pow(scale_diff))
             }
             std::cmp::Ordering::Greater => {
                 // Need to divide to decrease scale
@@ -558,30 +593,25 @@ fn parse_decimal_string(input_str: &str, input_scale: i8) -> Result<i128, Magnus
                         format!("Scale adjustment too large ({}) for decimal value '{}'. Consider using a larger scale.", scale_diff, s),
                     ));
                 }
-                Ok(v / 10_i128.pow(scale_diff))
+                Ok(ParsedDecimal::Int128(v / 10_i128.pow(scale_diff)))
             }
-            std::cmp::Ordering::Equal => Ok(v),
+            std::cmp::Ordering::Equal => Ok(ParsedDecimal::Int128(v)),
         }
     }
     // 3. Plain integer value (e.g., "12345")
     else {
-        // No decimal point, parse as i128 and scale appropriately
-        let v = s.parse::<i128>().map_err(|e| {
-            MagnusError::new(
-                magnus::exception::type_error(),
-                format!("Failed to parse integer string '{}' as decimal: {}", s, e),
-            )
-        })?;
+        // No decimal point, try to parse as i128 first
+        let v = match s.parse::<i128>() {
+            Ok(v) => v,
+            Err(_) => {
+                // Value too large for i128, use BigInt
+                return parse_large_decimal_with_bigint(s, input_scale);
+            }
+        };
 
         // Apply scale - make sure it's reasonable
         if input_scale > 38 {
-            return Err(MagnusError::new(
-                magnus::exception::range_error(),
-                format!(
-                    "Scale {} is too large for decimal value '{}'. Must be ≤ 38.",
-                    input_scale, s
-                ),
-            ));
+            return parse_large_decimal_with_bigint(s, input_scale);
         } else if input_scale < -38 {
             return Err(MagnusError::new(
                 magnus::exception::range_error(),
@@ -594,15 +624,153 @@ fn parse_decimal_string(input_str: &str, input_scale: i8) -> Result<i128, Magnus
 
         // Apply positive scale (multiply)
         if input_scale >= 0 {
-            Ok(v * 10_i128.pow(input_scale as u32))
+            match v.checked_mul(10_i128.pow(input_scale as u32)) {
+                Some(v) => Ok(ParsedDecimal::Int128(v)),
+                None => parse_large_decimal_with_bigint(s, input_scale),
+            }
         } else {
             // Apply negative scale (divide)
-            Ok(v / 10_i128.pow((-input_scale) as u32))
+            Ok(ParsedDecimal::Int128(
+                v / 10_i128.pow((-input_scale) as u32),
+            ))
+        }
+    }
+}
+
+/// Parse large decimal values using BigInt when they would overflow i128
+fn parse_large_decimal_with_bigint(s: &str, input_scale: i8) -> Result<ParsedDecimal, MagnusError> {
+    use num::BigInt;
+    use std::str::FromStr;
+
+    // Parse the input string as a BigInt
+    let bigint = if let Some(e_pos) = s.to_lowercase().find('e') {
+        // Handle scientific notation
+        let base = &s[0..e_pos];
+        let exp = &s[e_pos + 1..];
+
+        let exp_val = exp.parse::<i32>().map_err(|e| {
+            MagnusError::new(
+                magnus::exception::type_error(),
+                format!("Failed to parse exponent '{}': {}", exp, e),
+            )
+        })?;
+
+        // Parse base as BigInt
+        let base_bigint = if let Some(decimal_pos) = base.find('.') {
+            let mut base_without_point = base.to_string();
+            base_without_point.remove(decimal_pos);
+            let base_scale = base.len() - decimal_pos - 1;
+
+            let bigint = BigInt::from_str(&base_without_point).map_err(|e| {
+                MagnusError::new(
+                    magnus::exception::type_error(),
+                    format!("Failed to parse decimal base '{}': {}", base, e),
+                )
+            })?;
+
+            // Adjust for the decimal point
+            let effective_exp = exp_val - base_scale as i32;
+
+            if effective_exp > 0 {
+                bigint * BigInt::from(10).pow(effective_exp as u32)
+            } else if effective_exp < 0 {
+                bigint / BigInt::from(10).pow((-effective_exp) as u32)
+            } else {
+                bigint
+            }
+        } else {
+            let bigint = BigInt::from_str(base).map_err(|e| {
+                MagnusError::new(
+                    magnus::exception::type_error(),
+                    format!("Failed to parse decimal base '{}': {}", base, e),
+                )
+            })?;
+
+            if exp_val > 0 {
+                bigint * BigInt::from(10).pow(exp_val as u32)
+            } else if exp_val < 0 {
+                bigint / BigInt::from(10).pow((-exp_val) as u32)
+            } else {
+                bigint
+            }
+        };
+
+        base_bigint
+    } else if let Some(decimal_pos) = s.find('.') {
+        // Handle decimal point
+        let mut s_without_point = s.to_string();
+        s_without_point.remove(decimal_pos);
+
+        let actual_scale = s.len() - decimal_pos - 1;
+        let bigint = BigInt::from_str(&s_without_point).map_err(|e| {
+            MagnusError::new(
+                magnus::exception::type_error(),
+                format!("Failed to parse decimal string '{}': {}", s, e),
+            )
+        })?;
+
+        // Adjust for scale difference
+        let scale_diff = actual_scale as i8 - input_scale;
+
+        if scale_diff > 0 {
+            bigint / BigInt::from(10).pow(scale_diff as u32)
+        } else if scale_diff < 0 {
+            bigint * BigInt::from(10).pow((-scale_diff) as u32)
+        } else {
+            bigint
+        }
+    } else {
+        // Plain integer
+        let bigint = BigInt::from_str(s).map_err(|e| {
+            MagnusError::new(
+                magnus::exception::type_error(),
+                format!("Failed to parse integer string '{}': {}", s, e),
+            )
+        })?;
+
+        if input_scale > 0 {
+            bigint * BigInt::from(10).pow(input_scale as u32)
+        } else if input_scale < 0 {
+            bigint / BigInt::from(10).pow((-input_scale) as u32)
+        } else {
+            bigint
         }
+    };
+
+    // Convert BigInt to bytes and then to i256
+    let bytes = bigint.to_signed_bytes_le();
+
+    if bytes.len() <= 16 {
+        // Fits in i128
+        let mut buf = if bigint.sign() == num::bigint::Sign::Minus {
+            [0xff; 16]
+        } else {
+            [0; 16]
+        };
+        buf[..bytes.len()].copy_from_slice(&bytes);
+
+        Ok(ParsedDecimal::Int128(i128::from_le_bytes(buf)))
+    } else if bytes.len() <= 32 {
+        // Fits in i256
+        let mut buf = if bigint.sign() == num::bigint::Sign::Minus {
+            [0xff; 32]
+        } else {
+            [0; 32]
+        };
+        buf[..bytes.len()].copy_from_slice(&bytes);
+
+        Ok(ParsedDecimal::Int256(arrow_buffer::i256::from_le_bytes(
+            buf,
+        )))
+    } else {
+        Err(MagnusError::new(
+            magnus::exception::range_error(),
+            format!("Decimal value '{}' is too large to fit in 256 bits", s),
+        ))
     }
 }
 
-fn convert_to_decimal128(value: Value, scale: i8) -> Result<ParquetValue, MagnusError> {
+fn convert_to_decimal(value: Value, scale: i8) -> Result<ParquetValue, MagnusError> {
     // Get the decimal string based on the type of value
     let s = if unsafe { value.classname() } == "BigDecimal" {
         value
@@ -614,7 +782,10 @@ fn convert_to_decimal128(value: Value, scale: i8) -> Result<ParquetValue, Magnus
 
     // Use our unified parser to convert the string to a decimal value with scaling
     match parse_decimal_string(&s, scale) {
-        Ok(decimal_value) => Ok(ParquetValue::Decimal128(decimal_value, scale)),
+        Ok(decimal_value) => match decimal_value {
+            ParsedDecimal::Int128(v) => Ok(ParquetValue::Decimal128(v, scale)),
+            ParsedDecimal::Int256(v) => Ok(ParquetValue::Decimal256(v, scale)),
+        },
         Err(e) => Err(MagnusError::new(
             magnus::exception::type_error(),
             format!(
@@ -731,6 +902,52 @@ impl<'a> TryFrom<ArrayWrapper<'a>> for ParquetValueVec {
             }
             DataType::Date32 => impl_numeric_array_conversion!(column.array, Date32Array, Date32),
             DataType::Date64 => impl_numeric_array_conversion!(column.array, Date64Array, Date64),
+            DataType::Decimal128(_precision, scale) => {
+                let array = downcast_array::<Decimal128Array>(column.array);
+                Ok(ParquetValueVec(if array.is_nullable() {
+                    array
+                        .values()
+                        .iter()
+                        .enumerate()
+                        .map(|(i, x)| {
+                            if array.is_null(i) {
+                                ParquetValue::Null
+                            } else {
+                                ParquetValue::Decimal128(*x, *scale)
+                            }
+                        })
+                        .collect()
+                } else {
+                    array
+                        .values()
+                        .iter()
+                        .map(|x| ParquetValue::Decimal128(*x, *scale))
+                        .collect()
+                }))
+            }
+            DataType::Decimal256(_precision, scale) => {
+                let array = downcast_array::<Decimal256Array>(column.array);
+                Ok(ParquetValueVec(if array.is_nullable() {
+                    array
+                        .values()
+                        .iter()
+                        .enumerate()
+                        .map(|(i, x)| {
+                            if array.is_null(i) {
+                                ParquetValue::Null
+                            } else {
+                                ParquetValue::Decimal256(*x, *scale)
+                            }
+                        })
+                        .collect()
+                } else {
+                    array
+                        .values()
+                        .iter()
+                        .map(|x| ParquetValue::Decimal256(*x, *scale))
+                        .collect()
+                }))
+            }
             DataType::Timestamp(TimeUnit::Second, tz) => {
                 impl_timestamp_array_conversion!(
                     column.array,

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

@@ -22,6 +22,19 @@ pub fn format_decimal_with_i8_scale<T: std::fmt::Display>(value: T, scale: i8) -
     }
 }
 
+/// Format i256 decimal value with appropriate scale for BigDecimal conversion
+/// Uses bytes conversion to preserve full precision
+pub fn format_i256_decimal_with_scale(
+    value: arrow_buffer::i256,
+    scale: i8,
+) -> Result<String, ParquetGemError> {
+    // Convert i256 to big-endian bytes
+    let bytes = value.to_be_bytes();
+
+    // Use the existing bytes_to_decimal function which handles full precision
+    bytes_to_decimal(&bytes, scale as i32)
+}
+
 /// Format decimal value with appropriate scale for BigDecimal conversion
 /// Handles positive and negative scales correctly for i32 scale
 pub fn format_decimal_with_i32_scale<T: std::fmt::Display>(value: T, scale: i32) -> String {
@@ -35,7 +48,7 @@ pub fn format_decimal_with_i32_scale<T: std::fmt::Display>(value: T, scale: i32)
 }
 
 /// Convert arbitrary-length big-endian byte array to decimal string
-/// Supports byte arrays from 1 to 16 bytes in length
+/// Supports byte arrays from 1 to 32 bytes in length
 fn bytes_to_decimal(bytes: &[u8], scale: i32) -> Result<String, ParquetGemError> {
     match bytes.len() {
         0 => Err(ParquetGemError::InvalidDecimal(
@@ -50,34 +63,34 @@ fn bytes_to_decimal(bytes: &[u8], scale: i32) -> Result<String, ParquetGemError>
             // For 2 bytes, use i16
             let mut value: i16 = 0;
             let is_negative = bytes[0] & 0x80 != 0;
-            
+
             for &byte in bytes {
                 value = (value << 8) | (byte as i16);
             }
-            
+
             // Sign extend if negative
             if is_negative {
                 let shift = 16 - (bytes.len() * 8);
                 value = (value << shift) >> shift;
             }
-            
+
             Ok(format_decimal_with_i32_scale(value, scale))
         }
         3..=4 => {
             // For 3-4 bytes, use i32
             let mut value: i32 = 0;
             let is_negative = bytes[0] & 0x80 != 0;
-            
+
             for &byte in bytes {
                 value = (value << 8) | (byte as i32);
             }
-            
+
             // Sign extend if negative
             if is_negative {
                 let shift = 32 - (bytes.len() * 8);
                 value = (value << shift) >> shift;
             }
-            
+
             Ok(format_decimal_with_i32_scale(value, scale))
         }
         5..=8 => {
@@ -114,8 +127,79 @@ fn bytes_to_decimal(bytes: &[u8], scale: i32) -> Result<String, ParquetGemError>
 
             Ok(format_decimal_with_i32_scale(value, scale))
         }
+        17..=32 => {
+            // For 17-32 bytes, we need arbitrary precision handling
+            // Check if the number is negative (MSB of first byte)
+            let is_negative = bytes[0] & 0x80 != 0;
+
+            if is_negative {
+                // For negative numbers, we need to compute two's complement
+                // First, invert all bits
+                let mut inverted = Vec::with_capacity(bytes.len());
+                for &byte in bytes {
+                    inverted.push(!byte);
+                }
+
+                // Then add 1
+                let mut carry = 1u8;
+                for i in (0..inverted.len()).rev() {
+                    let (sum, new_carry) = inverted[i].overflowing_add(carry);
+                    inverted[i] = sum;
+                    carry = if new_carry { 1 } else { 0 };
+                }
+
+                // Convert to decimal string
+                let mut result = String::new();
+                let mut remainder = inverted;
+
+                // Repeatedly divide by 10 to get decimal digits
+                while !remainder.iter().all(|&b| b == 0) {
+                    let mut carry = 0u16;
+                    for i in 0..remainder.len() {
+                        let temp = (carry << 8) | (remainder[i] as u16);
+                        remainder[i] = (temp / 10) as u8;
+                        carry = temp % 10;
+                    }
+                    result.push_str(&carry.to_string());
+                }
+
+                // The digits are in reverse order
+                if result.is_empty() {
+                    result = "0".to_string();
+                } else {
+                    result = result.chars().rev().collect();
+                }
+
+                // Add negative sign and format with scale
+                Ok(format_decimal_with_i32_scale(format!("-{}", result), scale))
+            } else {
+                // For positive numbers, direct conversion
+                let mut result = String::new();
+                let mut remainder = bytes.to_vec();
+
+                // Repeatedly divide by 10 to get decimal digits
+                while !remainder.iter().all(|&b| b == 0) {
+                    let mut carry = 0u16;
+                    for i in 0..remainder.len() {
+                        let temp = (carry << 8) | (remainder[i] as u16);
+                        remainder[i] = (temp / 10) as u8;
+                        carry = temp % 10;
+                    }
+                    result.push_str(&carry.to_string());
+                }
+
+                // The digits are in reverse order
+                if result.is_empty() {
+                    result = "0".to_string();
+                } else {
+                    result = result.chars().rev().collect();
+                }
+
+                Ok(format_decimal_with_i32_scale(result, scale))
+            }
+        }
         _ => Err(ParquetGemError::InvalidDecimal(format!(
-            "Unsupported decimal byte array size: {}",
+            "Unsupported decimal byte array size: {} (maximum 32 bytes)",
             bytes.len()
         ))),
     }