parquet 0.0.4 → 0.2.5

data/ext/parquet/src/{types.rs → types/parquet_value.rs}

@@ -1,232 +1,8 @@
-use std::{borrow::Cow, collections::HashMap, hash::BuildHasher, sync::Arc};
+use crate::{impl_date_conversion, impl_timestamp_array_conversion, impl_timestamp_conversion};
 
-use arrow_array::cast::downcast_array;
-use arrow_array::{
-    Array, BinaryArray, BooleanArray, Date32Array, Date64Array, Float16Array, Float32Array,
-    Float64Array, Int16Array, Int32Array, Int64Array, Int8Array, ListArray, NullArray, StringArray,
-    StructArray, TimestampMicrosecondArray, TimestampMillisecondArray, TimestampNanosecondArray,
-    TimestampSecondArray, UInt16Array, UInt32Array, UInt64Array, UInt8Array,
-};
-use arrow_schema::{DataType, TimeUnit};
-use itertools::Itertools;
-use magnus::{value::ReprValue, IntoValue, Ruby, Value};
-use parquet::data_type::Decimal;
-use parquet::record::Field;
-
-use crate::header_cache::StringCacheKey;
-
-#[derive(Debug)]
-pub enum RowRecord<S: BuildHasher + Default> {
-    Vec(Vec<ParquetField>),
-    Map(HashMap<StringCacheKey, ParquetField, S>),
-}
-
-#[derive(Debug)]
-pub enum ColumnRecord<S: BuildHasher + Default> {
-    Vec(Vec<Vec<ParquetValue>>),
-    Map(HashMap<StringCacheKey, Vec<ParquetValue>, S>),
-}
-
-impl<S: BuildHasher + Default> IntoValue for RowRecord<S> {
-    fn into_value_with(self, handle: &Ruby) -> Value {
-        match self {
-            RowRecord::Vec(vec) => {
-                let ary = handle.ary_new_capa(vec.len());
-                vec.into_iter().try_for_each(|v| ary.push(v)).unwrap();
-                handle.into_value(ary)
-            }
-            RowRecord::Map(map) => {
-                let hash = handle.hash_new_capa(map.len());
-
-                let mut values: [Value; 128] = [handle.qnil().as_value(); 128];
-                let mut i = 0;
-
-                for chunk in &map.into_iter().chunks(64) {
-                    // Reduced to 64 to ensure space for pairs
-                    for (k, v) in chunk {
-                        if i + 1 >= values.len() {
-                            // Bulk insert current batch if array is full
-                            hash.bulk_insert(&values[..i]).unwrap();
-                            values[..i].fill(handle.qnil().as_value());
-                            i = 0;
-                        }
-                        values[i] = handle.into_value(k);
-                        values[i + 1] = handle.into_value(v);
-                        i += 2;
-                    }
-                    // Insert any remaining pairs
-                    if i > 0 {
-                        hash.bulk_insert(&values[..i]).unwrap();
-                        values[..i].fill(handle.qnil().as_value());
-                        i = 0;
-                    }
-                }
-
-                hash.into_value_with(handle)
-            }
-        }
-    }
-}
-
-impl<S: BuildHasher + Default> IntoValue for ColumnRecord<S> {
-    fn into_value_with(self, handle: &Ruby) -> Value {
-        match self {
-            ColumnRecord::Vec(vec) => {
-                let ary = handle.ary_new_capa(vec.len());
-                vec.into_iter()
-                    .try_for_each(|v| {
-                        let nested_ary = handle.ary_new_capa(v.len());
-                        v.into_iter().try_for_each(|v| nested_ary.push(v)).unwrap();
-                        ary.push(nested_ary.into_value_with(handle))
-                    })
-                    .unwrap();
-                ary.into_value_with(handle)
-            }
-            ColumnRecord::Map(map) => {
-                let hash = handle.hash_new_capa(map.len());
-
-                let mut values: [Value; 128] = [handle.qnil().as_value(); 128];
-                let mut i = 0;
-
-                for chunk in &map.into_iter().chunks(64) {
-                    // Reduced to 64 to ensure space for pairs
-                    for (k, v) in chunk {
-                        if i + 1 >= values.len() {
-                            // Bulk insert current batch if array is full
-                            hash.bulk_insert(&values[..i]).unwrap();
-                            values[..i].fill(handle.qnil().as_value());
-                            i = 0;
-                        }
-                        values[i] = handle.into_value(k);
-                        let ary = handle.ary_new_capa(v.len());
-                        v.into_iter().try_for_each(|v| ary.push(v)).unwrap();
-                        values[i + 1] = handle.into_value(ary);
-                        i += 2;
-                    }
-                    // Insert any remaining pairs
-                    if i > 0 {
-                        hash.bulk_insert(&values[..i]).unwrap();
-                        values[..i].fill(handle.qnil().as_value());
-                        i = 0;
-                    }
-                }
-
-                hash.into_value_with(handle)
-            }
-        }
-    }
-}
+use super::*;
 
 #[derive(Debug, Clone)]
