parquet 0.5.8 → 0.5.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c01534e1b898294b050175a11a0f4ca09ca088c24b6f496e470185427c855ff4
-  data.tar.gz: 0d9888f96914433267bce8406fdf9064e7bcf94c8840c82ca980385798ac1203
+  metadata.gz: f1a1f7c250b960dbe334145a537e865889fbc759e7b8bfbafcbadc77689972cd
+  data.tar.gz: 22116ec0b9fe89f0ad08a3674267bd00b141170b889091b476f3aab0d6be88a8
 SHA512:
-  metadata.gz: 011b1d7425843ee32fb7494825f5d32f3d7be2d06082c639622ac8b00865b3ea5f13057c03024690b14950c235b0882d1ae1a7dbd0c00756f32f099ed8c64289
-  data.tar.gz: 5ff4cd63dc21844a68a26bd2ae5e428b64abf6a8165de314ddc674af27b5e18e3d4303d02ba1c2631cb35498a93d2466e99aae0d267e8000380ef26105f10310
+  metadata.gz: ef8485d03247dd0d31993a774117669c1aaef5b875e7cb5c6f4c53e237a72fb81113ea35251426a21ea1ba24f8ae568bd2c3a158e6a45ce2416a308251d0f467
+  data.tar.gz: 672f38dfbf703dae996283fba8d137529e3089f569797df87feaac32fb0f956ea7c4d7ae57032715d1a21bd5bfa4dd728c2a3fe80174fb5fc0abdef51c73110a

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

@@ -32,7 +32,6 @@ use arrow_schema::{DataType, TimeUnit};
 use magnus::{value::ReprValue, Error as MagnusError, IntoValue, Ruby, Value};
 use parquet::data_type::Decimal;
 use parquet::record::Field;
-use std::array::TryFromSliceError;
 use std::{collections::HashMap, hash::BuildHasher, sync::Arc};
 
 use crate::header_cache::StringCacheKey;
@@ -60,7 +59,7 @@ pub enum ParquetGemError {
     #[error("Jiff error: {0}")]
     Jiff(#[from] jiff::Error),
     #[error("Failed to cast slice to array: {0}")]
-    InvalidDecimal(#[from] TryFromSliceError),
+    InvalidDecimal(String),
     #[error("Failed to parse UUID: {0}")]
     UuidError(#[from] uuid::Error),
 }

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

@@ -34,6 +34,93 @@ 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
+fn bytes_to_decimal(bytes: &[u8], scale: i32) -> Result<String, ParquetGemError> {
+    match bytes.len() {
+        0 => Err(ParquetGemError::InvalidDecimal(
+            "Empty byte array for decimal".to_string(),
+        )),
+        1 => {
+            // For 1 byte, use i8
+            let value = bytes[0] as i8;
+            Ok(format_decimal_with_i32_scale(value, scale))
+        }
+        2 => {
+            // 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 => {
+            // For 5-8 bytes, use i64
+            let mut value: i64 = 0;
+            let is_negative = bytes[0] & 0x80 != 0;
+
+            for &byte in bytes {
+                value = (value << 8) | (byte as i64);
+            }
+
+            // Sign extend if negative
+            if is_negative {
+                let shift = 64 - (bytes.len() * 8);
+                value = (value << shift) >> shift;
+            }
+
+            Ok(format_decimal_with_i32_scale(value, scale))
+        }
+        9..=16 => {
+            // For 9-16 bytes, use i128
+            let mut value: i128 = 0;
+            let is_negative = bytes[0] & 0x80 != 0;
+
+            for &byte in bytes {
+                value = (value << 8) | (byte as i128);
+            }
+
+            // Sign extend if negative
+            if is_negative {
+                let shift = 128 - (bytes.len() * 8);
+                value = (value << shift) >> shift;
+            }
+
+            Ok(format_decimal_with_i32_scale(value, scale))
+        }
+        _ => Err(ParquetGemError::InvalidDecimal(format!(
+            "Unsupported decimal byte array size: {}",
+            bytes.len()
+        ))),
+    }
+}
+
 #[derive(Debug)]
 pub enum RowRecord<S: BuildHasher + Default> {
     Vec(Vec<ParquetField>),
@@ -282,32 +369,7 @@ impl TryIntoValue for ParquetField {
                         format_decimal_with_i32_scale(unscaled, scale)
                     }
                     Decimal::Bytes { value, scale, .. } => {
-                        match value.len() {
-                            4 => {
-                                // value is a byte array containing the bytes for an i32 value in big endian order
-                                let casted = value.as_bytes()[..4].try_into()?;
-                                let unscaled = i32::from_be_bytes(casted);
-                                format_decimal_with_i32_scale(unscaled, scale)
-                            }
-                            8 => {
-                                // value is a byte array containing the bytes for an i64 value in big endian order
-                                let casted = value.as_bytes()[..8].try_into()?;
-                                let unscaled = i64::from_be_bytes(casted);
-                                format_decimal_with_i32_scale(unscaled, scale)
-                            }
-                            16 => {
-                                // value is a byte array containing the bytes for an i128 value in big endian order
-                                let casted = value.as_bytes()[..16].try_into()?;
-                                let unscaled = i128::from_be_bytes(casted);
-                                format_decimal_with_i32_scale(unscaled, scale)
-                            }
-                            _ => {
-                                unimplemented!(
-                                    "Unsupported decimal byte array size: {}",
-                                    value.len()
-                                );
-                            }
-                        }
+                        bytes_to_decimal(value.as_bytes(), scale)?
                     }
                 };
 

data/lib/parquet/version.rb

@@ -1,3 +1,3 @@
 module Parquet
-  VERSION = "0.5.8"
+  VERSION = "0.5.9"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: parquet
 version: !ruby/object:Gem::Version
-  version: 0.5.8
+  version: 0.5.9
 platform: ruby
 authors:
 - Nathan Jaremko
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-05-26 00:00:00.000000000 Z
+date: 2025-06-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rb_sys