parquet 0.5.11 → 0.5.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 82528b663c4a577262db90b6d17ba473a81d0ea725ceba486b63a3619040fa73
-  data.tar.gz: 2e44daa9b4e36ef1503589daaa0815cbc3acee10c565d9942f6c0b6d35ced5f0
+  metadata.gz: 5f1b43212634fda95b699a725acd82761c5ab5fe4a51473c3bc1dc5eb9bf2226
+  data.tar.gz: 6dfdc2027a957673ad5591dc293624f138e1ef5ef6772ad06ef31b24ca8f360d
 SHA512:
-  metadata.gz: 418951253384f5492385fcb30fa5b0113b85d9bc51346b6abad16105c124d8869266943c1a29bc0879cfee4270b94d32fb99004e233c6ebde4a70e1d329435af
-  data.tar.gz: bc0db4ebb36add314253b5b9b946cc2c84f315d51ba7fefbead6c7de3b65a3f7752fa4e4cf0be19704405b390ae0106d8383e30791e7fac4a86a75141c214de1
+  metadata.gz: dcdbfdeb1be352af9aa1356f6d1a13070df84410d6f7b7eaa744d5b3dd62ba18004ee189be23566fc0b3a39e5c6c3548505a6783d65cdd69ff677f4cd2206d29
+  data.tar.gz: a9d4cad07d8d91edc48a9a7268ad53a24ffd9a1b83f0265c2f8194a73fed097d6c6f74398707f3c1f026978892a9f84273ae68bd619f41653341dbb39ef880ee

data/Cargo.lock