-pub struct CowValue<'a>(pub Cow<'a, str>);
-
-impl<'a> IntoValue for CowValue<'a> {
-    fn into_value_with(self, handle: &Ruby) -> Value {
-        self.0.into_value_with(handle)
-    }
-}
-
-#[derive(Debug)]
-pub struct ParquetField(pub Field);
-
-impl IntoValue for ParquetField {
-    fn into_value_with(self, handle: &Ruby) -> Value {
-        match self.0 {
-            Field::Null => handle.qnil().as_value(),
-            Field::Bool(b) => b.into_value_with(handle),
-            Field::Short(s) => s.into_value_with(handle),
-            Field::Int(i) => i.into_value_with(handle),
-            Field::Long(l) => l.into_value_with(handle),
-            Field::UByte(ub) => ub.into_value_with(handle),
-            Field::UShort(us) => us.into_value_with(handle),
-            Field::UInt(ui) => ui.into_value_with(handle),
-            Field::ULong(ul) => ul.into_value_with(handle),
-            Field::Float16(f) => f32::from(f).into_value_with(handle),
-            Field::Float(f) => f.into_value_with(handle),
-            Field::Double(d) => d.into_value_with(handle),
-            Field::Str(s) => s.into_value_with(handle),
-            Field::Byte(b) => b.into_value_with(handle),
-            Field::Bytes(b) => handle.str_from_slice(b.data()).as_value(),
-            Field::Date(d) => {
-                let ts = jiff::Timestamp::from_second((d as i64) * 86400).unwrap();
-                let formatted = ts.strftime("%Y-%m-%d").to_string();
-                formatted.into_value_with(handle)
-            }
-            Field::TimestampMillis(ts) => {
-                let ts = jiff::Timestamp::from_millisecond(ts).unwrap();
-                let time_class = handle.class_time();
-                time_class
-                    .funcall::<_, _, Value>("parse", (ts.to_string(),))
-                    .unwrap()
-                    .into_value_with(handle)
-            }
-            Field::TimestampMicros(ts) => {
-                let ts = jiff::Timestamp::from_microsecond(ts).unwrap();
-                let time_class = handle.class_time();
-                time_class
-                    .funcall::<_, _, Value>("parse", (ts.to_string(),))
-                    .unwrap()
-                    .into_value_with(handle)
-            }
-            Field::ListInternal(list) => {
-                let elements = list.elements();
-                let ary = handle.ary_new_capa(elements.len());
-                elements
-                    .iter()
-                    .try_for_each(|e| ary.push(ParquetField(e.clone()).into_value_with(handle)))
-                    .unwrap();
-                ary.into_value_with(handle)
-            }
-            Field::MapInternal(map) => {
-                let entries = map.entries();
-                let hash = handle.hash_new_capa(entries.len());
-                entries
-                    .iter()
-                    .try_for_each(|(k, v)| {
-                        hash.aset(
-                            ParquetField(k.clone()).into_value_with(handle),
-                            ParquetField(v.clone()).into_value_with(handle),
-                        )
-                    })
-                    .unwrap();
-                hash.into_value_with(handle)
-            }
-            Field::Decimal(d) => {
-                let value = match d {
-                    Decimal::Int32 { value, scale, .. } => {
-                        let unscaled = i32::from_be_bytes(value);
-                        format!("{}e-{}", unscaled, scale)
-                    }
-                    Decimal::Int64 { value, scale, .. } => {
-                        let unscaled = i64::from_be_bytes(value);
-                        format!("{}e-{}", unscaled, scale)
-                    }
-                    Decimal::Bytes { value, scale, .. } => {
-                        // Convert bytes to string representation of unscaled value
-                        let unscaled = String::from_utf8_lossy(value.data());
-                        format!("{}e-{}", unscaled, scale)
-                    }
-                };
-                handle.eval(&format!("BigDecimal(\"{value}\")")).unwrap()
-            }
-            Field::Group(row) => {
-                let hash = handle.hash_new();
-                row.get_column_iter()
-                    .try_for_each(|(k, v)| {
-                        hash.aset(
-                            k.clone().into_value_with(handle),
-                            ParquetField(v.clone()).into_value_with(handle),
-                        )
-                    })
-                    .unwrap();
-                hash.into_value_with(handle)
-            }
-        }
-    }
-}
-
-#[allow(dead_code)]
-#[derive(Clone, Debug)]
 pub enum ParquetValue {
     Int8(i8),
     Int16(i16),
@@ -285,6 +61,175 @@ impl PartialEq for ParquetValue {
 
 impl Eq for ParquetValue {}
 
+impl std::hash::Hash for ParquetValue {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        match self {
+            ParquetValue::Int8(i) => i.hash(state),
+            ParquetValue::Int16(i) => i.hash(state),
+            ParquetValue::Int32(i) => i.hash(state),
+            ParquetValue::Int64(i) => i.hash(state),
+            ParquetValue::UInt8(i) => i.hash(state),
+            ParquetValue::UInt16(i) => i.hash(state),
+            ParquetValue::UInt32(i) => i.hash(state),
+            ParquetValue::UInt64(i) => i.hash(state),
+            ParquetValue::Float16(f) => f.to_bits().hash(state),
+            ParquetValue::Float32(f) => f.to_bits().hash(state),
+            ParquetValue::Float64(f) => f.to_bits().hash(state),
+            ParquetValue::Boolean(b) => b.hash(state),
+            ParquetValue::String(s) => s.hash(state),
+            ParquetValue::Bytes(b) => b.hash(state),
+            ParquetValue::Date32(d) => d.hash(state),
+            ParquetValue::Date64(d) => d.hash(state),
+            ParquetValue::TimestampSecond(ts, tz) => {
+                ts.hash(state);
+                tz.hash(state);
+            }
+            ParquetValue::TimestampMillis(ts, tz) => {
+                ts.hash(state);
+                tz.hash(state);
+            }
+            ParquetValue::TimestampMicros(ts, tz) => {
+                ts.hash(state);
+                tz.hash(state);
+            }
+            ParquetValue::TimestampNanos(ts, tz) => {
+                ts.hash(state);
+                tz.hash(state);
+            }
+            ParquetValue::List(l) => l.hash(state),
+            ParquetValue::Map(_m) => panic!("Map is not hashable"),
+            ParquetValue::Null => 0_i32.hash(state),
+        }
+    }
+}
+
+impl IntoValue for ParquetValue {
+    fn into_value_with(self, handle: &Ruby) -> Value {
+        match self {
+            ParquetValue::Int8(i) => i.into_value_with(handle),
+            ParquetValue::Int16(i) => i.into_value_with(handle),
+            ParquetValue::Int32(i) => i.into_value_with(handle),
+            ParquetValue::Int64(i) => i.into_value_with(handle),
+            ParquetValue::UInt8(i) => i.into_value_with(handle),
+            ParquetValue::UInt16(i) => i.into_value_with(handle),
+            ParquetValue::UInt32(i) => i.into_value_with(handle),
+            ParquetValue::UInt64(i) => i.into_value_with(handle),
+            ParquetValue::Float16(f) => f.into_value_with(handle),
+            ParquetValue::Float32(f) => f.into_value_with(handle),
+            ParquetValue::Float64(f) => f.into_value_with(handle),
+            ParquetValue::Boolean(b) => b.into_value_with(handle),
+            ParquetValue::String(s) => s.into_value_with(handle),
+            ParquetValue::Bytes(b) => handle.str_from_slice(&b).as_value(),
+            ParquetValue::Date32(d) => impl_date_conversion!(d, handle),
+            ParquetValue::Date64(d) => impl_date_conversion!(d, handle),
+            timestamp @ ParquetValue::TimestampSecond(_, _) => {
+                impl_timestamp_conversion!(timestamp, TimestampSecond, handle)
+            }
+            timestamp @ ParquetValue::TimestampMillis(_, _) => {
+                impl_timestamp_conversion!(timestamp, TimestampMillis, handle)
+            }
+            timestamp @ ParquetValue::TimestampMicros(_, _) => {
+                impl_timestamp_conversion!(timestamp, TimestampMicros, handle)
+            }
+            timestamp @ ParquetValue::TimestampNanos(_, _) => {
+                impl_timestamp_conversion!(timestamp, TimestampNanos, handle)
+            }
+            ParquetValue::List(l) => {
+                let ary = handle.ary_new_capa(l.len());
+                l.into_iter()
+                    .try_for_each(|v| ary.push(v.into_value_with(handle)))
+                    .unwrap();
+                ary.into_value_with(handle)
+            }
+            ParquetValue::Map(m) => {
+                let hash = handle.hash_new_capa(m.len());
+                m.into_iter()
+                    .try_for_each(|(k, v)| {
+                        hash.aset(k.into_value_with(handle), v.into_value_with(handle))
+                    })
+                    .unwrap();
+                hash.into_value_with(handle)
+            }
+            ParquetValue::Null => handle.qnil().as_value(),
+        }
+    }
+}
+
+impl ParquetValue {
+    pub fn from_value(value: Value, type_: &ParquetSchemaType) -> Result<Self, MagnusError> {
+        match type_ {
+            ParquetSchemaType::Int8 => {
+                let v = NumericConverter::<i8>::convert_with_string_fallback(value)?;
+                Ok(ParquetValue::Int8(v))
+            }
+            ParquetSchemaType::Int16 => {
+                let v = NumericConverter::<i16>::convert_with_string_fallback(value)?;
+                Ok(ParquetValue::Int16(v))
+            }
+            ParquetSchemaType::Int32 => {
+                let v = NumericConverter::<i32>::convert_with_string_fallback(value)?;
+                Ok(ParquetValue::Int32(v))
+            }
+            ParquetSchemaType::Int64 => {
+                let v = NumericConverter::<i64>::convert_with_string_fallback(value)?;
+                Ok(ParquetValue::Int64(v))
+            }
+            ParquetSchemaType::UInt8 => {
+                let v = NumericConverter::<u8>::convert_with_string_fallback(value)?;
+                Ok(ParquetValue::UInt8(v))
+            }
+            ParquetSchemaType::UInt16 => {
+                let v = NumericConverter::<u16>::convert_with_string_fallback(value)?;
+                Ok(ParquetValue::UInt16(v))
+            }
+            ParquetSchemaType::UInt32 => {
+                let v = NumericConverter::<u32>::convert_with_string_fallback(value)?;
+                Ok(ParquetValue::UInt32(v))
+            }
+            ParquetSchemaType::UInt64 => {
+                let v = NumericConverter::<u64>::convert_with_string_fallback(value)?;
+                Ok(ParquetValue::UInt64(v))
+            }
+            ParquetSchemaType::Float => {
+                let v = NumericConverter::<f32>::convert_with_string_fallback(value)?;
+                Ok(ParquetValue::Float32(v))
+            }
+            ParquetSchemaType::Double => {
+                let v = NumericConverter::<f64>::convert_with_string_fallback(value)?;
+                Ok(ParquetValue::Float64(v))
+            }
+            ParquetSchemaType::String => {
+                let v = String::try_convert(value)?;
+                Ok(ParquetValue::String(v))
+            }
+            ParquetSchemaType::Binary => {
+                let v = convert_to_binary(value)?;
+                Ok(ParquetValue::Bytes(v))
+            }
+            ParquetSchemaType::Boolean => {
+                let v = convert_to_boolean(value)?;
+                Ok(ParquetValue::Boolean(v))
+            }
+            ParquetSchemaType::Date32 => {
+                let v = convert_to_date32(value)?;
+                Ok(ParquetValue::Date32(v))
+            }
+            ParquetSchemaType::TimestampMillis => {
+                let v = convert_to_timestamp_millis(value)?;
+                Ok(ParquetValue::TimestampMillis(v, None))
+            }
+            ParquetSchemaType::TimestampMicros => {
+                let v = convert_to_timestamp_micros(value)?;
+                Ok(ParquetValue::TimestampMicros(v, None))
+            }
+            ParquetSchemaType::List(_) | ParquetSchemaType::Map(_) => Err(MagnusError::new(
+                magnus::exception::type_error(),
+                "Nested lists and maps are not supported",
+            )),
+        }
+    }
+}
+
 #[derive(Debug)]
 pub struct ParquetValueVec(Vec<ParquetValue>);
 
@@ -319,7 +264,6 @@ impl TryFrom<Arc<dyn Array>> for ParquetValueVec {
     }
 }
 
-// Add macro for handling numeric array conversions
 macro_rules! impl_numeric_array_conversion {
     ($column:expr, $array_type:ty, $variant:ident) => {{
         let array = downcast_array::<$array_type>($column);
@@ -345,8 +289,6 @@ macro_rules! impl_numeric_array_conversion {
         }
     }};
 }
-
-// Add macro for handling boolean array conversions
 macro_rules! impl_boolean_array_conversion {
     ($column:expr, $array_type:ty, $variant:ident) => {{
         let array = downcast_array::<$array_type>($column);
@@ -373,33 +315,6 @@ macro_rules! impl_boolean_array_conversion {
     }};
 }
 
-// Add macro for handling timestamp array conversions
-macro_rules! impl_timestamp_array_conversion {
-    ($column:expr, $array_type:ty, $variant:ident, $tz:expr) => {{
-        let array = downcast_array::<$array_type>($column);
-        if array.is_nullable() {
-            array
-                .values()
-                .iter()
-                .enumerate()
-                .map(|(i, x)| {
-                    if array.is_null(i) {
-                        ParquetValue::Null
-                    } else {
-                        ParquetValue::$variant(*x, $tz.clone())
-                    }
-                })
-                .collect()
-        } else {
-            array
-                .values()
-                .iter()
-                .map(|x| ParquetValue::$variant(*x, $tz.clone()))
-                .collect()
-        }
-    }};
-}
-
 impl TryFrom<&dyn Array> for ParquetValueVec {
     type Error = String;
 
@@ -445,7 +360,6 @@ impl TryFrom<&dyn Array> for ParquetValueVec {
                     tz
                 )
             }
-            // Because f16 is unstable in Rust, we convert it to f32
             DataType::Float16 => {
                 let array = downcast_array::<Float16Array>(column);
                 if array.is_nullable() {
@@ -542,181 +456,3 @@ impl TryFrom<&dyn Array> for ParquetValueVec {
         Ok(ParquetValueVec(tmp_vec))
     }
 }
-
-impl std::hash::Hash for ParquetValue {
-    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-        match self {
-            ParquetValue::Int8(i) => i.hash(state),
-            ParquetValue::Int16(i) => i.hash(state),
-            ParquetValue::Int32(i) => i.hash(state),
-            ParquetValue::Int64(i) => i.hash(state),
-            ParquetValue::UInt8(i) => i.hash(state),
-            ParquetValue::UInt16(i) => i.hash(state),
-            ParquetValue::UInt32(i) => i.hash(state),
-            ParquetValue::UInt64(i) => i.hash(state),
-            ParquetValue::Float16(f) => f.to_bits().hash(state),
-            ParquetValue::Float32(f) => f.to_bits().hash(state),
-            ParquetValue::Float64(f) => f.to_bits().hash(state),
-            ParquetValue::Boolean(b) => b.hash(state),
-            ParquetValue::String(s) => s.hash(state),
-            ParquetValue::Bytes(b) => b.hash(state),
-            ParquetValue::Date32(d) => d.hash(state),
-            ParquetValue::Date64(d) => d.hash(state),
-            ParquetValue::TimestampSecond(ts, tz) => {
-                ts.hash(state);
-                tz.hash(state);
-            }
-            ParquetValue::TimestampMillis(ts, tz) => {
-                ts.hash(state);
-                tz.hash(state);
-            }
-            ParquetValue::TimestampMicros(ts, tz) => {
-                ts.hash(state);
-                tz.hash(state);
-            }
-            ParquetValue::TimestampNanos(ts, tz) => {
-                ts.hash(state);
-                tz.hash(state);
-            }
-            ParquetValue::List(l) => l.hash(state),
-            ParquetValue::Map(_m) => panic!("Map is not hashable"),
-            ParquetValue::Null => 0_i32.hash(state),
-        }
-    }
-}
-
-impl IntoValue for ParquetValue {
-    fn into_value_with(self, handle: &Ruby) -> Value {
-        match self {
-            ParquetValue::Int8(i) => i.into_value_with(handle),
-            ParquetValue::Int16(i) => i.into_value_with(handle),
-            ParquetValue::Int32(i) => i.into_value_with(handle),
-            ParquetValue::Int64(i) => i.into_value_with(handle),
-            ParquetValue::UInt8(i) => i.into_value_with(handle),
-            ParquetValue::UInt16(i) => i.into_value_with(handle),
-            ParquetValue::UInt32(i) => i.into_value_with(handle),
-            ParquetValue::UInt64(i) => i.into_value_with(handle),
-            ParquetValue::Float16(f) => f.into_value_with(handle),
-            ParquetValue::Float32(f) => f.into_value_with(handle),
-            ParquetValue::Float64(f) => f.into_value_with(handle),
-            ParquetValue::Boolean(b) => b.into_value_with(handle),
-            ParquetValue::String(s) => s.into_value_with(handle),
-            ParquetValue::Bytes(b) => b.into_value_with(handle),
-            ParquetValue::Date32(d) => {
-                let ts = jiff::Timestamp::from_second((d as i64) * 86400).unwrap();
-                let formatted = ts.strftime("%Y-%m-%d").to_string();
-                formatted.into_value_with(handle)
-            }
-            ParquetValue::Date64(d) => {
-                let ts = jiff::Timestamp::from_second((d as i64) * 86400).unwrap();
-                let formatted = ts.strftime("%Y-%m-%d").to_string();
-                formatted.into_value_with(handle)
-            }
-            ParquetValue::TimestampSecond(ts, tz) => {
-                let ts = parse_zoned_timestamp(&ParquetValue::TimestampSecond(ts, tz));
-                let time_class = handle.class_time();
-                time_class
-                    .funcall::<_, _, Value>("parse", (ts.to_string(),))
-                    .unwrap()
-                    .into_value_with(handle)
-            }
-            ParquetValue::TimestampMillis(ts, tz) => {
-                let ts = parse_zoned_timestamp(&ParquetValue::TimestampMillis(ts, tz));
-                let time_class = handle.class_time();
-                time_class
-                    .funcall::<_, _, Value>("parse", (ts.to_string(),))
-                    .unwrap()
-                    .into_value_with(handle)
-            }
-            ParquetValue::TimestampMicros(ts, tz) => {
-                let ts = parse_zoned_timestamp(&ParquetValue::TimestampMicros(ts, tz));
-                let time_class = handle.class_time();
-                time_class
-                    .funcall::<_, _, Value>("parse", (ts.to_string(),))
-                    .unwrap()
-                    .into_value_with(handle)
-            }
-            ParquetValue::TimestampNanos(ts, tz) => {
-                let ts = parse_zoned_timestamp(&ParquetValue::TimestampNanos(ts, tz));
-                let time_class = handle.class_time();
-                time_class
-                    .funcall::<_, _, Value>("parse", (ts.to_string(),))
-                    .unwrap()
-                    .into_value_with(handle)
-            }
-            ParquetValue::List(l) => {
-                let ary = handle.ary_new_capa(l.len());
-                l.into_iter()
-                    .try_for_each(|v| ary.push(v.into_value_with(handle)))
-                    .unwrap();
-                ary.into_value_with(handle)
-            }
-            ParquetValue::Map(m) => {
-                let hash = handle.hash_new_capa(m.len());
-                m.into_iter()
-                    .try_for_each(|(k, v)| {
-                        hash.aset(k.into_value_with(handle), v.into_value_with(handle))
-                    })
-                    .unwrap();
-                hash.into_value_with(handle)
-            }
-            ParquetValue::Null => handle.qnil().as_value(),
-        }
-    }
-}
-
-fn parse_zoned_timestamp(value: &ParquetValue) -> jiff::Timestamp {
-    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::TimestampNanos(ts, tz) => {
-            (jiff::Timestamp::from_nanosecond(*ts as i128).unwrap(), tz)
-        }
-        _ => panic!("Invalid timestamp value"),
-    };
-
-    // If timezone is provided, convert to zoned timestamp
-    if let Some(tz) = tz {
-        // Handle fixed offset timezones like "+09:00" first
-        if tz.starts_with('+') || tz.starts_with('-') {
-            // Parse the offset string into hours and minutes
-            let (hours, minutes) = if tz.len() >= 5 && tz.contains(':') {
-                // Format: "+09:00" or "-09:00"
-                let h = tz[1..3].parse::<i32>().unwrap_or(0);
-                let m = tz[4..6].parse::<i32>().unwrap_or(0);
-                (h, m)
-            } else if tz.len() >= 3 {
-                // Format: "+09" or "-09"
-                let h = tz[1..3].parse::<i32>().unwrap_or(0);
-                (h, 0)
-            } else {
-                (0, 0)
-            };
-
-            // Apply sign
-            let total_minutes = if tz.starts_with('-') {
-                -(hours * 60 + minutes)
-            } else {
-                hours * 60 + minutes
-            };
-
-            // Create fixed timezone
-            let tz = jiff::tz::TimeZone::fixed(jiff::tz::offset((total_minutes / 60) as i8));
-            ts.to_zoned(tz).timestamp()
-        } else {
-            // Try IANA timezone
-            match ts.intz(&tz) {
-                Ok(zoned) => zoned.timestamp(),
-                Err(_) => ts, // Fall back to UTC if timezone is invalid
-            }
-        }
-    } else {
-        // No timezone provided - treat as UTC
-        ts
-    }
-}