@@ -64,7 +64,7 @@ dependencies = [
 [[package]]
 name = "arrow-array"
 version = "55.1.0"
-source = "git+https://github.com/njaremko/arrow-rs?branch=nathan%2Ffix-time#a6a93f401a9a2aba72aa362822b50068f67ded42"
+source = "git+https://github.com/njaremko/arrow-rs?branch=nathan_06-24-remove_primitive_map_key_assertion_on_record_reader#2d8b0b99d70de81b96b76cfdc10faa20dc7aed4e"
 dependencies = [
  "ahash",
  "arrow-buffer",
@@ -79,7 +79,7 @@ dependencies = [
 [[package]]
 name = "arrow-buffer"
 version = "55.1.0"
-source = "git+https://github.com/njaremko/arrow-rs?branch=nathan%2Ffix-time#a6a93f401a9a2aba72aa362822b50068f67ded42"
+source = "git+https://github.com/njaremko/arrow-rs?branch=nathan_06-24-remove_primitive_map_key_assertion_on_record_reader#2d8b0b99d70de81b96b76cfdc10faa20dc7aed4e"
 dependencies = [
  "bytes",
  "half",
@@ -89,7 +89,7 @@ dependencies = [
 [[package]]
 name = "arrow-cast"
 version = "55.1.0"
-source = "git+https://github.com/njaremko/arrow-rs?branch=nathan%2Ffix-time#a6a93f401a9a2aba72aa362822b50068f67ded42"
+source = "git+https://github.com/njaremko/arrow-rs?branch=nathan_06-24-remove_primitive_map_key_assertion_on_record_reader#2d8b0b99d70de81b96b76cfdc10faa20dc7aed4e"
 dependencies = [
  "arrow-array",
  "arrow-buffer",
@@ -108,7 +108,7 @@ dependencies = [
 [[package]]
 name = "arrow-data"
 version = "55.1.0"
-source = "git+https://github.com/njaremko/arrow-rs?branch=nathan%2Ffix-time#a6a93f401a9a2aba72aa362822b50068f67ded42"
+source = "git+https://github.com/njaremko/arrow-rs?branch=nathan_06-24-remove_primitive_map_key_assertion_on_record_reader#2d8b0b99d70de81b96b76cfdc10faa20dc7aed4e"
 dependencies = [
  "arrow-buffer",
  "arrow-schema",
@@ -119,7 +119,7 @@ dependencies = [
 [[package]]
 name = "arrow-ipc"
 version = "55.1.0"
-source = "git+https://github.com/njaremko/arrow-rs?branch=nathan%2Ffix-time#a6a93f401a9a2aba72aa362822b50068f67ded42"
+source = "git+https://github.com/njaremko/arrow-rs?branch=nathan_06-24-remove_primitive_map_key_assertion_on_record_reader#2d8b0b99d70de81b96b76cfdc10faa20dc7aed4e"
 dependencies = [
  "arrow-array",
  "arrow-buffer",
@@ -132,12 +132,12 @@ dependencies = [
 [[package]]
 name = "arrow-schema"
 version = "55.1.0"
-source = "git+https://github.com/njaremko/arrow-rs?branch=nathan%2Ffix-time#a6a93f401a9a2aba72aa362822b50068f67ded42"
+source = "git+https://github.com/njaremko/arrow-rs?branch=nathan_06-24-remove_primitive_map_key_assertion_on_record_reader#2d8b0b99d70de81b96b76cfdc10faa20dc7aed4e"
 
 [[package]]
 name = "arrow-select"
 version = "55.1.0"
-source = "git+https://github.com/njaremko/arrow-rs?branch=nathan%2Ffix-time#a6a93f401a9a2aba72aa362822b50068f67ded42"
+source = "git+https://github.com/njaremko/arrow-rs?branch=nathan_06-24-remove_primitive_map_key_assertion_on_record_reader#2d8b0b99d70de81b96b76cfdc10faa20dc7aed4e"
 dependencies = [
  "ahash",
  "arrow-array",
@@ -867,7 +867,7 @@ dependencies = [
 [[package]]
 name = "parquet"
 version = "55.1.0"
-source = "git+https://github.com/njaremko/arrow-rs?branch=nathan%2Ffix-time#a6a93f401a9a2aba72aa362822b50068f67ded42"
+source = "git+https://github.com/njaremko/arrow-rs?branch=nathan_06-24-remove_primitive_map_key_assertion_on_record_reader#2d8b0b99d70de81b96b76cfdc10faa20dc7aed4e"
 dependencies = [
  "ahash",
  "arrow-array",

data/README.md

@@ -265,6 +265,7 @@ The following data types are supported in the schema:
 - `boolean`
 - `date32`
 - `timestamp_millis`, `timestamp_micros`
+- `time_millis`, `time_micros`
 
 ### Schema DSL for Complex Data Types
 

data/ext/parquet/Cargo.toml

@@ -11,16 +11,16 @@ rb-sys-env = "^0.2"
 
 [dependencies]
 ahash = "0.8"
-arrow-array = { git = "https://github.com/njaremko/arrow-rs", branch = "nathan/fix-time" }
-arrow-buffer = { git = "https://github.com/njaremko/arrow-rs", branch = "nathan/fix-time" }
-arrow-ipc = { git = "https://github.com/njaremko/arrow-rs", branch = "nathan/fix-time", features = ["lz4"] }
-arrow-schema = { git = "https://github.com/njaremko/arrow-rs", branch = "nathan/fix-time" }
+arrow-array = { git = "https://github.com/njaremko/arrow-rs", branch = "nathan_06-24-remove_primitive_map_key_assertion_on_record_reader" }
+arrow-buffer = { git = "https://github.com/njaremko/arrow-rs", branch = "nathan_06-24-remove_primitive_map_key_assertion_on_record_reader" }
+arrow-ipc = { git = "https://github.com/njaremko/arrow-rs", branch = "nathan_06-24-remove_primitive_map_key_assertion_on_record_reader", features = ["lz4"] }
+arrow-schema = { git = "https://github.com/njaremko/arrow-rs", branch = "nathan_06-24-remove_primitive_map_key_assertion_on_record_reader" }
 bytes = "^1.9"
 either = "1.9"
 itertools = "^0.14"
 jiff = "0.2"
 magnus = { version = "0.7", features = ["rb-sys"] }
-parquet = { git = "https://github.com/njaremko/arrow-rs", branch = "nathan/fix-time", features = ["json"] }
+parquet = { git = "https://github.com/njaremko/arrow-rs", branch = "nathan_06-24-remove_primitive_map_key_assertion_on_record_reader", features = ["json"] }
 rand = "0.9"
 rb-sys = "^0.9"
 simdutf8 = "0.1.5"

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

@@ -115,4 +115,6 @@ pub enum PrimitiveType {
     Date32,
     TimestampMillis,
     TimestampMicros,
+    TimeMillis,
+    TimeMicros,
 }

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

@@ -25,9 +25,9 @@ use arrow_array::cast::downcast_array;
 use arrow_array::{
     Array, BinaryArray, BooleanArray, Date32Array, Date64Array, Decimal128Array, Decimal256Array,
     Float16Array, Float32Array, Float64Array, Int16Array, Int32Array, Int64Array, Int8Array,
-    ListArray, NullArray, StringArray, StructArray, TimestampMicrosecondArray,
-    TimestampMillisecondArray, TimestampNanosecondArray, TimestampSecondArray, UInt16Array,
-    UInt32Array, UInt64Array, UInt8Array,
+    ListArray, NullArray, StringArray, StructArray, Time32MillisecondArray, Time64MicrosecondArray,
+    TimestampMicrosecondArray, TimestampMillisecondArray, TimestampNanosecondArray,
+    TimestampSecondArray, UInt16Array, UInt32Array, UInt64Array, UInt8Array,
 };
 use arrow_schema::{DataType, TimeUnit};
 use magnus::{value::ReprValue, Error as MagnusError, IntoValue, Ruby, Value};

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

@@ -29,6 +29,8 @@ pub enum ParquetValue {
     TimestampMillis(i64, Option<Arc<str>>),
     TimestampMicros(i64, Option<Arc<str>>),
     TimestampNanos(i64, Option<Arc<str>>),
+    TimeMillis(i32),         // Time of day in milliseconds since midnight
+    TimeMicros(i64),         // Time of day in microseconds since midnight
     List(Vec<ParquetValue>), // A list of values (can be empty or have null items)
     // We're not using a separate NilList type anymore - we'll handle nil lists elsewhere
     Map(HashMap<ParquetValue, ParquetValue>),
@@ -108,6 +110,8 @@ impl PartialEq for ParquetValue {
             (ParquetValue::TimestampMillis(a, _), ParquetValue::TimestampMillis(b, _)) => a == b,
             (ParquetValue::TimestampMicros(a, _), ParquetValue::TimestampMicros(b, _)) => a == b,
             (ParquetValue::TimestampNanos(a, _), ParquetValue::TimestampNanos(b, _)) => a == b,
+            (ParquetValue::TimeMillis(a), ParquetValue::TimeMillis(b)) => a == b,
+            (ParquetValue::TimeMicros(a), ParquetValue::TimeMicros(b)) => a == b,
             (ParquetValue::List(a), ParquetValue::List(b)) => a == b,
             (ParquetValue::Null, ParquetValue::Null) => true,
             _ => false,
@@ -160,6 +164,8 @@ impl std::hash::Hash for ParquetValue {
                 ts.hash(state);
                 tz.hash(state);
             }
+            ParquetValue::TimeMillis(t) => t.hash(state),
+            ParquetValue::TimeMicros(t) => t.hash(state),
             ParquetValue::List(l) => l.hash(state),
             ParquetValue::Map(m) => {
                 for (k, v) in m {
@@ -224,6 +230,38 @@ impl TryIntoValue for ParquetValue {
             timestamp @ ParquetValue::TimestampNanos(_, _) => {
                 impl_timestamp_conversion!(timestamp, TimestampNanos, handle)
             }
+            ParquetValue::TimeMillis(millis) => {
+                // Convert time of day in milliseconds to a Ruby Time object
+                // Use epoch date (1970-01-01) with the given time
+                let total_seconds = millis / 1000;
+                let ms = millis % 1000;
+                let hours = total_seconds / 3600;
+                let minutes = (total_seconds % 3600) / 60;
+                let seconds = total_seconds % 60;
+
+                // Create a Time object for 1970-01-01 with the given time
+                let time_class = handle.class_time();
+                let time = time_class.funcall::<_, _, Value>(
+                    "new",
+                    (1970, 1, 1, hours, minutes, seconds, ms * 1000), // Ruby expects microseconds
+                )?;
+                Ok(time.into_value_with(handle))
+            }
+            ParquetValue::TimeMicros(micros) => {
+                // Convert time of day in microseconds to a Ruby Time object
+                // Use epoch date (1970-01-01) with the given time
+                let total_seconds = micros / 1_000_000;
+                let us = micros % 1_000_000;
+                let hours = total_seconds / 3600;
+                let minutes = (total_seconds % 3600) / 60;
+                let seconds = total_seconds % 60;
+
+                // Create a Time object for 1970-01-01 with the given time
+                let time_class = handle.class_time();
+                let time = time_class
+                    .funcall::<_, _, Value>("new", (1970, 1, 1, hours, minutes, seconds, us))?;
+                Ok(time.into_value_with(handle))
+            }
             ParquetValue::List(l) => {
                 // For lists, convert to Ruby array and check for specific cases
                 // when we might need to return nil instead of an empty array
@@ -356,12 +394,32 @@ impl ParquetValue {
                     Ok(ParquetValue::Date32(v))
                 }
                 PrimitiveType::TimestampMillis => {
-                    let v = convert_to_timestamp_millis(ruby, value, format)?;
-                    Ok(ParquetValue::TimestampMillis(v, None))
+                    if value.is_kind_of(ruby.class_time()) {
+                        use crate::types::timestamp::ruby_time_to_timestamp_with_tz;
+                        let (v, tz) = ruby_time_to_timestamp_with_tz(value, "millis")?;
+                        Ok(ParquetValue::TimestampMillis(v, tz))
+                    } else {
+                        let v = convert_to_timestamp_millis(ruby, value, format)?;
+                        Ok(ParquetValue::TimestampMillis(v, None))
+                    }
                 }
                 PrimitiveType::TimestampMicros => {
-                    let v = convert_to_timestamp_micros(ruby, value, format)?;
-                    Ok(ParquetValue::TimestampMicros(v, None))
+                    if value.is_kind_of(ruby.class_time()) {
+                        use crate::types::timestamp::ruby_time_to_timestamp_with_tz;
+                        let (v, tz) = ruby_time_to_timestamp_with_tz(value, "micros")?;
+                        Ok(ParquetValue::TimestampMicros(v, tz))
+                    } else {
+                        let v = convert_to_timestamp_micros(ruby, value, format)?;
+                        Ok(ParquetValue::TimestampMicros(v, None))
+                    }
+                }
+                PrimitiveType::TimeMillis => {
+                    let v = convert_to_time_millis(ruby, value, format)?;
+                    Ok(ParquetValue::TimeMillis(v))
+                }
+                PrimitiveType::TimeMicros => {
+                    let v = convert_to_time_micros(ruby, value, format)?;
+                    Ok(ParquetValue::TimeMicros(v))
                 }
             },
             ParquetSchemaType::List(list_field) => {
@@ -980,6 +1038,52 @@ impl<'a> TryFrom<ArrayWrapper<'a>> for ParquetValueVec {
                     tz
                 )
             }
+            DataType::Time32(TimeUnit::Millisecond) => {
+                let array = downcast_array::<Time32MillisecondArray>(column.array);
+                Ok(ParquetValueVec(if array.is_nullable() {
+                    array
+                        .values()
+                        .iter()
+                        .enumerate()
+                        .map(|(i, x)| {
+                            if array.is_null(i) {
+                                ParquetValue::Null
+                            } else {
+                                ParquetValue::TimeMillis(*x)
+                            }
+                        })
+                        .collect()
+                } else {
+                    array
+                        .values()
+                        .iter()
+                        .map(|x| ParquetValue::TimeMillis(*x))
+                        .collect()
+                }))
+            }
+            DataType::Time64(TimeUnit::Microsecond) => {
+                let array = downcast_array::<Time64MicrosecondArray>(column.array);
+                Ok(ParquetValueVec(if array.is_nullable() {
+                    array
+                        .values()
+                        .iter()
+                        .enumerate()
+                        .map(|(i, x)| {
+                            if array.is_null(i) {
+                                ParquetValue::Null
+                            } else {
+                                ParquetValue::TimeMicros(*x)
+                            }
+                        })
+                        .collect()
+                } else {
+                    array
+                        .values()
+                        .iter()
+                        .map(|x| ParquetValue::TimeMicros(*x))
+                        .collect()
+                }))
+            }
             DataType::Float16 => {
                 let array = downcast_array::<Float16Array>(column.array);
                 if array.is_nullable() {

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

@@ -1,6 +1,7 @@
 use std::sync::OnceLock;
 
 use itertools::Itertools;
+use jiff::ToSpan;
 use parquet::{
     basic::{ConvertedType, LogicalType},
     data_type::AsBytes,
@@ -372,8 +373,9 @@ impl TryIntoValue for ParquetField {
                 }
             }
             Field::Date(d) => {
-                let ts = jiff::Timestamp::from_second((d as i64) * 86400)?;
-                let formatted = ts.strftime("%Y-%m-%d").to_string();
+                let epoch = jiff::civil::Date::new(1970, 1, 1)?;
+                let date = epoch.checked_add(d.days()).map_err(ParquetGemError::Jiff)?;
+                let formatted = date.to_string();
                 Ok(formatted.into_value_with(handle))
             }
             Field::TimeMillis(ts) => {

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

@@ -295,6 +295,8 @@ 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),
+        "time_millis" | "time_ms" => Some(PrimitiveType::TimeMillis),
+        "time_micros" | "time_us" => Some(PrimitiveType::TimeMicros),
         "decimal" => Some(PrimitiveType::Decimal128(38, 0)), // Maximum precision, scale 0
         "decimal256" => Some(PrimitiveType::Decimal256(38, 0)), // Maximum precision, scale 0
         _ => None,
@@ -337,6 +339,12 @@ pub fn schema_node_to_arrow_field(node: &SchemaNode) -> ArrowField {
                 PrimitiveType::TimestampMicros => {
                     ArrowDataType::Timestamp(arrow_schema::TimeUnit::Microsecond, None)
                 }
+                PrimitiveType::TimeMillis => {
+                    ArrowDataType::Time32(arrow_schema::TimeUnit::Millisecond)
+                }
+                PrimitiveType::TimeMicros => {
+                    ArrowDataType::Time64(arrow_schema::TimeUnit::Microsecond)
+                }
             };
             ArrowField::new(name, dt, *nullable)
         }

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

@@ -1,4 +1,107 @@
 use super::*;
+use magnus::{TryConvert, Value};
+
+/// Parses a fixed offset timezone string (e.g., "+09:00", "-05:30", "+0800")
+/// Returns the offset in minutes from UTC
+fn parse_fixed_offset(tz: &str) -> Result<i32, ParquetGemError> {
+    // Remove any whitespace
+    let tz = tz.trim();
+
+    // Check if it starts with + or -
+    if !tz.starts_with('+') && !tz.starts_with('-') {
+        return Err(MagnusError::new(
+            magnus::exception::arg_error(),
+            format!(
+                "Invalid timezone offset format: '{}'. Expected format like '+09:00' or '-0530'",
+                tz
+            ),
+        ))?;
+    }
+
+    let sign = if tz.starts_with('-') { -1 } else { 1 };
+    let offset_str = &tz[1..]; // Remove the sign
+
+    // Parse different formats: "+09:00", "+0900", "+09"
+    let (hours, minutes) = if offset_str.contains(':') {
+        // Format: "+09:00" or "+9:30"
+        let parts: Vec<&str> = offset_str.split(':').collect();
+        if parts.len() != 2 {
+            return Err(MagnusError::new(
+                magnus::exception::arg_error(),
+                format!("Invalid timezone offset format: '{}'. Expected HH:MM", tz),
+            ))?;
+        }
+
+        let h = parts[0].parse::<i32>().map_err(|e| {
+            MagnusError::new(
+                magnus::exception::arg_error(),
+                format!("Invalid hour in timezone offset '{}': {}", tz, e),
+            )
+        })?;
+
+        let m = parts[1].parse::<i32>().map_err(|e| {
+            MagnusError::new(
+                magnus::exception::arg_error(),
+                format!("Invalid minute in timezone offset '{}': {}", tz, e),
+            )
+        })?;
+
+        (h, m)
+    } else if offset_str.len() == 4 {
+        // Format: "+0900"
+        let h = offset_str[0..2].parse::<i32>().map_err(|e| {
+            MagnusError::new(
+                magnus::exception::arg_error(),
+                format!("Invalid hour in timezone offset '{}': {}", tz, e),
+            )
+        })?;
+
+        let m = offset_str[2..4].parse::<i32>().map_err(|e| {
+            MagnusError::new(
+                magnus::exception::arg_error(),
+                format!("Invalid minute in timezone offset '{}': {}", tz, e),
+            )
+        })?;
+
+        (h, m)
+    } else if offset_str.len() == 2
+        || (offset_str.len() == 1 && offset_str.chars().all(|c| c.is_numeric()))
+    {
+        // Format: "+09" or "+9"
+        let h = offset_str.parse::<i32>().map_err(|e| {
+            MagnusError::new(
+                magnus::exception::arg_error(),
+                format!("Invalid hour in timezone offset '{}': {}", tz, e),
+            )
+        })?;
+        (h, 0)
+    } else {
+        return Err(MagnusError::new(
+            magnus::exception::arg_error(),
+            format!("Invalid timezone offset format: '{}'. Expected formats: '+HH:MM', '+HHMM', or '+HH'", tz),
+        ))?;
+    };
+
+    // Validate ranges
+    if hours < 0 || hours > 23 {
+        return Err(MagnusError::new(
+            magnus::exception::arg_error(),
+            format!("Invalid hour in timezone offset: {}. Must be 0-23", hours),
+        ))?;
+    }
+
+    if minutes < 0 || minutes > 59 {
+        return Err(MagnusError::new(
+            magnus::exception::arg_error(),
+            format!(
+                "Invalid minute in timezone offset: {}. Must be 0-59",
+                minutes
+            ),
+        ))?;
+    }
+
+    Ok(sign * (hours * 60 + minutes))
+}
 
 pub fn parse_zoned_timestamp(value: &ParquetValue) -> Result<jiff::Timestamp, ParquetGemError> {
     let (ts, tz) = match value {
@@ -18,37 +121,40 @@ pub fn parse_zoned_timestamp(value: &ParquetValue) -> Result<jiff::Timestamp, Pa
 
     // If timezone is provided, convert to zoned timestamp
     if let Some(tz) = tz {
-        // Handle fixed offset timezones like "+09:00" first
+        // Handle fixed offset timezones 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)
-            };
+            let total_minutes = parse_fixed_offset(tz)?;
+
+            // Create fixed timezone using the parsed offset
+            let offset_hours = total_minutes / 60;
+            let offset_minutes = total_minutes % 60;
 
-            // Apply sign
-            let total_minutes = if tz.starts_with('-') {
-                -(hours * 60 + minutes)
+            // jiff expects offset in hours, but we can be more precise
+            let tz = if offset_minutes == 0 {
+                jiff::tz::TimeZone::fixed(jiff::tz::offset(offset_hours as i8))
             } else {
-                hours * 60 + minutes
+                // For non-zero minutes, we need to create a custom offset
+                // jiff doesn't directly support minute-precision offsets in the simple API,
+                // so we'll use the timestamp directly with the offset applied
+                return Ok(ts);
             };
 
-            // Create fixed timezone
-            let tz = jiff::tz::TimeZone::fixed(jiff::tz::offset((total_minutes / 60) as i8));
             Ok(ts.to_zoned(tz).timestamp())
+        } else if tz.eq_ignore_ascii_case("UTC") || tz.eq_ignore_ascii_case("GMT") {
+            // Common UTC aliases
+            Ok(ts)
         } else {
             // Try IANA timezone
             match ts.in_tz(tz) {
                 Ok(zoned) => Ok(zoned.timestamp()),
-                Err(_) => Ok(ts), // Fall back to UTC if timezone is invalid
+                Err(e) => {
+                    // Log the error but don't fail - fall back to UTC
+                    eprintln!(
+                        "Warning: Failed to parse timezone '{}': {}. Using UTC.",
+                        tz, e
+                    );
+                    Ok(ts)
+                }
             }
         }
     } else {
@@ -57,21 +163,112 @@ pub fn parse_zoned_timestamp(value: &ParquetValue) -> Result<jiff::Timestamp, Pa
     }
 }
 
+/// Validates and normalizes a timezone string
+/// Returns the normalized timezone string or None if invalid
+pub fn validate_timezone(tz: &str) -> Option<String> {
+    let tz = tz.trim();
+
+    // Check for empty timezone
+    if tz.is_empty() {
+        return None;
+    }
+
+    // Fixed offset timezones
+    if tz.starts_with('+') || tz.starts_with('-') {
+        // Validate it can be parsed
+        if parse_fixed_offset(tz).is_ok() {
+            return Some(tz.to_string());
+        }
+    }
+
+    // Common UTC aliases
+    if tz.eq_ignore_ascii_case("UTC")
+        || tz.eq_ignore_ascii_case("GMT")
+        || tz.eq_ignore_ascii_case("Z")
+    {
+        return Some("UTC".to_string());
+    }
+
+    // Try to validate as IANA timezone by attempting to use it
+    // This is a bit expensive but ensures we only store valid timezones
+    if let Ok(tz_obj) = jiff::tz::TimeZone::get(tz) {
+        // Use the canonical name from jiff
+        return Some(
+            tz_obj
+                .iana_name()
+                .map(|s| s.to_string())
+                .unwrap_or_else(|| tz.to_string()),
+        );
+    }
+
+    None
+}
+
+/// Converts a Ruby Time object to a timestamp with timezone
+pub fn ruby_time_to_timestamp_with_tz(
+    value: Value,
+    unit: &str,
+) -> Result<(i64, Option<Arc<str>>), MagnusError> {
+    // Get seconds and microseconds
+    let secs = i64::try_convert(value.funcall::<_, _, Value>("to_i", ())?)?;
+    let usecs = i64::try_convert(value.funcall::<_, _, Value>("usec", ())?)?;
+
+    // Get timezone information from Ruby Time object
+    let tz_str = if let Ok(zone) = value.funcall::<_, _, Value>("zone", ()) {
+        if zone.is_nil() {
+            None
+        } else if let Ok(s) = String::try_convert(zone) {
+            validate_timezone(&s).map(|tz| Arc::from(tz.as_str()))
+        } else {
+            None
+        }
+    } else {
+        None
+    };
+
+    // Convert to appropriate unit
+    let timestamp = match unit {
+        "millis" => secs * 1000 + (usecs / 1000),
+        "micros" => secs * 1_000_000 + usecs,
+        "seconds" => secs,
+        "nanos" => secs * 1_000_000_000 + (usecs * 1000),
+        _ => {
+            return Err(MagnusError::new(
+                magnus::exception::arg_error(),
+                format!("Invalid timestamp unit: {}", unit),
+            ))
+        }
+    };
+
+    Ok((timestamp, tz_str))
+}
+
 // Macro for handling timestamp conversions
 #[macro_export]
 macro_rules! impl_timestamp_conversion {
     ($value:expr, $unit:ident, $handle:expr) => {{
         match $value {
             ParquetValue::$unit(ts, tz) => {
-                let ts = parse_zoned_timestamp(&ParquetValue::$unit(ts, tz))?;
+                let ts = parse_zoned_timestamp(&ParquetValue::$unit(ts, tz.clone()))?;
                 let time_class = $handle.class_time();
-                Ok(time_class
+
+                // Convert timestamp to Time object
+                let time_obj = time_class
                     .funcall::<_, _, Value>("parse", (ts.to_string(),))?
-                    .into_value_with($handle))
+                    .into_value_with($handle);
+
+                // If we have timezone info, we've already handled it in parse_zoned_timestamp
+                // The resulting Time object will be in the correct timezone
+
+                Ok(time_obj)
             }
             _ => Err(MagnusError::new(
                 magnus::exception::type_error(),
-                "Invalid timestamp type".to_string(),
+                format!(
+                    "Invalid timestamp type. Expected {}, got {:?}",
+                    stringify!($unit),
+                    $value
+                ),
             ))?,
         }
     }};

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

@@ -250,6 +250,8 @@ pub fn parquet_schema_type_to_arrow_data_type(
             PrimitiveType::Date32 => DataType::Date32,
             PrimitiveType::TimestampMillis => DataType::Timestamp(TimeUnit::Millisecond, None),
             PrimitiveType::TimestampMicros => DataType::Timestamp(TimeUnit::Microsecond, None),
+            PrimitiveType::TimeMillis => DataType::Time32(TimeUnit::Millisecond),
+            PrimitiveType::TimeMicros => DataType::Time64(TimeUnit::Microsecond),
         },
         // For a List<T>, create a standard List in Arrow with nullable items
         ParquetSchemaType::List(list_field) => {
@@ -416,6 +418,12 @@ fn create_arrow_builder_for_type(
         ParquetSchemaType::Primitive(PrimitiveType::TimestampMicros) => {
             Ok(Box::new(TimestampMicrosecondBuilder::with_capacity(cap)))
         }
+        ParquetSchemaType::Primitive(PrimitiveType::TimeMillis) => {
+            Ok(Box::new(Time32MillisecondBuilder::with_capacity(cap)))
+        }
+        ParquetSchemaType::Primitive(PrimitiveType::TimeMicros) => {
+            Ok(Box::new(Time64MicrosecondBuilder::with_capacity(cap)))
+        }
         ParquetSchemaType::List(list_field) => {
             // For a list, we create a ListBuilder whose child builder is determined by item_type.
             // Pass through capacity to ensure consistent sizing
@@ -1165,6 +1173,44 @@ fn fill_builder(
             }
             Ok(())
         }
+        ParquetSchemaType::Primitive(PrimitiveType::TimeMillis) => {
+            let typed_builder = builder
+                .as_any_mut()
+                .downcast_mut::<Time32MillisecondBuilder>()
+                .expect("Builder mismatch: expected Time32MillisecondBuilder");
+            for val in values {
+                match val {
+                    ParquetValue::TimeMillis(t) => typed_builder.append_value(*t),
+                    ParquetValue::Null => typed_builder.append_null(),
+                    other => {
+                        return Err(MagnusError::new(
+                            magnus::exception::type_error(),
+                            format!("Expected TimeMillis, got {:?}", other),
+                        ))
+                    }
+                }
+            }
+            Ok(())
+        }
+        ParquetSchemaType::Primitive(PrimitiveType::TimeMicros) => {
+            let typed_builder = builder
+                .as_any_mut()
+                .downcast_mut::<Time64MicrosecondBuilder>()
+                .expect("Builder mismatch: expected Time64MicrosecondBuilder");
+            for val in values {
+                match val {
+                    ParquetValue::TimeMicros(t) => typed_builder.append_value(*t),
+                    ParquetValue::Null => typed_builder.append_null(),
+                    other => {
+                        return Err(MagnusError::new(
+                            magnus::exception::type_error(),
+                            format!("Expected TimeMicros, got {:?}", other),
+                        ))
+                    }
+                }
+            }
+            Ok(())
+        }
 
         // ------------------
         // NESTED LIST - using helper function
@@ -1433,6 +1479,24 @@ fn fill_builder(
                                             )
                                         })?
                                         .append_value(*x),
+                                    ParquetValue::TimeMillis(x) => typed_builder
+                                        .field_builder::<Time32MillisecondBuilder>(i)
+                                        .ok_or_else(|| {
+                                            MagnusError::new(
+                                                magnus::exception::type_error(),
+                                                "Failed to coerce into Time32MillisecondBuilder",
+                                            )
+                                        })?
+                                        .append_value(*x),
+                                    ParquetValue::TimeMicros(x) => typed_builder
+                                        .field_builder::<Time64MicrosecondBuilder>(i)
+                                        .ok_or_else(|| {
+                                            MagnusError::new(
+                                                magnus::exception::type_error(),
+                                                "Failed to coerce into Time64MicrosecondBuilder",
+                                            )
+                                        })?
+                                        .append_value(*x),
                                     ParquetValue::List(items) => {
                                         let list_builder = typed_builder
                                             .field_builder::<ListBuilder<Box<dyn ArrayBuilder>>>(i)
@@ -1647,6 +1711,24 @@ fn fill_builder(
                                                 )
                                             })?
                                             .append_null(),
+                                        ParquetSchemaType::Primitive(PrimitiveType::TimeMillis) => typed_builder
+                                            .field_builder::<Time32MillisecondBuilder>(i)
+                                            .ok_or_else(|| {
+                                                MagnusError::new(
+                                                    magnus::exception::type_error(),
+                                                    "Failed to coerce into Time32MillisecondBuilder",
+                                                )
+                                            })?
+                                            .append_null(),
+                                        ParquetSchemaType::Primitive(PrimitiveType::TimeMicros) => typed_builder
+                                            .field_builder::<Time64MicrosecondBuilder>(i)
+                                            .ok_or_else(|| {
+                                                MagnusError::new(
+                                                    magnus::exception::type_error(),
+                                                    "Failed to coerce into Time64MicrosecondBuilder",
+                                                )
+                                            })?
+                                            .append_null(),
                                         ParquetSchemaType::List(_) => typed_builder
                                             .field_builder::<ListBuilder<Box<dyn ArrayBuilder>>>(i)
                                             .ok_or_else(|| {
@@ -1743,3 +1825,125 @@ pub fn convert_ruby_array_to_arrow(
     }
     convert_parquet_values_to_arrow(parquet_values, type_)
 }
+
+pub fn convert_to_time_millis(
+    ruby: &Ruby,
+    value: Value,
+    format: Option<&str>,
+) -> Result<i32, MagnusError> {
+    if value.is_kind_of(ruby.class_time()) {
+        // Extract time components
+        let hour = i32::try_convert(value.funcall::<_, _, Value>("hour", ())?)?;
+        let min = i32::try_convert(value.funcall::<_, _, Value>("min", ())?)?;
+        let sec = i32::try_convert(value.funcall::<_, _, Value>("sec", ())?)?;
+        let usec = i32::try_convert(value.funcall::<_, _, Value>("usec", ())?)?;
+
+        // Convert to milliseconds since midnight
+        Ok(hour * 3600000 + min * 60000 + sec * 1000 + usec / 1000)
+    } else if value.is_kind_of(ruby.class_string()) {
+        let s = String::try_convert(value)?;
+
+        if let Some(fmt) = format {
+            // Parse using the provided format
+            match jiff::civil::Time::strptime(fmt, &s) {
+                Ok(time) => {
+                    let millis = time.hour() as i32 * 3600000
+                        + time.minute() as i32 * 60000
+                        + time.second() as i32 * 1000
+                        + time.millisecond() as i32;
+                    Ok(millis)
+                }
+                Err(e) => Err(MagnusError::new(
+                    magnus::exception::type_error(),
+                    format!(
+                        "Failed to parse '{}' with format '{}' as time: {}",
+                        s, fmt, e
+                    ),
+                )),
+            }
+        } else {
+            // Try to parse as standard time format
+            match s.parse::<jiff::civil::Time>() {
+                Ok(time) => {
+                    let millis = time.hour() as i32 * 3600000
+                        + time.minute() as i32 * 60000
+                        + time.second() as i32 * 1000
+                        + time.millisecond() as i32;
+                    Ok(millis)
+                }
+                Err(e) => Err(MagnusError::new(
+                    magnus::exception::type_error(),
+                    format!("Failed to parse '{}' as time: {}", s, e),
+                )),
+            }
+        }
+    } else {
+        Err(MagnusError::new(
+            magnus::exception::type_error(),
+            format!("Cannot convert {} to time_millis", unsafe {
+                value.classname()
+            }),
+        ))
+    }
+}
+
+pub fn convert_to_time_micros(
+    ruby: &Ruby,
+    value: Value,
+    format: Option<&str>,
+) -> Result<i64, MagnusError> {
+    if value.is_kind_of(ruby.class_time()) {
+        // Extract time components
+        let hour = i64::try_convert(value.funcall::<_, _, Value>("hour", ())?)?;
+        let min = i64::try_convert(value.funcall::<_, _, Value>("min", ())?)?;
+        let sec = i64::try_convert(value.funcall::<_, _, Value>("sec", ())?)?;
+        let usec = i64::try_convert(value.funcall::<_, _, Value>("usec", ())?)?;
+
+        // Convert to microseconds since midnight
+        Ok(hour * 3600000000 + min * 60000000 + sec * 1000000 + usec)
+    } else if value.is_kind_of(ruby.class_string()) {
+        let s = String::try_convert(value)?;
+
+        if let Some(fmt) = format {
+            // Parse using the provided format
+            match jiff::civil::Time::strptime(fmt, &s) {
+                Ok(time) => {
+                    let micros = time.hour() as i64 * 3600000000
+                        + time.minute() as i64 * 60000000
+                        + time.second() as i64 * 1000000
+                        + time.microsecond() as i64;
+                    Ok(micros)
+                }
+                Err(e) => Err(MagnusError::new(
+                    magnus::exception::type_error(),
+                    format!(
+                        "Failed to parse '{}' with format '{}' as time: {}",
+                        s, fmt, e
+                    ),
+                )),
+            }
+        } else {
+            // Try to parse as standard time format
+            match s.parse::<jiff::civil::Time>() {
+                Ok(time) => {
+                    let micros = time.hour() as i64 * 3600000000
+                        + time.minute() as i64 * 60000000
+                        + time.second() as i64 * 1000000
+                        + time.microsecond() as i64;
+                    Ok(micros)
+                }
+                Err(e) => Err(MagnusError::new(
+                    magnus::exception::type_error(),
+                    format!("Failed to parse '{}' as time: {}", s, e),
+                )),
+            }
+        }
+    } else {
+        Err(MagnusError::new(
+            magnus::exception::type_error(),
+            format!("Cannot convert {} to time_micros", unsafe {
+                value.classname()
+            }),
+        ))
+    }
+}

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

@@ -146,7 +146,10 @@ impl FromStr for ParquetSchemaType<'_> {
         }
 
         // Check if it's a decimal256 type with precision and scale
-        if let Some(decimal_params) = s.strip_prefix("decimal256(").and_then(|s| s.strip_suffix(")")) {
+        if let Some(decimal_params) = s
+            .strip_prefix("decimal256(")
+            .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)
@@ -210,6 +213,8 @@ impl FromStr for ParquetSchemaType<'_> {
             "date32" => Ok(ParquetSchemaType::Primitive(PrimitiveType::Date32)),
             "timestamp_millis" => Ok(ParquetSchemaType::Primitive(PrimitiveType::TimestampMillis)),
             "timestamp_micros" => Ok(ParquetSchemaType::Primitive(PrimitiveType::TimestampMicros)),
+            "time_millis" => Ok(ParquetSchemaType::Primitive(PrimitiveType::TimeMillis)),
+            "time_micros" => Ok(ParquetSchemaType::Primitive(PrimitiveType::TimeMicros)),
             "decimal" => Ok(ParquetSchemaType::Primitive(PrimitiveType::Decimal128(
                 38, 0,
             ))),

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

@@ -230,6 +230,16 @@ fn arrow_data_type_to_parquet_schema_type(dt: &DataType) -> Result<ParquetSchema
                 "TimestampNanos not supported, please adjust your schema or code.",
             ))
         }
+        DataType::Time32(TimeUnit::Millisecond) => Ok(PST::Primitive(PrimitiveType::TimeMillis)),
+        DataType::Time64(TimeUnit::Microsecond) => Ok(PST::Primitive(PrimitiveType::TimeMicros)),
+        DataType::Time32(_) => Err(MagnusError::new(
+            magnus::exception::runtime_error(),
+            "Time32 only supports millisecond unit",
+        )),
+        DataType::Time64(_) => Err(MagnusError::new(
+            magnus::exception::runtime_error(),
+            "Time64 only supports microsecond unit",
+        )),
         DataType::Utf8 => Ok(PST::Primitive(PrimitiveType::String)),
         DataType::Binary => Ok(PST::Primitive(PrimitiveType::Binary)),
         DataType::LargeUtf8 => {

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

@@ -170,6 +170,12 @@ fn write_columns_impl(ruby: Rc<Ruby>, args: &[Value]) -> Result<(), ParquetGemEr
                                     PrimitiveType::TimestampMicros => {
                                         PST::Primitive(PrimitiveType::TimestampMicros)
                                     }
+                                    PrimitiveType::TimeMillis => {
+                                        PST::Primitive(PrimitiveType::TimeMillis)
+                                    }
+                                    PrimitiveType::TimeMicros => {
+                                        PST::Primitive(PrimitiveType::TimeMicros)
+                                    }
                                     PrimitiveType::Decimal256(precision, scale) => {
                                         PST::Primitive(PrimitiveType::Decimal256(precision, scale))
                                     }

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

@@ -259,9 +259,11 @@ pub fn estimate_value_size(
         PST::Primitive(PrimitiveType::Boolean) => Ok(1),
         PST::Primitive(PrimitiveType::Decimal128(_, _)) => Ok(16),
         PST::Primitive(PrimitiveType::Decimal256(_, _)) => Ok(32),
-        PST::Primitive(PrimitiveType::Date32)
-        | PST::Primitive(PrimitiveType::TimestampMillis)
-        | PST::Primitive(PrimitiveType::TimestampMicros) => Ok(8),
+        PST::Primitive(PrimitiveType::Date32) => Ok(4), // Date32 is 4 bytes
+        PST::Primitive(PrimitiveType::TimestampMillis)
+        | PST::Primitive(PrimitiveType::TimestampMicros) => Ok(8), // Timestamps are 8 bytes
+        PST::Primitive(PrimitiveType::TimeMillis) => Ok(4), // TimeMillis is 4 bytes
+        PST::Primitive(PrimitiveType::TimeMicros) => Ok(8), // TimeMicros is 8 bytes
         PST::Primitive(PrimitiveType::String) | PST::Primitive(PrimitiveType::Binary) => {
             if let Ok(s) = String::try_convert(value) {
                 // Account for string length plus Rust String's capacity+pointer overhead

data/lib/parquet/version.rb

@@ -1,3 +1,3 @@
 module Parquet
-  VERSION = "0.5.11"
+  VERSION = "0.5.13"
 end

metadata

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