From 09e583b587e82978033ce4f4c49af0b17bbd4e61 Mon Sep 17 00:00:00 2001
From: Christopher Prohm <mail@cprohm.de>
Date: Tue, 1 Oct 2024 17:17:43 +0200
Subject: [PATCH 01/28] Simplify usage for transmute

---
 serde_arrow/src/internal/utils/value.rs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/serde_arrow/src/internal/utils/value.rs b/serde_arrow/src/internal/utils/value.rs
index 68037dfe..7cdd9fb8 100644
--- a/serde_arrow/src/internal/utils/value.rs
+++ b/serde_arrow/src/internal/utils/value.rs
@@ -82,7 +82,7 @@ impl std::hash::Hash for HashF64 {
     }
 }
 
-pub fn transmute<S: Serialize, T: DeserializeOwned>(value: S) -> Result<T> {
+pub fn transmute<T: DeserializeOwned>(value: impl Serialize) -> Result<T> {
     let value = value.serialize(ValueSerializer)?;
     T::deserialize(ValueDeserializer::new(&value))
 }
@@ -577,6 +577,7 @@ impl<'de, 'a> serde::de::Deserializer<'de> for ValueDeserializer<'a> {
     fn deserialize_byte_buf<V: serde::de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
         match self.0 {
             Value::Bytes(v) => visitor.visit_byte_buf(v.to_owned()),
+            Value::String(v) => visitor.visit_byte_buf(v.as_bytes().to_owned()),
             v => fail!("Cannot deserialize bytes from non-bytes value {v:?}"),
         }
     }
@@ -584,6 +585,7 @@ impl<'de, 'a> serde::de::Deserializer<'de> for ValueDeserializer<'a> {
     fn deserialize_bytes<V: serde::de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
         match self.0 {
             Value::Bytes(v) => visitor.visit_bytes(v),
+            Value::String(v) => visitor.visit_bytes(v.as_bytes()),
             v => fail!("Cannot deserialize bytes from non-bytes value {v:?}"),
         }
     }

From 6d097467f6e1ec12bfa838c5c057476c5ebbb634 Mon Sep 17 00:00:00 2001
From: Christopher Prohm <mail@cprohm.de>
Date: Tue, 1 Oct 2024 17:17:49 +0200
Subject: [PATCH 02/28] Add jiff as a dev-dep

---
 Cargo.lock             | 27 +++++++++++++++++++++++++++
 serde_arrow/Cargo.toml |  1 +
 2 files changed, 28 insertions(+)

diff --git a/Cargo.lock b/Cargo.lock
index 213ccbc3..7135d487 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1688,6 +1688,32 @@ version = "1.0.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b"
 
+[[package]]
+name = "jiff"
+version = "0.1.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a45489186a6123c128fdf6016183fcfab7113e1820eb813127e036e287233fb"
+dependencies = [
+ "jiff-tzdb-platform",
+ "serde",
+ "windows-sys 0.59.0",
+]
+
+[[package]]
+name = "jiff-tzdb"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91335e575850c5c4c673b9bd467b0e025f164ca59d0564f69d0c2ee0ffad4653"
+
+[[package]]
+name = "jiff-tzdb-platform"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9835f0060a626fe59f160437bc725491a6af23133ea906500027d1bd2f8f4329"
+dependencies = [
+ "jiff-tzdb",
+]
+
 [[package]]
 name = "js-sys"
 version = "0.3.70"
@@ -2359,6 +2385,7 @@ dependencies = [
  "chrono",
  "criterion",
  "half",
+ "jiff",
  "rand",
  "rust_decimal",
  "serde",
diff --git a/serde_arrow/Cargo.toml b/serde_arrow/Cargo.toml
index e546c5e0..fa1c2157 100644
--- a/serde_arrow/Cargo.toml
+++ b/serde_arrow/Cargo.toml
@@ -138,6 +138,7 @@ serde_bytes = "0.11"
 rand = "0.8"
 bigdecimal = {version = "0.4", features = ["serde"] }
 uuid = { version = "1.10.0", features = ["serde", "v4"] }
+jiff = { version = "0.1", features = ["serde"] }
 
 # for benchmarks
 # arrow-version:replace: arrow-json-{version} = {{ package = "arrow-json", version = "{version}" }}

From 8c8bf3fe6974a44be9d414522e7497049523f7e8 Mon Sep 17 00:00:00 2001
From: Christopher Prohm <mail@cprohm.de>
Date: Tue, 1 Oct 2024 17:17:59 +0200
Subject: [PATCH 03/28] Test various reprs between Chrono and Jiff

---
 serde_arrow/src/test_with_arrow/impls/jiff.rs | 87 +++++++++++++++++++
 serde_arrow/src/test_with_arrow/impls/mod.rs  |  1 +
 2 files changed, 88 insertions(+)
 create mode 100644 serde_arrow/src/test_with_arrow/impls/jiff.rs

diff --git a/serde_arrow/src/test_with_arrow/impls/jiff.rs b/serde_arrow/src/test_with_arrow/impls/jiff.rs
new file mode 100644
index 00000000..bdcf44a8
--- /dev/null
+++ b/serde_arrow/src/test_with_arrow/impls/jiff.rs
@@ -0,0 +1,87 @@
+use jiff::{
+    civil::{date, time, Date, DateTime, Time},
+    Span,
+};
+
+use crate::internal::utils::value;
+
+#[test]
+fn string_repr_examples() {
+    // date
+    let obj = date(2023, 12, 31);
+    assert_eq!(value::transmute::<String>(&obj).unwrap(), "2023-12-31");
+
+    // date time without time zone
+    let obj = obj.at(18, 30, 0, 0);
+    assert_eq!(
+        value::transmute::<String>(&obj).unwrap(),
+        "2023-12-31T18:30:00"
+    );
+
+    // date time wiht timezone
+    let obj = obj.intz("UTC").unwrap();
+    assert_eq!(
+        value::transmute::<String>(&obj).unwrap(),
+        "2023-12-31T18:30:00+00:00[UTC]"
+    );
+
+    // time without fractional part
+    let obj = time(16, 56, 42, 0);
+    assert_eq!(value::transmute::<String>(&obj).unwrap(), "16:56:42");
+
+    // time with fractional part
+    let obj = time(16, 56, 42, 123_000_000);
+    assert_eq!(value::transmute::<String>(&obj).unwrap(), "16:56:42.123");
+
+    // day span
+    let obj = Span::new().days(32);
+    assert_eq!(value::transmute::<String>(&obj).unwrap(), "P32d");
+
+    // year month span
+    let obj = Span::new().years(4).months(7);
+    assert_eq!(value::transmute::<String>(&obj).unwrap(), "P4y7m");
+}
+
+/// Test that the different reprs between chrono and jiff are compatible
+#[test]
+fn transmute_jiff_chrono() {
+    // date
+    let chrono = chrono::NaiveDate::from_ymd_opt(2023, 12, 31).unwrap();
+    let jiff = date(2023, 12, 31);
+
+    assert_eq!(value::transmute::<Date>(&chrono).unwrap(), jiff);
+    assert_eq!(
+        value::transmute::<chrono::NaiveDate>(&jiff).unwrap(),
+        chrono
+    );
+
+    // time without fractional part
+    let chrono = chrono::NaiveTime::from_hms_opt(19, 31, 22).unwrap();
+    let jiff = time(19, 31, 22, 0);
+
+    assert_eq!(value::transmute::<Time>(&chrono).unwrap(), jiff);
+    assert_eq!(
+        value::transmute::<chrono::NaiveTime>(&jiff).unwrap(),
+        chrono
+    );
+
+    // time with fractional part
+    let chrono = chrono::NaiveTime::from_hms_nano_opt(19, 31, 22, 123_456_789).unwrap();
+    let jiff = time(19, 31, 22, 123_456_789);
+
+    assert_eq!(value::transmute::<Time>(&chrono).unwrap(), jiff);
+    assert_eq!(
+        value::transmute::<chrono::NaiveTime>(&jiff).unwrap(),
+        chrono
+    );
+
+    // datetime
+    let chrono = chrono::NaiveDate::from_ymd_opt(1234, 5, 6).unwrap().and_hms_opt(7, 8, 9).unwrap();
+    let jiff = date(1234, 5, 6).at(7, 8, 9, 0);
+
+    assert_eq!(value::transmute::<DateTime>(&chrono).unwrap(), jiff);
+    assert_eq!(
+        value::transmute::<chrono::NaiveDateTime>(&jiff).unwrap(),
+        chrono
+    );
+}
diff --git a/serde_arrow/src/test_with_arrow/impls/mod.rs b/serde_arrow/src/test_with_arrow/impls/mod.rs
index 72db9255..7bbef5d5 100644
--- a/serde_arrow/src/test_with_arrow/impls/mod.rs
+++ b/serde_arrow/src/test_with_arrow/impls/mod.rs
@@ -6,6 +6,7 @@ mod chrono;
 mod dictionary;
 mod examples;
 mod fixed_size_list;
+mod jiff;
 mod json_values;
 mod list;
 mod map;

From 7c936f6a52ca85e18d47e2fc5c691f440031f760 Mon Sep 17 00:00:00 2001
From: Christopher Prohm <mail@cprohm.de>
Date: Tue, 1 Oct 2024 17:19:52 +0200
Subject: [PATCH 04/28] reformat

---
 serde_arrow/src/test_with_arrow/impls/jiff.rs | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/serde_arrow/src/test_with_arrow/impls/jiff.rs b/serde_arrow/src/test_with_arrow/impls/jiff.rs
index bdcf44a8..30de2caf 100644
--- a/serde_arrow/src/test_with_arrow/impls/jiff.rs
+++ b/serde_arrow/src/test_with_arrow/impls/jiff.rs
@@ -76,7 +76,10 @@ fn transmute_jiff_chrono() {
     );
 
     // datetime
-    let chrono = chrono::NaiveDate::from_ymd_opt(1234, 5, 6).unwrap().and_hms_opt(7, 8, 9).unwrap();
+    let chrono = chrono::NaiveDate::from_ymd_opt(1234, 5, 6)
+        .unwrap()
+        .and_hms_opt(7, 8, 9)
+        .unwrap();
     let jiff = date(1234, 5, 6).at(7, 8, 9, 0);
 
     assert_eq!(value::transmute::<DateTime>(&chrono).unwrap(), jiff);

From 7afd9ff0b0e9a070e71d25e51220a8e3ece4cfae Mon Sep 17 00:00:00 2001
From: Christopher Prohm <mail@cprohm.de>
Date: Tue, 1 Oct 2024 18:19:48 +0200
Subject: [PATCH 05/28] Test more datetime formats

---
 .../src/test_with_arrow/impls/chrono.rs       |  9 +++++
 serde_arrow/src/test_with_arrow/impls/jiff.rs | 36 ++++++++++++++++---
 2 files changed, 41 insertions(+), 4 deletions(-)

diff --git a/serde_arrow/src/test_with_arrow/impls/chrono.rs b/serde_arrow/src/test_with_arrow/impls/chrono.rs
index 3ec7bd55..4a25d146 100644
--- a/serde_arrow/src/test_with_arrow/impls/chrono.rs
+++ b/serde_arrow/src/test_with_arrow/impls/chrono.rs
@@ -5,6 +5,7 @@ use crate::{
     internal::{
         arrow::DataType,
         testing::{assert_error_contains, ArrayAccess},
+        utils::value,
     },
     schema::{SchemaLike, SerdeArrowSchema, TracingOptions},
     utils::Item,
@@ -21,6 +22,14 @@ fn trace_from_type_does_not_work() {
     assert_error_contains(&res, "premature end of input");
 }
 
+#[test]
+fn temporal_formats() {
+    assert_error_contains(
+        &value::transmute::<DateTime<Utc>>("2023-12-01T12:22:33[UTC]"),
+        "",
+    );
+}
+
 #[test]
 fn utc_as_str() {
     let items = [
diff --git a/serde_arrow/src/test_with_arrow/impls/jiff.rs b/serde_arrow/src/test_with_arrow/impls/jiff.rs
index 30de2caf..660d2b08 100644
--- a/serde_arrow/src/test_with_arrow/impls/jiff.rs
+++ b/serde_arrow/src/test_with_arrow/impls/jiff.rs
@@ -1,9 +1,16 @@
 use jiff::{
     civil::{date, time, Date, DateTime, Time},
-    Span,
+    Span, Zoned,
+};
+use serde_json::json;
+
+use crate::{
+    internal::{
+        testing::assert_error_contains,
+        utils::{value, Item},
+    },
+    test_with_arrow::impls::utils::Test,
 };
-
-use crate::internal::utils::value;
 
 #[test]
 fn string_repr_examples() {
@@ -75,7 +82,7 @@ fn transmute_jiff_chrono() {
         chrono
     );
 
-    // datetime
+    // date time
     let chrono = chrono::NaiveDate::from_ymd_opt(1234, 5, 6)
         .unwrap()
         .and_hms_opt(7, 8, 9)
@@ -87,4 +94,25 @@ fn transmute_jiff_chrono() {
         value::transmute::<chrono::NaiveDateTime>(&jiff).unwrap(),
         chrono
     );
+
+    // date times with timezone are not compatible
+    let chrono = chrono::NaiveDate::from_ymd_opt(1234, 5, 6)
+        .unwrap()
+        .and_hms_opt(7, 8, 9)
+        .unwrap()
+        .and_utc();
+    assert_error_contains(&value::transmute::<Zoned>(&chrono), "");
+
+    let jiff = date(1234, 5, 6).at(7, 8, 9, 0).intz("UTC").unwrap();
+    assert_error_contains(
+        &value::transmute::<chrono::DateTime<chrono::Utc>>(&jiff),
+        "",
+    );
+}
+
+#[test]
+fn invalid_utc_formats() {
+    assert_error_contains(&value::transmute::<Zoned>("2023-12-31T18:30:00+00:00"), "");
+    assert_error_contains(&value::transmute::<Zoned>("2023-12-31T18:30:00Z"), "");
+}
 }

From 05df30525481b47ba203541fc9ea8b396202013b Mon Sep 17 00:00:00 2001
From: Christopher Prohm <mail@cprohm.de>
Date: Tue, 1 Oct 2024 18:20:46 +0200
Subject: [PATCH 06/28] Add support for jiff::Time

---
 .../deserialization/time_deserializer.rs      | 12 ++++++++
 serde_arrow/src/test_with_arrow/impls/jiff.rs | 28 +++++++++++++++++++
 2 files changed, 40 insertions(+)

diff --git a/serde_arrow/src/internal/deserialization/time_deserializer.rs b/serde_arrow/src/internal/deserialization/time_deserializer.rs
index 92d15206..7ae77fb9 100644
--- a/serde_arrow/src/internal/deserialization/time_deserializer.rs
+++ b/serde_arrow/src/internal/deserialization/time_deserializer.rs
@@ -106,4 +106,16 @@ impl<'de, T: NamedType + Integer> SimpleDeserializer<'de> for TimeDeserializer<'
         })
         .ctx(self)
     }
+
+    fn deserialize_bytes<V: Visitor<'de>>(&mut self, visitor: V) -> Result<V::Value> {
+        try_(|| self.deserialize_byte_buf(visitor)).ctx(self)
+    }
+
+    fn deserialize_byte_buf<V: Visitor<'de>>(&mut self, visitor: V) -> Result<V::Value> {
+        try_(|| {
+            let ts = self.array.next_required()?.into_i64()?;
+            visitor.visit_byte_buf(self.get_string_repr(ts)?.into_bytes())
+        })
+        .ctx(self)
+    }
 }
diff --git a/serde_arrow/src/test_with_arrow/impls/jiff.rs b/serde_arrow/src/test_with_arrow/impls/jiff.rs
index 660d2b08..d30fca95 100644
--- a/serde_arrow/src/test_with_arrow/impls/jiff.rs
+++ b/serde_arrow/src/test_with_arrow/impls/jiff.rs
@@ -115,4 +115,32 @@ fn invalid_utc_formats() {
     assert_error_contains(&value::transmute::<Zoned>("2023-12-31T18:30:00+00:00"), "");
     assert_error_contains(&value::transmute::<Zoned>("2023-12-31T18:30:00Z"), "");
 }
+
+#[test]
+fn test_naive_time() {
+    let items = [
+        Item(time(12, 0, 0, 0)),
+        Item(time(23, 31, 12, 0)),
+        Item(time(3, 2, 58, 0)),
+    ];
+
+    Test::new()
+        .with_schema(json!([{"name": "item", "data_type": "Time32(Second)"}]))
+        .serialize(&items)
+        .deserialize(&items);
+
+    Test::new()
+        .with_schema(json!([{"name": "item", "data_type": "Time32(Millisecond)"}]))
+        .serialize(&items)
+        .deserialize(&items);
+
+    Test::new()
+        .with_schema(json!([{"name": "item", "data_type": "Time64(Microsecond)"}]))
+        .serialize(&items)
+        .deserialize(&items);
+
+    Test::new()
+        .with_schema(json!([{"name": "item", "data_type": "Time64(Nanosecond)"}]))
+        .serialize(&items)
+        .deserialize(&items);
 }

From 669a85c5fd8450cc870f262cc527ea8592fe3191 Mon Sep 17 00:00:00 2001
From: Christopher Prohm <mail@cprohm.de>
Date: Tue, 1 Oct 2024 20:06:22 +0200
Subject: [PATCH 07/28] Implement jiff::Date for positive years

---
 .../deserialization/date32_deserializer.rs    | 12 +++
 .../deserialization/string_deserializer.rs    | 83 ++++++++-----------
 .../src/test_with_arrow/impls/chrono.rs       | 27 +++---
 serde_arrow/src/test_with_arrow/impls/jiff.rs | 48 ++++++++++-
 4 files changed, 106 insertions(+), 64 deletions(-)

diff --git a/serde_arrow/src/internal/deserialization/date32_deserializer.rs b/serde_arrow/src/internal/deserialization/date32_deserializer.rs
index f37f0b00..b528b82d 100644
--- a/serde_arrow/src/internal/deserialization/date32_deserializer.rs
+++ b/serde_arrow/src/internal/deserialization/date32_deserializer.rs
@@ -78,4 +78,16 @@ impl<'de> SimpleDeserializer<'de> for Date32Deserializer<'de> {
         })
         .ctx(self)
     }
+
+    fn deserialize_bytes<V: Visitor<'de>>(&mut self, visitor: V) -> Result<V::Value> {
+        try_(|| self.deserialize_byte_buf(visitor)).ctx(self)
+    }
+
+    fn deserialize_byte_buf<V: Visitor<'de>>(&mut self, visitor: V) -> Result<V::Value> {
+        try_(|| {
+            let ts = self.array.next_required()?;
+            visitor.visit_byte_buf(self.get_string_repr(ts)?.into_bytes())
+        })
+        .ctx(self)
+    }
 }
diff --git a/serde_arrow/src/internal/deserialization/string_deserializer.rs b/serde_arrow/src/internal/deserialization/string_deserializer.rs
index 067e79a1..183f5832 100644
--- a/serde_arrow/src/internal/deserialization/string_deserializer.rs
+++ b/serde_arrow/src/internal/deserialization/string_deserializer.rs
@@ -1,6 +1,6 @@
 use crate::internal::{
     arrow::BytesArrayView,
-    error::{fail, set_default, Context, ContextSupport, Result},
+    error::{fail, set_default, try_, Context, ContextSupport, Result},
     utils::{Mut, NamedType, Offset},
 };
 
@@ -85,72 +85,55 @@ impl<'a, O: NamedType + Offset> Context for StringDeserializer<'a, O> {
 
 impl<'a, O: NamedType + Offset> SimpleDeserializer<'a> for StringDeserializer<'a, O> {
     fn deserialize_any<V: serde::de::Visitor<'a>>(&mut self, visitor: V) -> Result<V::Value> {
-        self.deserialize_any_impl(visitor).ctx(self)
+        try_(|| {
+            if self.peek_next()? {
+                self.deserialize_str(visitor)
+            } else {
+                self.consume_next();
+                visitor.visit_none()
+            }
+        })
+        .ctx(self)
     }
 
     fn deserialize_option<V: serde::de::Visitor<'a>>(&mut self, visitor: V) -> Result<V::Value> {
-        self.deserialize_option_impl(visitor).ctx(self)
+        try_(|| {
+            if self.peek_next()? {
+                visitor.visit_some(Mut(self))
+            } else {
+                self.consume_next();
+                visitor.visit_none()
+            }
+        })
+        .ctx(self)
     }
 
     fn deserialize_str<V: serde::de::Visitor<'a>>(&mut self, visitor: V) -> Result<V::Value> {
-        self.deserialize_str_impl(visitor).ctx(self)
+        try_(|| visitor.visit_borrowed_str(self.next_required()?)).ctx(self)
     }
 
     fn deserialize_string<V: serde::de::Visitor<'a>>(&mut self, visitor: V) -> Result<V::Value> {
-        self.deserialize_string_impl(visitor).ctx(self)
-    }
-
-    fn deserialize_enum<V: serde::de::Visitor<'a>>(
-        &mut self,
-        name: &'static str,
-        variants: &'static [&'static str],
-        visitor: V,
-    ) -> Result<V::Value> {
-        self.deserialize_enum_impl(name, variants, visitor)
-            .ctx(self)
-    }
-}
-
-impl<'a, O: NamedType + Offset> StringDeserializer<'a, O> {
-    fn deserialize_any_impl<V: serde::de::Visitor<'a>>(&mut self, visitor: V) -> Result<V::Value> {
-        if self.peek_next()? {
-            self.deserialize_str(visitor)
-        } else {
-            self.consume_next();
-            visitor.visit_none()
-        }
+        try_(|| visitor.visit_string(self.next_required()?.to_owned())).ctx(self)
     }
 
-    fn deserialize_option_impl<V: serde::de::Visitor<'a>>(
-        &mut self,
-        visitor: V,
-    ) -> Result<V::Value> {
-        if self.peek_next()? {
-            visitor.visit_some(Mut(self))
-        } else {
-            self.consume_next();
-            visitor.visit_none()
-        }
+    fn deserialize_bytes<V: serde::de::Visitor<'a>>(&mut self, visitor: V) -> Result<V::Value> {
+        try_(|| visitor.visit_bytes(self.next_required()?.as_bytes())).ctx(self)
     }
 
-    fn deserialize_str_impl<V: serde::de::Visitor<'a>>(&mut self, visitor: V) -> Result<V::Value> {
-        visitor.visit_borrowed_str(self.next_required()?)
+    fn deserialize_byte_buf<V: serde::de::Visitor<'a>>(&mut self, visitor: V) -> Result<V::Value> {
+        try_(|| visitor.visit_byte_buf(self.next_required()?.to_owned().into_bytes())).ctx(self)
     }
 
-    fn deserialize_string_impl<V: serde::de::Visitor<'a>>(
-        &mut self,
-        visitor: V,
-    ) -> Result<V::Value> {
-        visitor.visit_string(self.next_required()?.to_owned())
-    }
-
-    fn deserialize_enum_impl<V: serde::de::Visitor<'a>>(
+    fn deserialize_enum<V: serde::de::Visitor<'a>>(
         &mut self,
-        _: &'static str,
-        _: &'static [&'static str],
+        _name: &'static str,
+        _variants: &'static [&'static str],
         visitor: V,
     ) -> Result<V::Value> {
-        let variant = self.next_required()?;
-        visitor.visit_enum(EnumAccess(variant))
+        try_(|| {
+            let variant = self.next_required()?;
+            visitor.visit_enum(EnumAccess(variant))
+        })
+        .ctx(self)
     }
 }
diff --git a/serde_arrow/src/test_with_arrow/impls/chrono.rs b/serde_arrow/src/test_with_arrow/impls/chrono.rs
index 4a25d146..e5c273d2 100644
--- a/serde_arrow/src/test_with_arrow/impls/chrono.rs
+++ b/serde_arrow/src/test_with_arrow/impls/chrono.rs
@@ -28,6 +28,20 @@ fn temporal_formats() {
         &value::transmute::<DateTime<Utc>>("2023-12-01T12:22:33[UTC]"),
         "",
     );
+
+    assert_eq!(
+        value::transmute::<String>(NaiveDate::from_ymd_opt(-10, 10, 30).unwrap()).unwrap(),
+        "-0010-10-30"
+    );
+    assert_eq!(
+        value::transmute::<NaiveDate>("-0010-10-30").unwrap(),
+        NaiveDate::from_ymd_opt(-10, 10, 30).unwrap()
+    );
+    // chrono also supports 6 digit dates, jiff requires them
+    assert_eq!(
+        value::transmute::<NaiveDate>("-000010-10-30").unwrap(),
+        NaiveDate::from_ymd_opt(-10, 10, 30).unwrap()
+    );
 }
 
 #[test]
@@ -681,10 +695,11 @@ fn duration_example_as_time64() {
 }
 
 #[test]
-fn naive_date_example_as_string() {
+fn naive_date() {
     let items = [
         Item(NaiveDate::from_ymd_opt(2024, 9, 30).unwrap()),
-        Item(NaiveDate::from_ymd_opt(-1000, 9, 30).unwrap()),
+        Item(NaiveDate::from_ymd_opt(-10, 10, 30).unwrap()),
+        Item(NaiveDate::from_ymd_opt(-1000, 9, 23).unwrap()),
     ];
 
     Test::new()
@@ -692,14 +707,6 @@ fn naive_date_example_as_string() {
         .trace_schema_from_samples(&items, TracingOptions::default())
         .serialize(&items)
         .deserialize(&items);
-}
-
-#[test]
-fn naive_date_example_as_time64() {
-    let items = [
-        Item(NaiveDate::from_ymd_opt(2024, 9, 30).unwrap()),
-        Item(NaiveDate::from_ymd_opt(-1000, 9, 30).unwrap()),
-    ];
 
     Test::new()
         .with_schema(json!([{"name": "item", "data_type": "Date32"}]))
diff --git a/serde_arrow/src/test_with_arrow/impls/jiff.rs b/serde_arrow/src/test_with_arrow/impls/jiff.rs
index d30fca95..0cc0fce9 100644
--- a/serde_arrow/src/test_with_arrow/impls/jiff.rs
+++ b/serde_arrow/src/test_with_arrow/impls/jiff.rs
@@ -18,15 +18,23 @@ fn string_repr_examples() {
     let obj = date(2023, 12, 31);
     assert_eq!(value::transmute::<String>(&obj).unwrap(), "2023-12-31");
 
+    let obj = date(-10, 10, 30);
+    assert_eq!(value::transmute::<String>(&obj).unwrap(), "-000010-10-30");
+    assert_eq!(value::transmute::<Date>("-000010-10-30").unwrap(), obj);
+    assert_error_contains(
+        &value::transmute::<Date>("-0010-10-30"),
+        "six digit integer",
+    );
+
     // date time without time zone
-    let obj = obj.at(18, 30, 0, 0);
+    let obj = date(2023, 12, 31).at(18, 30, 0, 0);
     assert_eq!(
         value::transmute::<String>(&obj).unwrap(),
         "2023-12-31T18:30:00"
     );
 
-    // date time wiht timezone
-    let obj = obj.intz("UTC").unwrap();
+    // date time with timezone
+    let obj = date(2023, 12, 31).at(18, 30, 0, 0).intz("UTC").unwrap();
     assert_eq!(
         value::transmute::<String>(&obj).unwrap(),
         "2023-12-31T18:30:00+00:00[UTC]"
@@ -117,13 +125,25 @@ fn invalid_utc_formats() {
 }
 
 #[test]
-fn test_naive_time() {
+fn empty_string_errors() {
+    assert_error_contains(&value::transmute::<Date>(""), "found end of input");
+    assert_error_contains(&value::transmute::<Time>(""), "found end of input");
+    assert_error_contains(&value::transmute::<Zoned>(""), "found end of input");
+}
+
+#[test]
+fn test_time() {
     let items = [
         Item(time(12, 0, 0, 0)),
         Item(time(23, 31, 12, 0)),
         Item(time(3, 2, 58, 0)),
     ];
 
+    Test::new()
+        .with_schema(json!([{"name": "item", "data_type": "LargeUtf8"}]))
+        .serialize(&items)
+        .deserialize(&items);
+
     Test::new()
         .with_schema(json!([{"name": "item", "data_type": "Time32(Second)"}]))
         .serialize(&items)
@@ -144,3 +164,23 @@ fn test_naive_time() {
         .serialize(&items)
         .deserialize(&items);
 }
+
+#[test]
+fn test_date() {
+    let items = [
+        Item(date(1234, 5, 6)),
+        // NOTE: chrono uses 4 digits for the year, jiff requires 6
+        // Item(date(-10, 10, 30)),
+        Item(date(2024, 10, 1)),
+    ];
+
+    Test::new()
+        .with_schema(json!([{"name": "item", "data_type": "LargeUtf8"}]))
+        .serialize(&items)
+        .deserialize(&items);
+
+    Test::new()
+        .with_schema(json!([{"name": "item", "data_type": "Date32"}]))
+        .serialize(&items)
+        .deserialize(&items);
+}

From cc0016b392accff19a369a213a896b14ec184d7c Mon Sep 17 00:00:00 2001
From: Christopher Prohm <mail@cprohm.de>
Date: Tue, 1 Oct 2024 20:13:24 +0200
Subject: [PATCH 08/28] Test transmutation chrono::DateTime<Utc> <->
 jiff::Timestamp

---
 serde_arrow/src/test_with_arrow/impls/jiff.rs | 17 ++++++++++++++---
 1 file changed, 14 insertions(+), 3 deletions(-)

diff --git a/serde_arrow/src/test_with_arrow/impls/jiff.rs b/serde_arrow/src/test_with_arrow/impls/jiff.rs
index 0cc0fce9..7e20bd68 100644
--- a/serde_arrow/src/test_with_arrow/impls/jiff.rs
+++ b/serde_arrow/src/test_with_arrow/impls/jiff.rs
@@ -1,6 +1,6 @@
 use jiff::{
     civil::{date, time, Date, DateTime, Time},
-    Span, Zoned,
+    Span, Timestamp, Zoned,
 };
 use serde_json::json;
 
@@ -109,13 +109,24 @@ fn transmute_jiff_chrono() {
         .and_hms_opt(7, 8, 9)
         .unwrap()
         .and_utc();
-    assert_error_contains(&value::transmute::<Zoned>(&chrono), "");
-
     let jiff = date(1234, 5, 6).at(7, 8, 9, 0).intz("UTC").unwrap();
+
+    assert_error_contains(&value::transmute::<Zoned>(&chrono), "");
     assert_error_contains(
         &value::transmute::<chrono::DateTime<chrono::Utc>>(&jiff),
         "",
     );
+
+    // use timestamp
+    let jiff_timestamp = jiff.timestamp();
+    assert_eq!(
+        value::transmute::<Timestamp>(&chrono).unwrap(),
+        jiff_timestamp
+    );
+    assert_eq!(
+        value::transmute::<chrono::DateTime<chrono::Utc>>(&jiff_timestamp).unwrap(),
+        chrono
+    );
 }
 
 #[test]

From 8c446ecc20151b7d78478f0c0e08e0fe1fb5c901 Mon Sep 17 00:00:00 2001
From: Christopher Prohm <mail@cprohm.de>
Date: Wed, 2 Oct 2024 20:01:27 +0200
Subject: [PATCH 09/28] Implement support dates with negative years across
 chrono and jiff

---
 .../deserialization/date32_deserializer.rs    | 20 +++++++++++++++++--
 serde_arrow/src/test_with_arrow/impls/jiff.rs |  3 +--
 2 files changed, 19 insertions(+), 4 deletions(-)

diff --git a/serde_arrow/src/internal/deserialization/date32_deserializer.rs b/serde_arrow/src/internal/deserialization/date32_deserializer.rs
index b528b82d..bf35e471 100644
--- a/serde_arrow/src/internal/deserialization/date32_deserializer.rs
+++ b/serde_arrow/src/internal/deserialization/date32_deserializer.rs
@@ -1,4 +1,4 @@
-use chrono::{Duration, NaiveDate, NaiveDateTime};
+use chrono::{Datelike, Duration, NaiveDate, NaiveDateTime};
 use serde::de::Visitor;
 
 use crate::internal::{
@@ -27,7 +27,23 @@ impl<'a> Date32Deserializer<'a> {
         #[allow(deprecated)]
         let delta = Duration::days(ts as i64);
         let date = UNIX_EPOCH + delta;
-        Ok(date.to_string())
+
+        // special handling of negative dates:
+        //
+        // - jiff expects 6 digits years in this case
+        // - chrono allows an arbitrary number of digits, when prefixed with a sign
+        //
+        // https://github.com/chronotope/chrono/blob/05a6ce68cf18a01274cef211b080a7170c7c1a1f/src/format/parse.rs#L368
+        if date.year() < 0 {
+            Ok(format!(
+                "-{positive_year:06}-{month:02}-{day:02}",
+                positive_year = -date.year(),
+                month = date.month(),
+                day = date.day(),
+            ))
+        } else {
+            Ok(date.to_string())
+        }
     }
 }
 
diff --git a/serde_arrow/src/test_with_arrow/impls/jiff.rs b/serde_arrow/src/test_with_arrow/impls/jiff.rs
index 7e20bd68..251b67c1 100644
--- a/serde_arrow/src/test_with_arrow/impls/jiff.rs
+++ b/serde_arrow/src/test_with_arrow/impls/jiff.rs
@@ -180,8 +180,7 @@ fn test_time() {
 fn test_date() {
     let items = [
         Item(date(1234, 5, 6)),
-        // NOTE: chrono uses 4 digits for the year, jiff requires 6
-        // Item(date(-10, 10, 30)),
+        Item(date(-10, 10, 30)),
         Item(date(2024, 10, 1)),
     ];
 

From b81f10b951d8f754a522451a2b95db61f1730d77 Mon Sep 17 00:00:00 2001
From: Christopher Prohm <mail@cprohm.de>
Date: Wed, 2 Oct 2024 20:13:42 +0200
Subject: [PATCH 10/28] regroup chrono tests

---
 .../src/test_with_arrow/impls/chrono.rs       | 115 +++++++++++-------
 1 file changed, 73 insertions(+), 42 deletions(-)

diff --git a/serde_arrow/src/test_with_arrow/impls/chrono.rs b/serde_arrow/src/test_with_arrow/impls/chrono.rs
index e5c273d2..885174aa 100644
--- a/serde_arrow/src/test_with_arrow/impls/chrono.rs
+++ b/serde_arrow/src/test_with_arrow/impls/chrono.rs
@@ -664,53 +664,84 @@ fn duration_example_as_string_details() {
     assert_eq!(array.get_utf8(2).unwrap(), Some("23:59:59.999"));
 }
 
-#[test]
-fn duration_example_as_string() {
-    let items = [
-        Item(NaiveTime::from_hms_opt(12, 10, 42).unwrap()),
-        Item(NaiveTime::from_hms_opt(22, 10, 00).unwrap()),
-        Item(NaiveTime::from_hms_milli_opt(23, 59, 59, 999).unwrap()),
-    ];
+mod naive_time {
+    use super::*;
+
+    fn items() -> Vec<Item<NaiveTime>> {
+        vec![
+            Item(NaiveTime::from_hms_opt(12, 10, 42).unwrap()),
+            Item(NaiveTime::from_hms_opt(22, 10, 00).unwrap()),
+            Item(NaiveTime::from_hms_milli_opt(23, 59, 59, 999).unwrap()),
+        ]
+    }
 
-    Test::new()
-        .with_schema(json!([{"name": "item", "data_type": "LargeUtf8"}]))
-        .trace_schema_from_samples(&items, TracingOptions::default())
-        .serialize(&items)
-        .deserialize(&items);
-}
+    #[test]
+    fn as_large_utf8() {
+        let items = &items();
+        Test::new()
+            .with_schema(json!([{"name": "item", "data_type": "LargeUtf8"}]))
+            .trace_schema_from_samples(&items, TracingOptions::default())
+            .serialize(&items)
+            .deserialize(&items);
+    }
 
-#[test]
-fn duration_example_as_time64() {
-    let items = [
-        Item(NaiveTime::from_hms_opt(12, 10, 42).unwrap()),
-        Item(NaiveTime::from_hms_opt(22, 10, 00).unwrap()),
-        Item(NaiveTime::from_hms_milli_opt(23, 59, 59, 999).unwrap()),
-    ];
+    #[test]
+    fn as_utf8() {
+        let items = items();
+        Test::new()
+            .with_schema(json!([{"name": "item", "data_type": "Utf8"}]))
+            .serialize(&items)
+            .deserialize(&items);
+    }
 
-    Test::new()
-        .with_schema(json!([{"name": "item", "data_type": "Time64(Nanosecond)"}]))
-        .trace_schema_from_samples(&items, TracingOptions::default().guess_dates(true))
-        .serialize(&items)
-        .deserialize(&items);
+    #[test]
+    fn as_time64() {
+        let items = items();
+        Test::new()
+            .with_schema(json!([{"name": "item", "data_type": "Time64(Nanosecond)"}]))
+            .trace_schema_from_samples(&items, TracingOptions::default().guess_dates(true))
+            .serialize(&items)
+            .deserialize(&items);
+    }
 }
 
-#[test]
-fn naive_date() {
-    let items = [
-        Item(NaiveDate::from_ymd_opt(2024, 9, 30).unwrap()),
-        Item(NaiveDate::from_ymd_opt(-10, 10, 30).unwrap()),
-        Item(NaiveDate::from_ymd_opt(-1000, 9, 23).unwrap()),
-    ];
+mod naive_date {
+    use super::*;
 
-    Test::new()
-        .with_schema(json!([{"name": "item", "data_type": "LargeUtf8"}]))
-        .trace_schema_from_samples(&items, TracingOptions::default())
-        .serialize(&items)
-        .deserialize(&items);
+    fn items() -> Vec<Item<NaiveDate>> {
+        vec![
+            Item(NaiveDate::from_ymd_opt(2024, 9, 30).unwrap()),
+            Item(NaiveDate::from_ymd_opt(-10, 10, 30).unwrap()),
+            Item(NaiveDate::from_ymd_opt(-1000, 9, 23).unwrap()),
+        ]
+    }
 
-    Test::new()
-        .with_schema(json!([{"name": "item", "data_type": "Date32"}]))
-        .trace_schema_from_samples(&items, TracingOptions::default().guess_dates(true))
-        .serialize(&items)
-        .deserialize(&items);
+    #[test]
+    fn as_large_utf8() {
+        let items = items();
+        Test::new()
+            .with_schema(json!([{"name": "item", "data_type": "LargeUtf8"}]))
+            .trace_schema_from_samples(&items, TracingOptions::default())
+            .serialize(&items)
+            .deserialize(&items);
+    }
+
+    #[test]
+    fn as_utf8() {
+        let items = items();
+        Test::new()
+            .with_schema(json!([{"name": "item", "data_type": "Utf8"}]))
+            .serialize(&items)
+            .deserialize(&items);
+    }
+
+    #[test]
+    fn as_date32() {
+        let items = items();
+        Test::new()
+            .with_schema(json!([{"name": "item", "data_type": "Date32"}]))
+            .trace_schema_from_samples(&items, TracingOptions::default().guess_dates(true))
+            .serialize(&items)
+            .deserialize(&items);
+    }
 }

From bed583515aadfd03b6ae1e3da2ae4875f0626a76 Mon Sep 17 00:00:00 2001
From: Christopher Prohm <mail@cprohm.de>
Date: Wed, 2 Oct 2024 20:24:41 +0200
Subject: [PATCH 11/28] Regroup jiff tests

---
 serde_arrow/src/test_with_arrow/impls/jiff.rs | 146 ++++++++++++------
 1 file changed, 97 insertions(+), 49 deletions(-)

diff --git a/serde_arrow/src/test_with_arrow/impls/jiff.rs b/serde_arrow/src/test_with_arrow/impls/jiff.rs
index 251b67c1..9c3d4d4e 100644
--- a/serde_arrow/src/test_with_arrow/impls/jiff.rs
+++ b/serde_arrow/src/test_with_arrow/impls/jiff.rs
@@ -6,6 +6,7 @@ use serde_json::json;
 
 use crate::{
     internal::{
+        schema::TracingOptions,
         testing::assert_error_contains,
         utils::{value, Item},
     },
@@ -142,55 +143,102 @@ fn empty_string_errors() {
     assert_error_contains(&value::transmute::<Zoned>(""), "found end of input");
 }
 
-#[test]
-fn test_time() {
-    let items = [
-        Item(time(12, 0, 0, 0)),
-        Item(time(23, 31, 12, 0)),
-        Item(time(3, 2, 58, 0)),
-    ];
-
-    Test::new()
-        .with_schema(json!([{"name": "item", "data_type": "LargeUtf8"}]))
-        .serialize(&items)
-        .deserialize(&items);
-
-    Test::new()
-        .with_schema(json!([{"name": "item", "data_type": "Time32(Second)"}]))
-        .serialize(&items)
-        .deserialize(&items);
-
-    Test::new()
-        .with_schema(json!([{"name": "item", "data_type": "Time32(Millisecond)"}]))
-        .serialize(&items)
-        .deserialize(&items);
-
-    Test::new()
-        .with_schema(json!([{"name": "item", "data_type": "Time64(Microsecond)"}]))
-        .serialize(&items)
-        .deserialize(&items);
-
-    Test::new()
-        .with_schema(json!([{"name": "item", "data_type": "Time64(Nanosecond)"}]))
-        .serialize(&items)
-        .deserialize(&items);
+mod time {
+    use super::*;
+
+    fn items() -> Vec<Item<Time>> {
+        vec![
+            Item(time(12, 0, 0, 0)),
+            Item(time(23, 31, 12, 0)),
+            Item(time(3, 2, 58, 0)),
+        ]
+    }
+
+    #[test]
+    fn as_large_utf8() {
+        let items = items();
+        Test::new()
+            .with_schema(json!([{"name": "item", "data_type": "LargeUtf8"}]))
+            .trace_schema_from_samples(&items, TracingOptions::default())
+            .serialize(&items)
+            .deserialize(&items);
+    }
+
+    #[test]
+    fn as_utf8() {
+        let items = items();
+        Test::new()
+            .with_schema(json!([{"name": "item", "data_type": "Utf8"}]))
+            .serialize(&items)
+            .deserialize(&items);
+    }
+
+    #[test]
+    fn as_time32_second() {
+        let items = items();
+        Test::new()
+            .with_schema(json!([{"name": "item", "data_type": "Time32(Second)"}]))
+            .serialize(&items)
+            .deserialize(&items);
+    }
+
+    #[test]
+    fn as_time32_miliseconds() {
+        let items = items();
+        Test::new()
+            .with_schema(json!([{"name": "item", "data_type": "Time32(Millisecond)"}]))
+            .serialize(&items)
+            .deserialize(&items);
+    }
+
+    #[test]
+    fn as_time32_microseconds() {
+        let items = items();
+        Test::new()
+            .with_schema(json!([{"name": "item", "data_type": "Time64(Microsecond)"}]))
+            .serialize(&items)
+            .deserialize(&items);
+    }
+
+    #[test]
+    fn as_time64_nanosecond() {
+        let items = items();
+        Test::new()
+            .with_schema(json!([{"name": "item", "data_type": "Time64(Nanosecond)"}]))
+            .trace_schema_from_samples(&items, TracingOptions::default().guess_dates(true))
+            .serialize(&items)
+            .deserialize(&items);
+    }
 }
 
-#[test]
-fn test_date() {
-    let items = [
-        Item(date(1234, 5, 6)),
-        Item(date(-10, 10, 30)),
-        Item(date(2024, 10, 1)),
-    ];
-
-    Test::new()
-        .with_schema(json!([{"name": "item", "data_type": "LargeUtf8"}]))
-        .serialize(&items)
-        .deserialize(&items);
-
-    Test::new()
-        .with_schema(json!([{"name": "item", "data_type": "Date32"}]))
-        .serialize(&items)
-        .deserialize(&items);
+mod date {
+    use super::*;
+
+    fn items() -> Vec<Item<Date>> {
+        vec![
+            Item(date(1234, 5, 6)),
+            Item(date(-10, 10, 30)),
+            Item(date(2024, 10, 1)),
+        ]
+    }
+
+    #[test]
+    fn as_large_utf8() {
+        let items = items();
+        Test::new()
+            .with_schema(json!([{"name": "item", "data_type": "LargeUtf8"}]))
+            .trace_schema_from_samples(&items, TracingOptions::default())
+            .serialize(&items)
+            .deserialize(&items);
+    }
+
+    #[test]
+    fn as_date32() {
+        let items = items();
+        Test::new()
+            .with_schema(json!([{"name": "item", "data_type": "Date32"}]))
+            .trace_schema_from_samples(&items, TracingOptions::default().guess_dates(true))
+            .serialize(&items)
+            .deserialize(&items);
+    }
 }

From 57faa15ef8ade832b5e657464ef8b9c74bd20560 Mon Sep 17 00:00:00 2001
From: Christopher Prohm <mail@cprohm.de>
Date: Wed, 2 Oct 2024 20:24:56 +0200
Subject: [PATCH 12/28] Address clippy

---
 serde_arrow/src/_impl/docs/defs.rs                  | 4 ++--
 serde_arrow/src/arrow2_impl/api.rs                  | 2 +-
 serde_arrow/src/arrow_impl/api.rs                   | 2 +-
 serde_arrow/src/internal/array_builder.rs           | 2 +-
 serde_arrow/src/internal/schema/from_samples/mod.rs | 1 +
 serde_arrow/src/test_with_arrow/impls/chrono.rs     | 2 +-
 6 files changed, 7 insertions(+), 6 deletions(-)

diff --git a/serde_arrow/src/_impl/docs/defs.rs b/serde_arrow/src/_impl/docs/defs.rs
index 3320c2fa..e30c8df8 100644
--- a/serde_arrow/src/_impl/docs/defs.rs
+++ b/serde_arrow/src/_impl/docs/defs.rs
@@ -28,7 +28,7 @@ pub fn example_arrow_arrays() -> (Vec<crate::_impl::arrow::datatypes::FieldRef>,
     let items = example_records();
 
     let fields = Vec::<crate::_impl::arrow::datatypes::FieldRef>::from_type::<Record>(TracingOptions::default()).unwrap();
-    let arrays = crate::to_arrow(&fields, &items).unwrap();
+    let arrays = crate::to_arrow(&fields, items).unwrap();
 
     (fields, arrays)
 }
@@ -40,7 +40,7 @@ pub fn example_arrow2_arrays() -> (Vec<crate::_impl::arrow2::datatypes::Field>,
     let items = example_records();
 
     let fields = Vec::<crate::_impl::arrow2::datatypes::Field>::from_type::<Record>(TracingOptions::default()).unwrap();
-    let arrays = crate::to_arrow2(&fields, &items).unwrap();
+    let arrays = crate::to_arrow2(&fields, items).unwrap();
 
     (fields, arrays)
 }
diff --git a/serde_arrow/src/arrow2_impl/api.rs b/serde_arrow/src/arrow2_impl/api.rs
index 41cad44b..602d4e90 100644
--- a/serde_arrow/src/arrow2_impl/api.rs
+++ b/serde_arrow/src/arrow2_impl/api.rs
@@ -107,7 +107,7 @@ impl crate::internal::array_builder::ArrayBuilder {
     /// Construct `arrow2` arrays and reset the builder (*requires one of the
     /// `arrow2-*` features*)
     pub fn to_arrow2(&mut self) -> Result<Vec<Box<dyn Array>>> {
-        self.to_arrays()?
+        self.build_arrays()?
             .into_iter()
             .map(Box::<dyn Array>::try_from)
             .collect()
diff --git a/serde_arrow/src/arrow_impl/api.rs b/serde_arrow/src/arrow_impl/api.rs
index cf298f27..126c4d3b 100644
--- a/serde_arrow/src/arrow_impl/api.rs
+++ b/serde_arrow/src/arrow_impl/api.rs
@@ -186,7 +186,7 @@ impl crate::internal::array_builder::ArrayBuilder {
     /// Construct `arrow` arrays and reset the builder (*requires one of the
     /// `arrow-*` features*)
     pub fn to_arrow(&mut self) -> Result<Vec<ArrayRef>> {
-        self.to_arrays()?
+        self.build_arrays()?
             .into_iter()
             .map(ArrayRef::try_from)
             .collect()
diff --git a/serde_arrow/src/internal/array_builder.rs b/serde_arrow/src/internal/array_builder.rs
index 869c9694..1be34f3e 100644
--- a/serde_arrow/src/internal/array_builder.rs
+++ b/serde_arrow/src/internal/array_builder.rs
@@ -83,7 +83,7 @@ impl ArrayBuilder {
         self.builder.extend(items)
     }
 
-    pub(crate) fn to_arrays(&mut self) -> Result<Vec<Array>> {
+    pub(crate) fn build_arrays(&mut self) -> Result<Vec<Array>> {
         let mut arrays = Vec::new();
         for field in self.builder.take_records()? {
             arrays.push(field.into_array()?);
diff --git a/serde_arrow/src/internal/schema/from_samples/mod.rs b/serde_arrow/src/internal/schema/from_samples/mod.rs
index bf36b934..66f0571e 100644
--- a/serde_arrow/src/internal/schema/from_samples/mod.rs
+++ b/serde_arrow/src/internal/schema/from_samples/mod.rs
@@ -335,6 +335,7 @@ impl<'a> serde::ser::Serializer for TracerSerializer<'a> {
 
     fn serialize_str(self, s: &str) -> Result<Self::Ok> {
         try_(|| {
+            #[allow(clippy::collapsible_else_if)]
             let (ty, st) = if !self.0.get_options().guess_dates {
                 (DataType::LargeUtf8, None)
             } else {
diff --git a/serde_arrow/src/test_with_arrow/impls/chrono.rs b/serde_arrow/src/test_with_arrow/impls/chrono.rs
index 885174aa..8cbec3a8 100644
--- a/serde_arrow/src/test_with_arrow/impls/chrono.rs
+++ b/serde_arrow/src/test_with_arrow/impls/chrono.rs
@@ -656,7 +656,7 @@ fn duration_example_as_string_details() {
     let mut builder = ArrayBuilder::new(schema).unwrap();
     builder.extend(&items).unwrap();
 
-    let arrays = builder.to_arrays().unwrap();
+    let arrays = builder.build_arrays().unwrap();
     let [array] = arrays.try_into().unwrap();
 
     assert_eq!(array.get_utf8(0).unwrap(), Some("12:10:42"));

From 3f7c3004b8d69febdd8a5e49332a784e22aad94f Mon Sep 17 00:00:00 2001
From: Christopher Prohm <mail@cprohm.de>
Date: Wed, 2 Oct 2024 20:42:21 +0200
Subject: [PATCH 13/28] Add support for jiff::DateTime

---
 .../deserialization/date64_deserializer.rs    | 44 ++++++++-
 serde_arrow/src/test_with_arrow/impls/jiff.rs | 92 +++++++++++++++++++
 2 files changed, 133 insertions(+), 3 deletions(-)

diff --git a/serde_arrow/src/internal/deserialization/date64_deserializer.rs b/serde_arrow/src/internal/deserialization/date64_deserializer.rs
index b6bc2601..031147f8 100644
--- a/serde_arrow/src/internal/deserialization/date64_deserializer.rs
+++ b/serde_arrow/src/internal/deserialization/date64_deserializer.rs
@@ -1,4 +1,4 @@
-use chrono::DateTime;
+use chrono::{DateTime, Datelike, Utc};
 use serde::de::Visitor;
 
 use crate::internal::{
@@ -43,11 +43,37 @@ impl<'a> Date64Deserializer<'a> {
         };
 
         if self.is_utc {
+            Ok(self.format_utc(date_time))
+        } else {
+            Ok(self.format_non_utc(date_time))
+        }
+    }
+
+    pub fn format_utc(&self, date_time: DateTime<Utc>) -> String {
+        // NOTE: chrono documents that Debug, not Display, can be parsed
+        format!("{:?}", date_time)
+    }
+
+    pub fn format_non_utc(&self, date_time: DateTime<Utc>) -> String {
+        let date_time = date_time.naive_utc();
+        // special handling of negative dates:
+        //
+        // - jiff expects 6 digits years in this case
+        // - chrono allows an arbitrary number of digits, when prefixed with a sign
+        //
+        // https://github.com/chronotope/chrono/blob/05a6ce68cf18a01274cef211b080a7170c7c1a1f/src/format/parse.rs#L368
+        if date_time.year() < 0 {
             // NOTE: chrono documents that Debug, not Display, can be parsed
-            Ok(format!("{:?}", date_time))
+            format!(
+                "-{positive_year:06}-{month:02}-{day:02}T{time:?}",
+                positive_year = -date_time.year(),
+                month = date_time.month(),
+                day = date_time.day(),
+                time = date_time.time(),
+            )
         } else {
             // NOTE: chrono documents that Debug, not Display, can be parsed
-            Ok(format!("{:?}", date_time.naive_utc()))
+            format!("{:?}", date_time)
         }
     }
 }
@@ -99,4 +125,16 @@ impl<'de> SimpleDeserializer<'de> for Date64Deserializer<'de> {
         })
         .ctx(self)
     }
+
+    fn deserialize_bytes<V: Visitor<'de>>(&mut self, visitor: V) -> Result<V::Value> {
+        try_(|| self.deserialize_byte_buf(visitor).ctx(self))
+    }
+
+    fn deserialize_byte_buf<V: Visitor<'de>>(&mut self, visitor: V) -> Result<V::Value> {
+        try_(|| {
+            let ts = self.array.next_required()?;
+            visitor.visit_byte_buf(self.get_string_repr(ts)?.into_bytes())
+        })
+        .ctx(self)
+    }
 }
diff --git a/serde_arrow/src/test_with_arrow/impls/jiff.rs b/serde_arrow/src/test_with_arrow/impls/jiff.rs
index 9c3d4d4e..1343e111 100644
--- a/serde_arrow/src/test_with_arrow/impls/jiff.rs
+++ b/serde_arrow/src/test_with_arrow/impls/jiff.rs
@@ -232,6 +232,15 @@ mod date {
             .deserialize(&items);
     }
 
+    #[test]
+    fn as_utf8() {
+        let items = items();
+        Test::new()
+            .with_schema(json!([{"name": "item", "data_type": "Utf8"}]))
+            .serialize(&items)
+            .deserialize(&items);
+    }
+
     #[test]
     fn as_date32() {
         let items = items();
@@ -242,3 +251,86 @@ mod date {
             .deserialize(&items);
     }
 }
+
+mod date_time {
+    use super::*;
+
+    fn items() -> Vec<Item<DateTime>> {
+        vec![
+            Item(date(2024, 10, 2).at(20, 26, 12, 0)),
+            Item(date(-10, 10, 30).at(0, 0, 0, 0)),
+            Item(date(-1000, 1, 12).at(23, 59, 59, 0)),
+        ]
+    }
+
+    #[test]
+    fn as_large_utf8() {
+        let items = items();
+        Test::new()
+            .with_schema(json!([{"name": "item", "data_type": "LargeUtf8"}]))
+            .trace_schema_from_samples(&items, TracingOptions::default())
+            .serialize(&items)
+            .deserialize(&items);
+    }
+
+    #[test]
+    fn as_utf8() {
+        let items = items();
+        Test::new()
+            .with_schema(json!([{"name": "item", "data_type": "Utf8"}]))
+            .serialize(&items)
+            .deserialize(&items);
+    }
+
+    #[test]
+    fn as_timestamp_second() {
+        let items = items();
+        Test::new()
+            .with_schema(json!([{"name": "item", "data_type": "Timestamp(Second, None)"}]))
+            .serialize(&items)
+            .deserialize(&items);
+    }
+
+    #[test]
+    fn as_timestamp_millisecond() {
+        let items = items();
+        Test::new()
+            .with_schema(json!([{"name": "item", "data_type": "Timestamp(Millisecond, None)"}]))
+            .serialize(&items)
+            .deserialize(&items);
+    }
+
+    #[test]
+    fn as_timestamp_microsecond() {
+        let items = items();
+        Test::new()
+            .with_schema(json!([{"name": "item", "data_type": "Timestamp(Microsecond, None)"}]))
+            .serialize(&items)
+            .deserialize(&items);
+    }
+
+    #[test]
+    fn as_timestamp_nanosecond() {
+        // the make sure the date can be represented as i64 with nanosecond resolution
+        let items = items()
+            .into_iter()
+            .filter(|Item(dt)| *dt >= date(1677, 9, 21).at(0, 12, 44, 0))
+            .collect::<Vec<_>>();
+        Test::new()
+            .with_schema(json!([{"name": "item", "data_type": "Timestamp(Nanosecond, None)"}]))
+            .serialize(&items)
+            .deserialize(&items);
+    }
+
+    #[test]
+    fn as_date64() {
+        let items = items();
+        Test::new()
+            .with_schema(
+                json!([{"name": "item", "data_type": "Date64", "strategy": "NaiveStrAsDate64"}]),
+            )
+            .trace_schema_from_samples(&items, TracingOptions::default().guess_dates(true))
+            .serialize(&items)
+            .deserialize(&items);
+    }
+}

From 9d7d8fda2ee7042fce91de1ff16adb9369362b56 Mon Sep 17 00:00:00 2001
From: Christopher Prohm <mail@cprohm.de>
Date: Thu, 3 Oct 2024 10:16:35 +0200
Subject: [PATCH 14/28] Add support jiff::Timestamp

---
 .../deserialization/date64_deserializer.rs    |   4 +-
 serde_arrow/src/test_with_arrow/impls/jiff.rs | 113 ++++++++++++++++++
 2 files changed, 116 insertions(+), 1 deletion(-)

diff --git a/serde_arrow/src/internal/deserialization/date64_deserializer.rs b/serde_arrow/src/internal/deserialization/date64_deserializer.rs
index 031147f8..611c98ec 100644
--- a/serde_arrow/src/internal/deserialization/date64_deserializer.rs
+++ b/serde_arrow/src/internal/deserialization/date64_deserializer.rs
@@ -51,7 +51,9 @@ impl<'a> Date64Deserializer<'a> {
 
     pub fn format_utc(&self, date_time: DateTime<Utc>) -> String {
         // NOTE: chrono documents that Debug, not Display, can be parsed
-        format!("{:?}", date_time)
+        let mut s = self.format_non_utc(date_time);
+        s.push('Z');
+        s
     }
 
     pub fn format_non_utc(&self, date_time: DateTime<Utc>) -> String {
diff --git a/serde_arrow/src/test_with_arrow/impls/jiff.rs b/serde_arrow/src/test_with_arrow/impls/jiff.rs
index 1343e111..97330959 100644
--- a/serde_arrow/src/test_with_arrow/impls/jiff.rs
+++ b/serde_arrow/src/test_with_arrow/impls/jiff.rs
@@ -334,3 +334,116 @@ mod date_time {
             .deserialize(&items);
     }
 }
+
+mod timestamp {
+    use super::*;
+
+    fn items() -> Vec<Item<Timestamp>> {
+        vec![
+            Item(
+                date(2024, 10, 2)
+                    .at(20, 26, 12, 0)
+                    .intz("UTC")
+                    .unwrap()
+                    .timestamp(),
+            ),
+            Item(
+                date(-10, 10, 30)
+                    .at(0, 0, 0, 0)
+                    .intz("UTC")
+                    .unwrap()
+                    .timestamp(),
+            ),
+            Item(
+                date(-1000, 1, 12)
+                    .at(23, 59, 59, 0)
+                    .intz("UTC")
+                    .unwrap()
+                    .timestamp(),
+            ),
+        ]
+    }
+
+    #[test]
+    fn as_large_utf8() {
+        let items = items();
+        Test::new()
+            .with_schema(json!([{"name": "item", "data_type": "LargeUtf8"}]))
+            .trace_schema_from_samples(&items, TracingOptions::default())
+            .serialize(&items)
+            .deserialize(&items);
+    }
+
+    #[test]
+    fn as_utf8() {
+        let items = items();
+        Test::new()
+            .with_schema(json!([{"name": "item", "data_type": "Utf8"}]))
+            .serialize(&items)
+            .deserialize(&items);
+    }
+
+    #[test]
+    fn as_timestamp_second() {
+        let items = items();
+        Test::new()
+            .with_schema(json!([{"name": "item", "data_type": "Timestamp(Second, Some(\"UTC\"))"}]))
+            .serialize(&items)
+            .deserialize(&items);
+    }
+
+    #[test]
+    fn as_timestamp_millisecond() {
+        let items = items();
+        Test::new()
+            .with_schema(
+                json!([{"name": "item", "data_type": "Timestamp(Millisecond, Some(\"UTC\"))"}]),
+            )
+            .serialize(&items)
+            .deserialize(&items);
+    }
+
+    #[test]
+    fn as_timestamp_microsecond() {
+        let items = items();
+        Test::new()
+            .with_schema(
+                json!([{"name": "item", "data_type": "Timestamp(Microsecond, Some(\"UTC\"))"}]),
+            )
+            .serialize(&items)
+            .deserialize(&items);
+    }
+
+    #[test]
+    fn as_timestamp_nanosecond() {
+        // the make sure the date can be represented as i64 with nanosecond resolution
+        let items = items()
+            .into_iter()
+            .filter(|Item(dt)| {
+                *dt >= date(1677, 9, 21)
+                    .at(0, 12, 44, 0)
+                    .intz("UTC")
+                    .unwrap()
+                    .timestamp()
+            })
+            .collect::<Vec<_>>();
+        Test::new()
+            .with_schema(
+                json!([{"name": "item", "data_type": "Timestamp(Nanosecond, Some(\"UTC\"))"}]),
+            )
+            .serialize(&items)
+            .deserialize(&items);
+    }
+
+    #[test]
+    fn as_date64() {
+        let items = items();
+        Test::new()
+            .with_schema(
+                json!([{"name": "item", "data_type": "Date64", "strategy": "UtcStrAsDate64"}]),
+            )
+            .trace_schema_from_samples(&items, TracingOptions::default().guess_dates(true))
+            .serialize(&items)
+            .deserialize(&items);
+    }
+}

From 24c982521f9f36a6d0fd7bad0c81380642fafaa2 Mon Sep 17 00:00:00 2001
From: Christopher Prohm <mail@cprohm.de>
Date: Thu, 3 Oct 2024 10:56:12 +0200
Subject: [PATCH 15/28] Move chrono parsers to top-level and start to return
 data from parsers

---
 .../{schema/from_samples => }/chrono.rs       | 80 +++++++++++++++----
 serde_arrow/src/internal/mod.rs               |  1 +
 .../src/internal/schema/from_samples/mod.rs   |  2 +-
 3 files changed, 65 insertions(+), 18 deletions(-)
 rename serde_arrow/src/internal/{schema/from_samples => }/chrono.rs (56%)

diff --git a/serde_arrow/src/internal/schema/from_samples/chrono.rs b/serde_arrow/src/internal/chrono.rs
similarity index 56%
rename from serde_arrow/src/internal/schema/from_samples/chrono.rs
rename to serde_arrow/src/internal/chrono.rs
index 957dbdac..ad72ee96 100644
--- a/serde_arrow/src/internal/schema/from_samples/chrono.rs
+++ b/serde_arrow/src/internal/chrono.rs
@@ -1,39 +1,57 @@
+//! Support for Parsing datetime related quantities
+//!
+
 pub fn matches_naive_datetime(s: &str) -> bool {
-    eval_parser(parsing::match_naive_datetime, s)
+    match_parser(parsing::match_naive_datetime, s)
 }
 
 pub fn matches_utc_datetime(s: &str) -> bool {
-    eval_parser(parsing::match_utc_datetime, s)
+    match_parser(parsing::match_utc_datetime, s)
 }
 
 pub fn matches_naive_date(s: &str) -> bool {
-    eval_parser(parsing::match_naive_date, s)
+    match_parser(parsing::match_naive_date, s)
 }
 
 pub fn matches_naive_time(s: &str) -> bool {
-    eval_parser(parsing::match_naive_time, s)
+    match_parser(parsing::match_naive_time, s)
 }
 
-fn eval_parser<F: Fn(&str) -> Result<&str, &str>>(parser: F, s: &str) -> bool {
+fn match_parser<F: Fn(&str) -> Result<&str, &str>>(parser: F, s: &str) -> bool {
     parser(s.trim()).map(str::is_empty).unwrap_or_default()
 }
 
-/// minimalistic monadic parser
+/// minimalistic monadic parsers for datetime objects
+///
+/// Each parser has the the following interface:
+///
+/// `fn (string_to_parser, ..extra_args) -> Result<(rest, result), unmatched_string>`
 ///
-/// Returns the Err(unmatched_string) on error and Ok(rest) on success
 mod parsing {
     pub const DIGIT: &[char] = &['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'];
 
-    pub fn match_optional_sign(s: &str) -> Result<&str, &str> {
-        Ok(s.strip_prefix(['+', '-']).unwrap_or(s))
+    fn get_prefix<'a>(s: &'a str, rest: &str) -> &'a str {
+        debug_assert!(s.ends_with(rest), "Invalid call to get prefix");
+        let len_prefix = s.len() - rest.len();
+        &s[..len_prefix]
+    }
+
+    pub fn match_optional_sign(s: &str) -> Result<(&str, Option<char>), &str> {
+        if let Some(rest) = s.strip_prefix('+') {
+            Ok((rest, Some('+')))
+        } else if let Some(rest) = s.strip_prefix('-') {
+            Ok((rest, Some('-')))
+        } else {
+            Ok((s, None))
+        }
     }
 
-    pub fn match_one_or_more_digits(s: &str) -> Result<&str, &str> {
-        let mut s = s.strip_prefix(DIGIT).ok_or(s)?;
-        while let Some(new_s) = s.strip_prefix(DIGIT) {
-            s = new_s;
+    pub fn match_one_or_more_digits(s: &str) -> Result<(&str, &str), &str> {
+        let mut rest = s.strip_prefix(DIGIT).ok_or(s)?;
+        while let Some(new_rest) = rest.strip_prefix(DIGIT) {
+            rest = new_rest;
         }
-        Ok(s)
+        Ok((rest, get_prefix(s, rest)))
     }
 
     pub fn match_one_or_two_digits(s: &str) -> Result<&str, &str> {
@@ -55,8 +73,8 @@ mod parsing {
     }
 
     pub fn match_naive_date(s: &str) -> Result<&str, &str> {
-        let s = match_optional_sign(s)?;
-        let s = match_one_or_more_digits(s)?;
+        let (s, _sign) = match_optional_sign(s)?;
+        let (s, _year) = match_one_or_more_digits(s)?;
         let s = match_char(s, '-')?;
         let s = match_one_or_two_digits(s)?;
         let s = match_char(s, '-')?;
@@ -71,7 +89,8 @@ mod parsing {
         let s = match_one_or_two_digits(s)?;
 
         if let Some(s) = s.strip_prefix('.') {
-            match_one_or_more_digits(s)
+            let (s, _subsecond) = match_one_or_more_digits(s)?;
+            Ok(s)
         } else {
             Ok(s)
         }
@@ -133,3 +152,30 @@ fn test_match_naive_time() {
     assert_eq!(parsing::match_naive_time("23:00:12"), Ok(""));
     assert_eq!(parsing::match_naive_time("23:00:12.999"), Ok(""));
 }
+
+#[test]
+fn match_optional_sign() {
+    assert_eq!(parsing::match_optional_sign("foo"), Ok(("foo", None)));
+    assert_eq!(parsing::match_optional_sign("?foo"), Ok(("?foo", None)));
+    assert_eq!(parsing::match_optional_sign("+foo"), Ok(("foo", Some('+'))));
+    assert_eq!(parsing::match_optional_sign("-foo"), Ok(("foo", Some('-'))));
+}
+
+#[test]
+fn match_one_or_more_digits() {
+    assert_eq!(parsing::match_one_or_more_digits("foo"), Err("foo"));
+    assert_eq!(parsing::match_one_or_more_digits(" 1foo"), Err(" 1foo"));
+    assert_eq!(parsing::match_one_or_more_digits("1foo"), Ok(("foo", "1")));
+    assert_eq!(
+        parsing::match_one_or_more_digits("12foo"),
+        Ok(("foo", "12"))
+    );
+    assert_eq!(
+        parsing::match_one_or_more_digits("123foo"),
+        Ok(("foo", "123"))
+    );
+    assert_eq!(
+        parsing::match_one_or_more_digits("1234foo"),
+        Ok(("foo", "1234"))
+    );
+}
diff --git a/serde_arrow/src/internal/mod.rs b/serde_arrow/src/internal/mod.rs
index 1c7188d6..a53053bc 100644
--- a/serde_arrow/src/internal/mod.rs
+++ b/serde_arrow/src/internal/mod.rs
@@ -1,5 +1,6 @@
 pub mod array_builder;
 pub mod arrow;
+pub mod chrono;
 pub mod deserialization;
 pub mod deserializer;
 pub mod error;
diff --git a/serde_arrow/src/internal/schema/from_samples/mod.rs b/serde_arrow/src/internal/schema/from_samples/mod.rs
index 66f0571e..9103204c 100644
--- a/serde_arrow/src/internal/schema/from_samples/mod.rs
+++ b/serde_arrow/src/internal/schema/from_samples/mod.rs
@@ -1,5 +1,4 @@
 //! Support for `from_samples`
-mod chrono;
 #[cfg(test)]
 mod test_error_messages;
 
@@ -9,6 +8,7 @@ use serde::{ser::Impossible, Serialize};
 
 use crate::internal::{
     arrow::{DataType, TimeUnit},
+    chrono,
     error::{fail, try_, Context, ContextSupport, Error, Result},
     schema::{Strategy, TracingMode, TracingOptions},
 };

From 3ef1634517214b6f6ea45741fa045cee0db32f1c Mon Sep 17 00:00:00 2001
From: Christopher Prohm <mail@cprohm.de>
Date: Thu, 3 Oct 2024 11:35:33 +0200
Subject: [PATCH 16/28] Modify all parsers to return the matched data

---
 serde_arrow/src/internal/chrono.rs | 413 ++++++++++++++++++++++++-----
 1 file changed, 341 insertions(+), 72 deletions(-)

diff --git a/serde_arrow/src/internal/chrono.rs b/serde_arrow/src/internal/chrono.rs
index ad72ee96..aa39f084 100644
--- a/serde_arrow/src/internal/chrono.rs
+++ b/serde_arrow/src/internal/chrono.rs
@@ -2,23 +2,27 @@
 //!
 
 pub fn matches_naive_datetime(s: &str) -> bool {
-    match_parser(parsing::match_naive_datetime, s)
+    parsing::match_naive_datetime(s)
+        .map(|(rest, _)| rest.is_empty())
+        .unwrap_or_default()
 }
 
 pub fn matches_utc_datetime(s: &str) -> bool {
-    match_parser(parsing::match_utc_datetime, s)
+    parsing::match_utc_datetime(s)
+        .map(|(rest, _)| rest.is_empty())
+        .unwrap_or_default()
 }
 
 pub fn matches_naive_date(s: &str) -> bool {
-    match_parser(parsing::match_naive_date, s)
+    parsing::match_naive_date(s)
+        .map(|(rest, _)| rest.is_empty())
+        .unwrap_or_default()
 }
 
 pub fn matches_naive_time(s: &str) -> bool {
-    match_parser(parsing::match_naive_time, s)
-}
-
-fn match_parser<F: Fn(&str) -> Result<&str, &str>>(parser: F, s: &str) -> bool {
-    parser(s.trim()).map(str::is_empty).unwrap_or_default()
+    parsing::match_naive_time(s)
+        .map(|(rest, _)| rest.is_empty())
+        .unwrap_or_default()
 }
 
 /// minimalistic monadic parsers for datetime objects
@@ -30,85 +34,150 @@ fn match_parser<F: Fn(&str) -> Result<&str, &str>>(parser: F, s: &str) -> bool {
 mod parsing {
     pub const DIGIT: &[char] = &['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'];
 
-    fn get_prefix<'a>(s: &'a str, rest: &str) -> &'a str {
-        debug_assert!(s.ends_with(rest), "Invalid call to get prefix");
-        let len_prefix = s.len() - rest.len();
-        &s[..len_prefix]
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    pub struct Date<'a> {
+        pub sign: Option<char>,
+        pub year: &'a str,
+        pub month: &'a str,
+        pub day: &'a str,
     }
 
-    pub fn match_optional_sign(s: &str) -> Result<(&str, Option<char>), &str> {
-        if let Some(rest) = s.strip_prefix('+') {
-            Ok((rest, Some('+')))
-        } else if let Some(rest) = s.strip_prefix('-') {
-            Ok((rest, Some('-')))
-        } else {
-            Ok((s, None))
-        }
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    pub struct Time<'a> {
+        pub hour: &'a str,
+        pub minute: &'a str,
+        pub second: &'a str,
+        pub subsecond: Option<&'a str>,
     }
 
-    pub fn match_one_or_more_digits(s: &str) -> Result<(&str, &str), &str> {
-        let mut rest = s.strip_prefix(DIGIT).ok_or(s)?;
-        while let Some(new_rest) = rest.strip_prefix(DIGIT) {
-            rest = new_rest;
-        }
-        Ok((rest, get_prefix(s, rest)))
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    pub struct DateTime<'a> {
+        pub date: Date<'a>,
+        pub time: Time<'a>,
     }
 
-    pub fn match_one_or_two_digits(s: &str) -> Result<&str, &str> {
-        let s = s.strip_prefix(DIGIT).ok_or(s)?;
-        Ok(s.strip_prefix(DIGIT).unwrap_or(s))
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    pub struct DateTimeUtc<'a> {
+        pub date: Date<'a>,
+        pub time: Time<'a>,
+        pub timezone: &'a str,
     }
 
-    pub fn match_char(s: &str, c: char) -> Result<&str, &str> {
-        s.strip_prefix(c).ok_or(s)
+    pub fn match_utc_datetime(s: &str) -> Result<(&str, DateTimeUtc<'_>), &str> {
+        let (s, DateTime { date, time }) = match_naive_datetime_with_sep(s, &['T', ' '])?;
+        let (s, timezone) = match_utc_timezone(s)?;
+        Ok((
+            s,
+            DateTimeUtc {
+                date,
+                time,
+                timezone,
+            },
+        ))
+    }
+
+    pub fn match_naive_datetime(s: &str) -> Result<(&str, DateTime<'_>), &str> {
+        match_naive_datetime_with_sep(s, &['T'])
+    }
+
+    pub fn match_naive_date(s: &str) -> Result<(&str, Date<'_>), &str> {
+        let (s, sign) = match_optional_sign(s)?;
+        let (s, year) = match_one_or_more_digits(s)?;
+        let (s, _) = match_char(s, '-')?;
+        let (s, month) = match_one_or_two_digits(s)?;
+        let (s, _) = match_char(s, '-')?;
+        let (s, day) = match_one_or_two_digits(s)?;
+        Ok((
+            s,
+            Date {
+                sign,
+                year,
+                month,
+                day,
+            },
+        ))
+    }
+
+    pub fn match_naive_time(s: &str) -> Result<(&str, Time<'_>), &str> {
+        let (s, hour) = match_one_or_two_digits(s)?;
+        let (s, _) = match_char(s, ':')?;
+        let (s, minute) = match_one_or_two_digits(s)?;
+        let (s, _) = match_char(s, ':')?;
+        let (s, second) = match_one_or_two_digits(s)?;
+
+        let (s, subsecond) = if let Some(s) = s.strip_prefix('.') {
+            let (s, subsecond) = match_one_or_more_digits(s)?;
+            (s, Some(subsecond))
+        } else {
+            (s, None)
+        };
+
+        Ok((
+            s,
+            Time {
+                hour,
+                minute,
+                second,
+                subsecond,
+            },
+        ))
     }
 
     pub fn match_naive_datetime_with_sep<'a>(
         s: &'a str,
         sep: &'_ [char],
-    ) -> Result<&'a str, &'a str> {
-        let s = match_naive_date(s)?;
+    ) -> Result<(&'a str, DateTime<'a>), &'a str> {
+        let (s, date) = match_naive_date(s)?;
         let s = s.strip_prefix(sep).ok_or(s)?;
-        match_naive_time(s)
+        let (s, time) = match_naive_time(s)?;
+        Ok((s, DateTime { date, time }))
     }
 
-    pub fn match_naive_date(s: &str) -> Result<&str, &str> {
-        let (s, _sign) = match_optional_sign(s)?;
-        let (s, _year) = match_one_or_more_digits(s)?;
-        let s = match_char(s, '-')?;
-        let s = match_one_or_two_digits(s)?;
-        let s = match_char(s, '-')?;
-        match_one_or_two_digits(s)
+    /// Match known UTC time zone designators
+    ///
+    /// Note: this function is more permissive than some libraries (e.g., jiff)
+    pub fn match_utc_timezone(s: &str) -> Result<(&str, &str), &str> {
+        for prefix in ["Z", "+0000", "+00:00"] {
+            if let Some(rest) = s.strip_prefix(prefix) {
+                return Ok((rest, get_prefix(s, rest)));
+            }
+        }
+        Err(s)
     }
 
-    pub fn match_naive_time(s: &str) -> Result<&str, &str> {
-        let s = match_one_or_two_digits(s)?;
-        let s = match_char(s, ':')?;
-        let s = match_one_or_two_digits(s)?;
-        let s = match_char(s, ':')?;
-        let s = match_one_or_two_digits(s)?;
+    fn get_prefix<'a>(s: &'a str, rest: &str) -> &'a str {
+        debug_assert!(s.ends_with(rest), "Invalid call to get prefix");
+        let len_prefix = s.len() - rest.len();
+        &s[..len_prefix]
+    }
 
-        if let Some(s) = s.strip_prefix('.') {
-            let (s, _subsecond) = match_one_or_more_digits(s)?;
-            Ok(s)
+    pub fn match_optional_sign(s: &str) -> Result<(&str, Option<char>), &str> {
+        if let Some(rest) = s.strip_prefix('+') {
+            Ok((rest, Some('+')))
+        } else if let Some(rest) = s.strip_prefix('-') {
+            Ok((rest, Some('-')))
         } else {
-            Ok(s)
+            Ok((s, None))
         }
     }
 
-    pub fn match_naive_datetime(s: &str) -> Result<&str, &str> {
-        match_naive_datetime_with_sep(s, &['T'])
+    pub fn match_one_or_more_digits(s: &str) -> Result<(&str, &str), &str> {
+        let mut rest = s.strip_prefix(DIGIT).ok_or(s)?;
+        while let Some(new_rest) = rest.strip_prefix(DIGIT) {
+            rest = new_rest;
+        }
+        Ok((rest, get_prefix(s, rest)))
     }
 
-    pub fn match_utc_datetime(s: &str) -> Result<&str, &str> {
-        let s = match_naive_datetime_with_sep(s, &['T', ' '])?;
+    pub fn match_one_or_two_digits(s: &str) -> Result<(&str, &str), &str> {
+        let rest = s.strip_prefix(DIGIT).ok_or(s)?;
+        let rest = rest.strip_prefix(DIGIT).unwrap_or(rest);
+        Ok((rest, get_prefix(s, rest)))
+    }
 
-        if let Some(s) = s.strip_prefix('Z') {
-            Ok(s)
-        } else if let Some(s) = s.strip_prefix("+0000") {
-            Ok(s)
-        } else if let Some(s) = s.strip_prefix("+00:00") {
-            Ok(s)
+    pub fn match_char(s: &str, c: char) -> Result<(&str, char), &str> {
+        if let Some(rest) = s.strip_prefix(c) {
+            Ok((rest, c))
         } else {
             Err(s)
         }
@@ -118,39 +187,223 @@ mod parsing {
 #[test]
 fn test_match_naive_datetime() {
     // chrono examples
-    assert_eq!(parsing::match_naive_datetime("2015-09-18T23:56:04"), Ok(""));
+    assert_eq!(
+        parsing::match_naive_datetime("2015-09-18T23:56:04"),
+        Ok((
+            "",
+            parsing::DateTime {
+                date: parsing::Date {
+                    sign: None,
+                    year: "2015",
+                    month: "09",
+                    day: "18"
+                },
+                time: parsing::Time {
+                    hour: "23",
+                    minute: "56",
+                    second: "04",
+                    subsecond: None
+                }
+            }
+        ))
+    );
     assert_eq!(
         parsing::match_naive_datetime("+12345-6-7T7:59:60.5"),
-        Ok("")
+        Ok((
+            "",
+            parsing::DateTime {
+                date: parsing::Date {
+                    sign: Some('+'),
+                    year: "12345",
+                    month: "6",
+                    day: "7"
+                },
+                time: parsing::Time {
+                    hour: "7",
+                    minute: "59",
+                    second: "60",
+                    subsecond: Some("5")
+                },
+            }
+        ))
     );
 }
 
 #[test]
 fn test_match_utc_datetime() {
     // examples from the chrono docs
-    assert_eq!(parsing::match_utc_datetime("2012-12-12T12:12:12Z"), Ok(""));
-    assert_eq!(parsing::match_utc_datetime("2012-12-12 12:12:12Z"), Ok(""));
+    assert_eq!(
+        parsing::match_utc_datetime("2012-12-12T12:12:12Z"),
+        Ok((
+            "",
+            parsing::DateTimeUtc {
+                date: parsing::Date {
+                    sign: None,
+                    year: "2012",
+                    month: "12",
+                    day: "12"
+                },
+                time: parsing::Time {
+                    hour: "12",
+                    minute: "12",
+                    second: "12",
+                    subsecond: None
+                },
+                timezone: "Z",
+            }
+        ))
+    );
+    assert_eq!(
+        parsing::match_utc_datetime("2012-12-12 12:12:12Z"),
+        Ok((
+            "",
+            parsing::DateTimeUtc {
+                date: parsing::Date {
+                    sign: None,
+                    year: "2012",
+                    month: "12",
+                    day: "12"
+                },
+                time: parsing::Time {
+                    hour: "12",
+                    minute: "12",
+                    second: "12",
+                    subsecond: None
+                },
+                timezone: "Z",
+            }
+        ))
+    );
     assert_eq!(
         parsing::match_utc_datetime("2012-12-12 12:12:12+0000"),
-        Ok("")
+        Ok((
+            "",
+            parsing::DateTimeUtc {
+                date: parsing::Date {
+                    sign: None,
+                    year: "2012",
+                    month: "12",
+                    day: "12"
+                },
+                time: parsing::Time {
+                    hour: "12",
+                    minute: "12",
+                    second: "12",
+                    subsecond: None
+                },
+                timezone: "+0000",
+            }
+        ))
     );
     assert_eq!(
         parsing::match_utc_datetime("2012-12-12 12:12:12+00:00"),
-        Ok("")
+        Ok((
+            "",
+            parsing::DateTimeUtc {
+                date: parsing::Date {
+                    sign: None,
+                    year: "2012",
+                    month: "12",
+                    day: "12"
+                },
+                time: parsing::Time {
+                    hour: "12",
+                    minute: "12",
+                    second: "12",
+                    subsecond: None
+                },
+                timezone: "+00:00",
+            }
+        ))
     );
 }
 
 #[test]
 fn test_match_naive_date() {
-    assert_eq!(parsing::match_naive_date("+12345-6-7"), Ok(""));
-    assert_eq!(parsing::match_naive_date("2015-09-18"), Ok(""));
-    assert_eq!(parsing::match_naive_date("-20-21-22"), Ok(""));
+    assert_eq!(
+        parsing::match_naive_date("+12345-6-7"),
+        Ok((
+            "",
+            parsing::Date {
+                sign: Some('+'),
+                year: "12345",
+                month: "6",
+                day: "7"
+            }
+        ))
+    );
+    assert_eq!(
+        parsing::match_naive_date("2015-09-18"),
+        Ok((
+            "",
+            parsing::Date {
+                sign: None,
+                year: "2015",
+                month: "09",
+                day: "18"
+            }
+        ))
+    );
+
+    // NOTE: the content is not verified
+    assert_eq!(
+        parsing::match_naive_date("-20-21-22"),
+        Ok((
+            "",
+            parsing::Date {
+                sign: Some('-'),
+                year: "20",
+                month: "21",
+                day: "22"
+            }
+        ))
+    );
+
+    assert_eq!(parsing::match_naive_date("foo"), Err("foo"));
+
+    assert_eq!(parsing::match_naive_date("2015-123-18"), Err("3-18"));
+
+    // trailing digits are returned as rest
+    assert_eq!(
+        parsing::match_naive_date("2024-12-091234"),
+        Ok((
+            "1234",
+            parsing::Date {
+                sign: None,
+                year: "2024",
+                month: "12",
+                day: "09"
+            }
+        ))
+    );
 }
 
 #[test]
 fn test_match_naive_time() {
-    assert_eq!(parsing::match_naive_time("23:00:12"), Ok(""));
-    assert_eq!(parsing::match_naive_time("23:00:12.999"), Ok(""));
+    assert_eq!(
+        parsing::match_naive_time("23:00:12"),
+        Ok((
+            "",
+            parsing::Time {
+                hour: "23",
+                minute: "00",
+                second: "12",
+                subsecond: None
+            }
+        ))
+    );
+    assert_eq!(
+        parsing::match_naive_time("23:00:12.999"),
+        Ok((
+            "",
+            parsing::Time {
+                hour: "23",
+                minute: "00",
+                second: "12",
+                subsecond: Some("999")
+            }
+        ))
+    );
 }
 
 #[test]
@@ -179,3 +432,19 @@ fn match_one_or_more_digits() {
         Ok(("foo", "1234"))
     );
 }
+
+#[test]
+fn match_one_or_two_digits() {
+    assert_eq!(parsing::match_one_or_two_digits("foo"), Err("foo"));
+    assert_eq!(parsing::match_one_or_two_digits(" 1foo"), Err(" 1foo"));
+    assert_eq!(parsing::match_one_or_two_digits("1foo"), Ok(("foo", "1")));
+    assert_eq!(parsing::match_one_or_two_digits("12foo"), Ok(("foo", "12")));
+    assert_eq!(
+        parsing::match_one_or_two_digits("123foo"),
+        Ok(("3foo", "12"))
+    );
+    assert_eq!(
+        parsing::match_one_or_two_digits("1234foo"),
+        Ok(("34foo", "12"))
+    );
+}

From e78c01a19405d86ccd66fc8817e9233c2ac5183c Mon Sep 17 00:00:00 2001
From: Christopher Prohm <mail@cprohm.de>
Date: Thu, 3 Oct 2024 12:23:52 +0200
Subject: [PATCH 17/28] Implement span parsing

---
 serde_arrow/src/internal/chrono.rs | 303 +++++++++++++++++++++++++++--
 1 file changed, 287 insertions(+), 16 deletions(-)

diff --git a/serde_arrow/src/internal/chrono.rs b/serde_arrow/src/internal/chrono.rs
index aa39f084..921dbef4 100644
--- a/serde_arrow/src/internal/chrono.rs
+++ b/serde_arrow/src/internal/chrono.rs
@@ -1,28 +1,39 @@
 //! Support for Parsing datetime related quantities
 //!
+use crate::internal::error::Result;
 
+use parsing::ParseResult;
+
+pub use parsing::Span;
+
+/// Check whether `s` can be parsed as a naive datetime
 pub fn matches_naive_datetime(s: &str) -> bool {
-    parsing::match_naive_datetime(s)
-        .map(|(rest, _)| rest.is_empty())
-        .unwrap_or_default()
+    parsing::match_naive_datetime(s).matches()
 }
 
+/// Check whether `s` can be parsed as a UTC datetime
 pub fn matches_utc_datetime(s: &str) -> bool {
-    parsing::match_utc_datetime(s)
-        .map(|(rest, _)| rest.is_empty())
-        .unwrap_or_default()
+    parsing::match_utc_datetime(s).matches()
 }
 
+/// Check whether `s` can be parsed as a naive date
 pub fn matches_naive_date(s: &str) -> bool {
-    parsing::match_naive_date(s)
-        .map(|(rest, _)| rest.is_empty())
-        .unwrap_or_default()
+    parsing::match_naive_date(s).matches()
 }
 
+/// Check whether `s` can be parsed as a naive time
 pub fn matches_naive_time(s: &str) -> bool {
-    parsing::match_naive_time(s)
-        .map(|(rest, _)| rest.is_empty())
-        .unwrap_or_default()
+    parsing::match_naive_time(s).matches()
+}
+
+/// Check whether `s` can be parsed as a span
+pub fn matches_span(s: &str) -> bool {
+    parsing::match_span(s).matches()
+}
+
+/// Parse `s` as a span
+pub fn parse_span(s: &str) -> Result<Span<'_>> {
+    parsing::match_span(s).into_result("Span")
 }
 
 /// minimalistic monadic parsers for datetime objects
@@ -34,7 +45,34 @@ pub fn matches_naive_time(s: &str) -> bool {
 mod parsing {
     pub const DIGIT: &[char] = &['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'];
 
-    #[derive(Debug, Clone, PartialEq, Eq)]
+    pub trait ParseResult {
+        type Output;
+
+        fn matches(&self) -> bool;
+        fn into_result(self, output_type: &str) -> crate::internal::error::Result<Self::Output>;
+    }
+
+    impl<'a, 'e, R> ParseResult for Result<(&'a str, R), &'e str> {
+        type Output = R;
+
+        fn matches(&self) -> bool {
+            match self {
+                Ok((rest, _)) => rest.is_empty(),
+                Err(_) => false,
+            }
+        }
+
+        fn into_result(self, output_type: &str) -> crate::internal::error::Result<Self::Output> {
+            match self {
+                Ok((rest, output)) if rest.is_empty() => Ok(output),
+                Ok((unmatched, _)) | Err(unmatched) => crate::internal::error::fail!(
+                    "Could not parse the string as {output_type}, unmatched content: {unmatched:?}"
+                ),
+            }
+        }
+    }
+
+    #[derive(Debug, Default, Clone, PartialEq, Eq)]
     pub struct Date<'a> {
         pub sign: Option<char>,
         pub year: &'a str,
@@ -42,7 +80,7 @@ mod parsing {
         pub day: &'a str,
     }
 
-    #[derive(Debug, Clone, PartialEq, Eq)]
+    #[derive(Debug, Default, Clone, PartialEq, Eq)]
     pub struct Time<'a> {
         pub hour: &'a str,
         pub minute: &'a str,
@@ -50,19 +88,31 @@ mod parsing {
         pub subsecond: Option<&'a str>,
     }
 
-    #[derive(Debug, Clone, PartialEq, Eq)]
+    #[derive(Debug, Default, Clone, PartialEq, Eq)]
     pub struct DateTime<'a> {
         pub date: Date<'a>,
         pub time: Time<'a>,
     }
 
-    #[derive(Debug, Clone, PartialEq, Eq)]
+    #[derive(Debug, Default, Clone, PartialEq, Eq)]
     pub struct DateTimeUtc<'a> {
         pub date: Date<'a>,
         pub time: Time<'a>,
         pub timezone: &'a str,
     }
 
+    #[derive(Debug, Default, Clone, PartialEq, Eq)]
+    pub struct Span<'a> {
+        pub year: Option<&'a str>,
+        pub month: Option<&'a str>,
+        pub day: Option<&'a str>,
+        pub week: Option<&'a str>,
+        pub hour: Option<&'a str>,
+        pub minute: Option<&'a str>,
+        pub second: Option<&'a str>,
+        pub subsecond: Option<&'a str>,
+    }
+
     pub fn match_utc_datetime(s: &str) -> Result<(&str, DateTimeUtc<'_>), &str> {
         let (s, DateTime { date, time }) = match_naive_datetime_with_sep(s, &['T', ' '])?;
         let (s, timezone) = match_utc_timezone(s)?;
@@ -123,6 +173,60 @@ mod parsing {
         ))
     }
 
+    pub fn match_span(s: &str) -> Result<(&str, Span<'_>), &str> {
+        let (s, _) = match_char_case_insensitive(s, 'P')?;
+        let (s, year) = match_optional_span_value(s, 'Y')?;
+        let (s, month) = match_optional_span_value(s, 'M')?;
+        let (s, week) = match_optional_span_value(s, 'W')?;
+        let (s, day) = match_optional_span_value(s, 'D')?;
+
+        let (s, hour, minute, second, subsecond) = if let Some(s) = s.strip_prefix(['t', 'T']) {
+            let (s, hour) = match_optional_span_value(s, 'H')?;
+            let (s, minute) = match_optional_span_value(s, 'M')?;
+            let (s, second, subsecond) = match_optional_span_seconds(s)?;
+            (s, hour, minute, second, subsecond)
+        } else {
+            (s, None, None, None, None)
+        };
+
+        Ok((
+            s,
+            Span {
+                year,
+                month,
+                week,
+                day,
+                hour,
+                minute,
+                second,
+                subsecond,
+            },
+        ))
+    }
+
+    pub fn match_optional_span_seconds(
+        s: &str,
+    ) -> Result<(&str, Option<&str>, Option<&str>), &str> {
+        let Ok((rest, second)) = match_one_or_more_digits(s) else {
+            return Ok((s, None, None));
+        };
+        let second = Some(second);
+
+        let (rest, subsecond) = if let Some(rest) = rest.strip_prefix('.') {
+            // Q: is a subsecond part really required after a '.'?
+            let (rest, subsecond) = match_one_or_more_digits(rest)?;
+            (rest, Some(subsecond))
+        } else {
+            (rest, None)
+        };
+
+        let Ok((rest, _)) = match_char_case_insensitive(rest, 'S') else {
+            return Ok((s, None, None));
+        };
+
+        Ok((rest, second, subsecond))
+    }
+
     pub fn match_naive_datetime_with_sep<'a>(
         s: &'a str,
         sep: &'_ [char],
@@ -151,6 +255,17 @@ mod parsing {
         &s[..len_prefix]
     }
 
+    /// Match a value in a span
+    pub fn match_optional_span_value(s: &str, unit: char) -> Result<(&str, Option<&str>), &str> {
+        let Ok((rest, value)) = match_one_or_more_digits(s) else {
+            return Ok((s, None));
+        };
+        let Ok((rest, _)) = match_char_case_insensitive(rest, unit) else {
+            return Ok((s, None));
+        };
+        Ok((rest, Some(value)))
+    }
+
     pub fn match_optional_sign(s: &str) -> Result<(&str, Option<char>), &str> {
         if let Some(rest) = s.strip_prefix('+') {
             Ok((rest, Some('+')))
@@ -182,6 +297,24 @@ mod parsing {
             Err(s)
         }
     }
+
+    /// Match a character case insensitive
+    ///
+    /// Note: `c` must be an ASCII character and must be uppercase
+    pub fn match_char_case_insensitive(s: &str, c: char) -> Result<(&str, char), &str> {
+        debug_assert!(c.is_ascii());
+        debug_assert!(c.is_ascii_uppercase());
+
+        let c_lowercase = c.to_ascii_lowercase();
+
+        if let Some(rest) = s.strip_prefix(c) {
+            Ok((rest, c))
+        } else if let Some(rest) = s.strip_prefix(c_lowercase) {
+            Ok((rest, c_lowercase))
+        } else {
+            Err(s)
+        }
+    }
 }
 
 #[test]
@@ -406,6 +539,144 @@ fn test_match_naive_time() {
     );
 }
 
+#[test]
+fn match_span() {
+    // jiff examples
+    assert_eq!(
+        parsing::match_span("P40D"),
+        Ok((
+            "",
+            parsing::Span {
+                day: Some("40"),
+                ..Default::default()
+            }
+        ))
+    );
+    assert_eq!(
+        parsing::match_span("P1y1d"),
+        Ok((
+            "",
+            parsing::Span {
+                year: Some("1"),
+                day: Some("1"),
+                ..Default::default()
+            }
+        ))
+    );
+    assert_eq!(
+        parsing::match_span("P1m"),
+        Ok((
+            "",
+            parsing::Span {
+                month: Some("1"),
+                ..Default::default()
+            }
+        ))
+    );
+    assert_eq!(
+        parsing::match_span("P1w"),
+        Ok((
+            "",
+            parsing::Span {
+                week: Some("1"),
+                ..Default::default()
+            }
+        ))
+    );
+    assert_eq!(
+        parsing::match_span("P1w4d"),
+        Ok((
+            "",
+            parsing::Span {
+                week: Some("1"),
+                day: Some("4"),
+                ..Default::default()
+            }
+        ))
+    );
+    assert_eq!(
+        parsing::match_span("P0d"),
+        Ok((
+            "",
+            parsing::Span {
+                day: Some("0"),
+                ..Default::default()
+            }
+        ))
+    );
+
+    assert_eq!(
+        parsing::match_span("P3dT4h59m"),
+        Ok((
+            "",
+            parsing::Span {
+                day: Some("3"),
+                hour: Some("4"),
+                minute: Some("59"),
+                ..Default::default()
+            }
+        ))
+    );
+    assert_eq!(
+        parsing::match_span("PT2H30M"),
+        Ok((
+            "",
+            parsing::Span {
+                hour: Some("2"),
+                minute: Some("30"),
+                ..Default::default()
+            }
+        ))
+    );
+    assert_eq!(
+        parsing::match_span("PT1m"),
+        Ok((
+            "",
+            parsing::Span {
+                minute: Some("1"),
+                ..Default::default()
+            }
+        ))
+    );
+    assert_eq!(
+        parsing::match_span("PT0s"),
+        Ok((
+            "",
+            parsing::Span {
+                second: Some("0"),
+                ..Default::default()
+            }
+        ))
+    );
+    assert_eq!(
+        parsing::match_span("PT0.0021s"),
+        Ok((
+            "",
+            parsing::Span {
+                second: Some("0"),
+                subsecond: Some("0021"),
+                ..Default::default()
+            }
+        ))
+    );
+    assert_eq!(
+        parsing::match_span("P1y1m1dT1h1m1.1s"),
+        Ok((
+            "",
+            parsing::Span {
+                year: Some("1"),
+                month: Some("1"),
+                day: Some("1"),
+                hour: Some("1"),
+                minute: Some("1"),
+                second: Some("1"),
+                subsecond: Some("1"),
+                ..Default::default()
+            }
+        ))
+    );
+}
+
 #[test]
 fn match_optional_sign() {
     assert_eq!(parsing::match_optional_sign("foo"), Ok(("foo", None)));

From 0796cc73f4617899f183bf19538f3e55aa9dd7a0 Mon Sep 17 00:00:00 2001
From: Christopher Prohm <mail@cprohm.de>
Date: Thu, 3 Oct 2024 13:59:38 +0200
Subject: [PATCH 18/28] Initial impl of Span support

---
 serde_arrow/src/internal/chrono.rs            |  56 ++++++++--
 .../deserialization/array_deserializer.rs     |   7 +-
 .../deserialization/duration_deserializer.rs  | 104 ++++++++++++++++++
 .../src/internal/deserialization/mod.rs       |   1 +
 .../serialization/duration_builder.rs         |   9 ++
 serde_arrow/src/test_with_arrow/impls/jiff.rs |  66 +++++++++++
 6 files changed, 234 insertions(+), 9 deletions(-)
 create mode 100644 serde_arrow/src/internal/deserialization/duration_deserializer.rs

diff --git a/serde_arrow/src/internal/chrono.rs b/serde_arrow/src/internal/chrono.rs
index 921dbef4..72792340 100644
--- a/serde_arrow/src/internal/chrono.rs
+++ b/serde_arrow/src/internal/chrono.rs
@@ -1,11 +1,13 @@
 //! Support for Parsing datetime related quantities
 //!
-use crate::internal::error::Result;
+use crate::internal::{arrow::TimeUnit, error::Result};
 
 use parsing::ParseResult;
 
 pub use parsing::Span;
 
+use super::error::fail;
+
 /// Check whether `s` can be parsed as a naive datetime
 pub fn matches_naive_datetime(s: &str) -> bool {
     parsing::match_naive_datetime(s).matches()
@@ -26,17 +28,57 @@ pub fn matches_naive_time(s: &str) -> bool {
     parsing::match_naive_time(s).matches()
 }
 
-/// Check whether `s` can be parsed as a span
-pub fn matches_span(s: &str) -> bool {
-    parsing::match_span(s).matches()
-}
-
 /// Parse `s` as a span
 pub fn parse_span(s: &str) -> Result<Span<'_>> {
     parsing::match_span(s).into_result("Span")
 }
 
-/// minimalistic monadic parsers for datetime objects
+// TODO: handle signs
+impl<'a> parsing::Span<'a> {
+    pub fn to_arrow_duration(&self, unit: TimeUnit) -> Result<i64> {
+        if get_value(self.year)? != 0 || get_value(self.month)? != 0 {
+            fail!("Cannot convert interval style spans to a duration");
+        }
+
+        // TODO: perform check here?
+        let second_value = get_value(self.week)? * 7 * 24 * 60 * 60
+            + get_value(self.day)? * 24 * 60 * 60
+            + get_value(self.hour)? * 60 * 60
+            + get_value(self.minute)? * 60
+            + get_value(self.second)?;
+
+        // TODO: implement subsecond values
+
+        checked_unit_cast(second_value, unit)
+    }
+}
+
+fn get_value(s: Option<&str>) -> Result<i64> {
+    match s {
+        Some(s) => Ok(s.parse()?),
+        None => Ok(0),
+    }
+}
+
+fn checked_unit_cast(second_value: i64, unit: TimeUnit) -> Result<i64> {
+    match unit {
+        TimeUnit::Second => Ok(second_value),
+        TimeUnit::Microsecond => match second_value.checked_mul(1_000_i64) {
+            Some(res) => Ok(res),
+            None => fail!("Cannot represent {second_value} with Microsecond resolution"),
+        },
+        TimeUnit::Millisecond => match second_value.checked_mul(1_000_000_i64) {
+            Some(res) => Ok(res),
+            None => fail!("Cannot represent {second_value} with Millisecond resolution"),
+        },
+        TimeUnit::Nanosecond => match second_value.checked_mul(1_000_000_000_i64) {
+            Some(res) => Ok(res),
+            None => fail!("Cannot represent {second_value} with Nanosecond resolution"),
+        },
+    }
+}
+
+/// Minimalistic monadic parsers for datetime objects
 ///
 /// Each parser has the the following interface:
 ///
diff --git a/serde_arrow/src/internal/deserialization/array_deserializer.rs b/serde_arrow/src/internal/deserialization/array_deserializer.rs
index c423d105..4707c4fa 100644
--- a/serde_arrow/src/internal/deserialization/array_deserializer.rs
+++ b/serde_arrow/src/internal/deserialization/array_deserializer.rs
@@ -12,7 +12,7 @@ use super::{
     binary_deserializer::BinaryDeserializer, bool_deserializer::BoolDeserializer,
     date32_deserializer::Date32Deserializer, date64_deserializer::Date64Deserializer,
     decimal_deserializer::DecimalDeserializer, dictionary_deserializer::DictionaryDeserializer,
-    enum_deserializer::EnumDeserializer,
+    duration_deserializer::DurationDeserializer, enum_deserializer::EnumDeserializer,
     fixed_size_binary_deserializer::FixedSizeBinaryDeserializer,
     fixed_size_list_deserializer::FixedSizeListDeserializer, float_deserializer::FloatDeserializer,
     integer_deserializer::IntegerDeserializer, list_deserializer::ListDeserializer,
@@ -36,6 +36,7 @@ pub enum ArrayDeserializer<'a> {
     F32(FloatDeserializer<'a, f32>),
     F64(FloatDeserializer<'a, f64>),
     Decimal128(DecimalDeserializer<'a>),
+    Duration(DurationDeserializer<'a>),
     Date32(Date32Deserializer<'a>),
     Date64(Date64Deserializer<'a>),
     Time32(TimeDeserializer<'a, i32>),
@@ -122,8 +123,9 @@ impl<'a> ArrayDeserializer<'a> {
                     is_utc_timestamp(view.timezone.as_deref())?,
                 ))),
             },
-            V::Duration(view) => Ok(D::I64(IntegerDeserializer::new(
+            V::Duration(view) => Ok(D::Duration(DurationDeserializer::new(
                 path,
+                view.unit,
                 PrimitiveArrayView {
                     values: view.values,
                     validity: view.validity,
@@ -342,6 +344,7 @@ macro_rules! dispatch {
             $wrapper::F32($name) => $expr,
             $wrapper::F64($name) => $expr,
             $wrapper::Decimal128($name) => $expr,
+            $wrapper::Duration($name) => $expr,
             $wrapper::Date32($name) => $expr,
             $wrapper::Date64($name) => $expr,
             $wrapper::Time32($name) => $expr,
diff --git a/serde_arrow/src/internal/deserialization/duration_deserializer.rs b/serde_arrow/src/internal/deserialization/duration_deserializer.rs
new file mode 100644
index 00000000..440f9419
--- /dev/null
+++ b/serde_arrow/src/internal/deserialization/duration_deserializer.rs
@@ -0,0 +1,104 @@
+use serde::de::Visitor;
+
+use crate::internal::{
+    arrow::{PrimitiveArrayView, TimeUnit},
+    error::{set_default, try_, Context, ContextSupport, Result},
+    utils::Mut,
+};
+
+use super::{simple_deserializer::SimpleDeserializer, utils::ArrayBufferIterator};
+
+pub struct DurationDeserializer<'a> {
+    path: String,
+    unit: TimeUnit,
+    array: ArrayBufferIterator<'a, i64>,
+}
+
+impl<'a> DurationDeserializer<'a> {
+    pub fn new(path: String, unit: TimeUnit, view: PrimitiveArrayView<'a, i64>) -> Self {
+        Self {
+            path,
+            unit,
+            array: ArrayBufferIterator::new(view.values, view.validity),
+        }
+    }
+
+    pub fn next_string_value_required(&mut self) -> Result<String> {
+        let value = self.array.next_required()?;
+        Ok(self.format_string_value(value))
+    }
+
+    pub fn format_string_value(&self, value: i64) -> String {
+        match self.unit {
+            TimeUnit::Second => format!("PT{value}s"),
+            TimeUnit::Microsecond => format!(
+                "PT{second}.{subsecond:03}s",
+                second = value / 1_000,
+                subsecond = value % 1000
+            ),
+            TimeUnit::Millisecond => format!(
+                "PT{second}.{subsecond:06}s",
+                second = value / 1_000_000,
+                subsecond = value % 1_000_000
+            ),
+            TimeUnit::Nanosecond => format!(
+                "PT{second}.{subsecond:09}s",
+                second = value / 1_000_000_000,
+                subsecond = value % 1_000_000_000
+            ),
+        }
+    }
+}
+
+impl<'de> Context for DurationDeserializer<'de> {
+    fn annotate(&self, annotations: &mut std::collections::BTreeMap<String, String>) {
+        set_default(annotations, "field", &self.path);
+        set_default(annotations, "data_type", "Duration(..)");
+    }
+}
+
+impl<'de> SimpleDeserializer<'de> for DurationDeserializer<'de> {
+    fn deserialize_any<V: Visitor<'de>>(&mut self, visitor: V) -> Result<V::Value> {
+        try_(|| {
+            if self.array.peek_next()? {
+                self.deserialize_i64(visitor)
+            } else {
+                self.array.consume_next();
+                visitor.visit_none()
+            }
+        })
+        .ctx(self)
+    }
+
+    fn deserialize_option<V: Visitor<'de>>(&mut self, visitor: V) -> Result<V::Value> {
+        try_(|| {
+            if self.array.peek_next()? {
+                visitor.visit_some(Mut(&mut *self))
+            } else {
+                self.array.consume_next();
+                visitor.visit_none()
+            }
+        })
+        .ctx(self)
+    }
+
+    fn deserialize_i64<V: Visitor<'de>>(&mut self, visitor: V) -> Result<V::Value> {
+        try_(|| visitor.visit_i64(self.array.next_required()?)).ctx(self)
+    }
+
+    fn deserialize_str<V: Visitor<'de>>(&mut self, visitor: V) -> Result<V::Value> {
+        try_(|| visitor.visit_str(self.next_string_value_required()?.as_str())).ctx(self)
+    }
+
+    fn deserialize_string<V: Visitor<'de>>(&mut self, visitor: V) -> Result<V::Value> {
+        try_(|| visitor.visit_string(self.next_string_value_required()?)).ctx(self)
+    }
+
+    fn deserialize_bytes<V: Visitor<'de>>(&mut self, visitor: V) -> Result<V::Value> {
+        try_(|| visitor.visit_bytes(self.next_string_value_required()?.as_bytes())).ctx(self)
+    }
+
+    fn deserialize_byte_buf<V: Visitor<'de>>(&mut self, visitor: V) -> Result<V::Value> {
+        try_(|| visitor.visit_byte_buf(self.next_string_value_required()?.into_bytes())).ctx(self)
+    }
+}
diff --git a/serde_arrow/src/internal/deserialization/mod.rs b/serde_arrow/src/internal/deserialization/mod.rs
index 8da9f023..42a3a80f 100644
--- a/serde_arrow/src/internal/deserialization/mod.rs
+++ b/serde_arrow/src/internal/deserialization/mod.rs
@@ -5,6 +5,7 @@ pub mod date32_deserializer;
 pub mod date64_deserializer;
 pub mod decimal_deserializer;
 pub mod dictionary_deserializer;
+pub mod duration_deserializer;
 pub mod enum_deserializer;
 pub mod enums_as_string_impl;
 pub mod fixed_size_binary_deserializer;
diff --git a/serde_arrow/src/internal/serialization/duration_builder.rs b/serde_arrow/src/internal/serialization/duration_builder.rs
index 2c73e250..3762afc8 100644
--- a/serde_arrow/src/internal/serialization/duration_builder.rs
+++ b/serde_arrow/src/internal/serialization/duration_builder.rs
@@ -2,6 +2,7 @@ use std::collections::BTreeMap;
 
 use crate::internal::{
     arrow::{Array, PrimitiveArray, TimeArray, TimeUnit},
+    chrono,
     error::{set_default, try_, Context, ContextSupport, Result},
     utils::array_ext::{new_primitive_array, ArrayExt, ScalarArrayExt},
 };
@@ -92,4 +93,12 @@ impl SimpleSerializer for DurationBuilder {
     fn serialize_u64(&mut self, v: u64) -> Result<()> {
         try_(|| self.array.push_scalar_value(i64::try_from(v)?)).ctx(self)
     }
+
+    fn serialize_str(&mut self, v: &str) -> Result<()> {
+        try_(|| {
+            let value = chrono::parse_span(v)?.to_arrow_duration(self.unit)?;
+            self.array.push_scalar_value(value)
+        })
+        .ctx(self)
+    }
 }
diff --git a/serde_arrow/src/test_with_arrow/impls/jiff.rs b/serde_arrow/src/test_with_arrow/impls/jiff.rs
index 97330959..b91147bf 100644
--- a/serde_arrow/src/test_with_arrow/impls/jiff.rs
+++ b/serde_arrow/src/test_with_arrow/impls/jiff.rs
@@ -447,3 +447,69 @@ mod timestamp {
             .deserialize(&items);
     }
 }
+
+mod span {
+    use serde::{Deserialize, Serialize};
+    use super::*;
+
+    // wrapper around spans that uses compare for PartialEq
+    #[derive(Debug, Serialize, Deserialize)]
+    struct EquivalentSpan(Span);
+
+    impl From<Span> for EquivalentSpan {
+        fn from(value: Span) -> Self {
+            Self(value)
+        }
+    }
+
+    impl std::cmp::PartialEq for EquivalentSpan {
+        fn eq(&self, other: &Self) -> bool {
+            match self.0.compare(&other.0) {
+                Ok(ordering) => ordering == std::cmp::Ordering::Equal,
+                Err(_) => false,
+            }
+        }
+    }
+
+    fn items() -> Vec<Item<EquivalentSpan>> {
+        // use std::ops::Neg;
+
+        // Note: weeks are always considered non-uniform
+        vec![
+            Item(Span::new().hours(5).seconds(20).into()),
+            Item(Span::new().minutes(20).seconds(32).into()),
+            Item(Span::new().days(5).hours(12).into()),
+            // TODO: negative spans are not yet supported
+            // Item(Span::new().days(1).hours(2).minutes(3).seconds(4).neg().into()),
+            // TODO: examples with subsecond resolution
+        ]
+    }
+
+    #[test]
+    fn as_large_utf8() {
+        let items = items();
+        Test::new()
+            .with_schema(json!([{"name": "item", "data_type": "LargeUtf8"}]))
+            .trace_schema_from_samples(&items, TracingOptions::default())
+            .serialize(&items)
+            .deserialize(&items);
+    }
+
+    #[test]
+    fn as_utf8() {
+        let items = items();
+        Test::new()
+            .with_schema(json!([{"name": "item", "data_type": "Utf8"}]))
+            .serialize(&items)
+            .deserialize(&items);
+    }
+
+    #[test]
+    fn as_duration_second() {
+        let items = items();
+        Test::new()
+            .with_schema(json!([{"name": "item", "data_type": "Duration(Second)"}]))
+            .serialize(&items)
+            .deserialize(&items);
+    }
+}

From 8ea39274a8255f1215a955c6c454a197d4c951a9 Mon Sep 17 00:00:00 2001
From: Christopher Prohm <mail@cprohm.de>
Date: Thu, 3 Oct 2024 14:08:59 +0200
Subject: [PATCH 19/28] Implement negative duration support

---
 serde_arrow/src/internal/chrono.rs            | 63 ++++++++++++++++++-
 .../deserialization/duration_deserializer.rs  | 24 +------
 serde_arrow/src/test_with_arrow/impls/jiff.rs | 15 +++--
 3 files changed, 75 insertions(+), 27 deletions(-)

diff --git a/serde_arrow/src/internal/chrono.rs b/serde_arrow/src/internal/chrono.rs
index 72792340..92a02017 100644
--- a/serde_arrow/src/internal/chrono.rs
+++ b/serde_arrow/src/internal/chrono.rs
@@ -48,8 +48,41 @@ impl<'a> parsing::Span<'a> {
             + get_value(self.second)?;
 
         // TODO: implement subsecond values
+        let unsigned_result = checked_unit_cast(second_value, unit)?;
 
-        checked_unit_cast(second_value, unit)
+        if self.sign == Some('-') {
+            Ok(-unsigned_result)
+        } else {
+            Ok(unsigned_result)
+        }
+    }
+}
+
+/// Format a duration in the given unit as a Span string
+pub fn format_arrow_duration_as_span(value: i64, unit: TimeUnit) -> String {
+    let (value, sign) = if value < 0 {
+        (-value, "-")
+    } else {
+        (value, "")
+    };
+
+    match unit {
+        TimeUnit::Second => format!("{sign}PT{value}s"),
+        TimeUnit::Microsecond => format!(
+            "{sign}PT{second}.{subsecond:03}s",
+            second = value / 1_000,
+            subsecond = value % 1000
+        ),
+        TimeUnit::Millisecond => format!(
+            "{sign}PT{second}.{subsecond:06}s",
+            second = value / 1_000_000,
+            subsecond = value % 1_000_000
+        ),
+        TimeUnit::Nanosecond => format!(
+            "{sign}PT{second}.{subsecond:09}s",
+            second = value / 1_000_000_000,
+            subsecond = value % 1_000_000_000
+        ),
     }
 }
 
@@ -145,6 +178,7 @@ mod parsing {
 
     #[derive(Debug, Default, Clone, PartialEq, Eq)]
     pub struct Span<'a> {
+        pub sign: Option<char>,
         pub year: Option<&'a str>,
         pub month: Option<&'a str>,
         pub day: Option<&'a str>,
@@ -216,6 +250,7 @@ mod parsing {
     }
 
     pub fn match_span(s: &str) -> Result<(&str, Span<'_>), &str> {
+        let (s, sign) = match_optional_sign(s)?;
         let (s, _) = match_char_case_insensitive(s, 'P')?;
         let (s, year) = match_optional_span_value(s, 'Y')?;
         let (s, month) = match_optional_span_value(s, 'M')?;
@@ -234,6 +269,7 @@ mod parsing {
         Ok((
             s,
             Span {
+                sign,
                 year,
                 month,
                 week,
@@ -717,6 +753,31 @@ fn match_span() {
             }
         ))
     );
+    assert_eq!(
+        parsing::match_span("+P3dT4h59m"),
+        Ok((
+            "",
+            parsing::Span {
+                sign: Some('+'),
+                day: Some("3"),
+                hour: Some("4"),
+                minute: Some("59"),
+                ..Default::default()
+            }
+        ))
+    );
+    assert_eq!(
+        parsing::match_span("-P1w4d"),
+        Ok((
+            "",
+            parsing::Span {
+                sign: Some('-'),
+                week: Some("1"),
+                day: Some("4"),
+                ..Default::default()
+            }
+        ))
+    );
 }
 
 #[test]
diff --git a/serde_arrow/src/internal/deserialization/duration_deserializer.rs b/serde_arrow/src/internal/deserialization/duration_deserializer.rs
index 440f9419..bd91c2bb 100644
--- a/serde_arrow/src/internal/deserialization/duration_deserializer.rs
+++ b/serde_arrow/src/internal/deserialization/duration_deserializer.rs
@@ -2,6 +2,7 @@ use serde::de::Visitor;
 
 use crate::internal::{
     arrow::{PrimitiveArrayView, TimeUnit},
+    chrono,
     error::{set_default, try_, Context, ContextSupport, Result},
     utils::Mut,
 };
@@ -25,28 +26,7 @@ impl<'a> DurationDeserializer<'a> {
 
     pub fn next_string_value_required(&mut self) -> Result<String> {
         let value = self.array.next_required()?;
-        Ok(self.format_string_value(value))
-    }
-
-    pub fn format_string_value(&self, value: i64) -> String {
-        match self.unit {
-            TimeUnit::Second => format!("PT{value}s"),
-            TimeUnit::Microsecond => format!(
-                "PT{second}.{subsecond:03}s",
-                second = value / 1_000,
-                subsecond = value % 1000
-            ),
-            TimeUnit::Millisecond => format!(
-                "PT{second}.{subsecond:06}s",
-                second = value / 1_000_000,
-                subsecond = value % 1_000_000
-            ),
-            TimeUnit::Nanosecond => format!(
-                "PT{second}.{subsecond:09}s",
-                second = value / 1_000_000_000,
-                subsecond = value % 1_000_000_000
-            ),
-        }
+        Ok(chrono::format_arrow_duration_as_span(value, self.unit))
     }
 }
 
diff --git a/serde_arrow/src/test_with_arrow/impls/jiff.rs b/serde_arrow/src/test_with_arrow/impls/jiff.rs
index b91147bf..9474d32a 100644
--- a/serde_arrow/src/test_with_arrow/impls/jiff.rs
+++ b/serde_arrow/src/test_with_arrow/impls/jiff.rs
@@ -449,8 +449,8 @@ mod timestamp {
 }
 
 mod span {
-    use serde::{Deserialize, Serialize};
     use super::*;
+    use serde::{Deserialize, Serialize};
 
     // wrapper around spans that uses compare for PartialEq
     #[derive(Debug, Serialize, Deserialize)]
@@ -472,15 +472,22 @@ mod span {
     }
 
     fn items() -> Vec<Item<EquivalentSpan>> {
-        // use std::ops::Neg;
+        use std::ops::Neg;
 
         // Note: weeks are always considered non-uniform
         vec![
             Item(Span::new().hours(5).seconds(20).into()),
             Item(Span::new().minutes(20).seconds(32).into()),
             Item(Span::new().days(5).hours(12).into()),
-            // TODO: negative spans are not yet supported
-            // Item(Span::new().days(1).hours(2).minutes(3).seconds(4).neg().into()),
+            Item(
+                Span::new()
+                    .days(1)
+                    .hours(2)
+                    .minutes(3)
+                    .seconds(4)
+                    .neg()
+                    .into(),
+            ),
             // TODO: examples with subsecond resolution
         ]
     }

From 24dba7808c0084fa84c33e31f651080f542a9805 Mon Sep 17 00:00:00 2001
From: Christopher Prohm <mail@cprohm.de>
Date: Thu, 3 Oct 2024 15:07:35 +0200
Subject: [PATCH 20/28] Implement subsecond support

---
 serde_arrow/src/internal/chrono.rs            | 242 +++++++++++++++---
 serde_arrow/src/test_with_arrow/impls/jiff.rs |  89 +++++--
 .../src/test_with_arrow/impls/utils.rs        |   4 +-
 3 files changed, 277 insertions(+), 58 deletions(-)

diff --git a/serde_arrow/src/internal/chrono.rs b/serde_arrow/src/internal/chrono.rs
index 92a02017..d03952cf 100644
--- a/serde_arrow/src/internal/chrono.rs
+++ b/serde_arrow/src/internal/chrono.rs
@@ -36,24 +36,58 @@ pub fn parse_span(s: &str) -> Result<Span<'_>> {
 // TODO: handle signs
 impl<'a> parsing::Span<'a> {
     pub fn to_arrow_duration(&self, unit: TimeUnit) -> Result<i64> {
-        if get_value(self.year)? != 0 || get_value(self.month)? != 0 {
+        if get_optional_digit_value(self.year)? != 0 || get_optional_digit_value(self.month)? != 0 {
             fail!("Cannot convert interval style spans to a duration");
         }
 
-        // TODO: perform check here?
-        let second_value = get_value(self.week)? * 7 * 24 * 60 * 60
-            + get_value(self.day)? * 24 * 60 * 60
-            + get_value(self.hour)? * 60 * 60
-            + get_value(self.minute)? * 60
-            + get_value(self.second)?;
+        let second_value = self.get_second_value()?;
+        let nanosecond_value = self.get_nanosecond_value()?;
+        Self::build_duration(self.sign, second_value, nanosecond_value, unit)
+    }
 
-        // TODO: implement subsecond values
-        let unsigned_result = checked_unit_cast(second_value, unit)?;
+    fn get_second_value(&self) -> Result<i64> {
+        Ok(get_optional_digit_value(self.week)? * 7 * 24 * 60 * 60
+            + get_optional_digit_value(self.day)? * 24 * 60 * 60
+            + get_optional_digit_value(self.hour)? * 60 * 60
+            + get_optional_digit_value(self.minute)? * 60
+            + get_optional_digit_value(self.second)?)
+    }
 
-        if self.sign == Some('-') {
-            Ok(-unsigned_result)
+    fn get_nanosecond_value(&self) -> Result<i64> {
+        let Some(subsecond) = self.subsecond else {
+            return Ok(0);
+        };
+        let subsecond_val: i64 = subsecond.parse()?;
+        // TODO: handle subsecond.len() > 9 gracefully
+        Ok(subsecond_val * 10_i64.pow(9 - u32::try_from(subsecond.len())?))
+    }
+
+    fn build_duration(
+        sign: Option<char>,
+        second_value: i64,
+        nanosecond_value: i64,
+        unit: TimeUnit,
+    ) -> Result<i64> {
+        let unsigned_duration = match unit {
+            TimeUnit::Second => second_value,
+            TimeUnit::Millisecond => match second_value.checked_mul(1_000_i64) {
+                Some(res) => res + nanosecond_value / 1_000_000,
+                None => fail!("Cannot represent {second_value} with Microsecond resolution"),
+            },
+            TimeUnit::Microsecond => match second_value.checked_mul(1_000_000_i64) {
+                Some(res) => res + nanosecond_value / 1_000,
+                None => fail!("Cannot represent {second_value} with Millisecond resolution"),
+            },
+            TimeUnit::Nanosecond => match second_value.checked_mul(1_000_000_000_i64) {
+                Some(res) => res + nanosecond_value,
+                None => fail!("Cannot represent {second_value} with Nanosecond resolution"),
+            },
+        };
+
+        if sign == Some('-') {
+            Ok(-unsigned_duration)
         } else {
-            Ok(unsigned_result)
+            Ok(unsigned_duration)
         }
     }
 }
@@ -68,12 +102,12 @@ pub fn format_arrow_duration_as_span(value: i64, unit: TimeUnit) -> String {
 
     match unit {
         TimeUnit::Second => format!("{sign}PT{value}s"),
-        TimeUnit::Microsecond => format!(
+        TimeUnit::Millisecond => format!(
             "{sign}PT{second}.{subsecond:03}s",
             second = value / 1_000,
-            subsecond = value % 1000
+            subsecond = value % 1_000
         ),
-        TimeUnit::Millisecond => format!(
+        TimeUnit::Microsecond => format!(
             "{sign}PT{second}.{subsecond:06}s",
             second = value / 1_000_000,
             subsecond = value % 1_000_000
@@ -86,31 +120,13 @@ pub fn format_arrow_duration_as_span(value: i64, unit: TimeUnit) -> String {
     }
 }
 
-fn get_value(s: Option<&str>) -> Result<i64> {
+fn get_optional_digit_value(s: Option<&str>) -> Result<i64> {
     match s {
         Some(s) => Ok(s.parse()?),
         None => Ok(0),
     }
 }
 
-fn checked_unit_cast(second_value: i64, unit: TimeUnit) -> Result<i64> {
-    match unit {
-        TimeUnit::Second => Ok(second_value),
-        TimeUnit::Microsecond => match second_value.checked_mul(1_000_i64) {
-            Some(res) => Ok(res),
-            None => fail!("Cannot represent {second_value} with Microsecond resolution"),
-        },
-        TimeUnit::Millisecond => match second_value.checked_mul(1_000_000_i64) {
-            Some(res) => Ok(res),
-            None => fail!("Cannot represent {second_value} with Millisecond resolution"),
-        },
-        TimeUnit::Nanosecond => match second_value.checked_mul(1_000_000_000_i64) {
-            Some(res) => Ok(res),
-            None => fail!("Cannot represent {second_value} with Nanosecond resolution"),
-        },
-    }
-}
-
 /// Minimalistic monadic parsers for datetime objects
 ///
 /// Each parser has the the following interface:
@@ -778,6 +794,17 @@ fn match_span() {
             }
         ))
     );
+    assert_eq!(
+        parsing::match_span("PT0.020s"),
+        Ok((
+            "",
+            parsing::Span {
+                second: Some("0"),
+                subsecond: Some("020"),
+                ..Default::default()
+            }
+        ))
+    )
 }
 
 #[test]
@@ -822,3 +849,150 @@ fn match_one_or_two_digits() {
         Ok(("34foo", "12"))
     );
 }
+
+#[test]
+fn test_parse_and_format_duration() {
+    fn parse_as_duration(s: &str, unit: TimeUnit) -> i64 {
+        parse_span(s).unwrap().to_arrow_duration(unit).unwrap()
+    }
+
+    assert_eq!(format_arrow_duration_as_span(20, TimeUnit::Second), "PT20s");
+    assert_eq!(
+        format_arrow_duration_as_span(20, TimeUnit::Millisecond),
+        "PT0.020s"
+    );
+    assert_eq!(
+        format_arrow_duration_as_span(20, TimeUnit::Microsecond),
+        "PT0.000020s"
+    );
+    assert_eq!(
+        format_arrow_duration_as_span(20, TimeUnit::Nanosecond),
+        "PT0.000000020s"
+    );
+
+    assert_eq!(parse_as_duration("PT20s", TimeUnit::Second), 20);
+    assert_eq!(parse_as_duration("PT0.020s", TimeUnit::Millisecond), 20);
+    assert_eq!(parse_as_duration("PT0.000020s", TimeUnit::Microsecond), 20);
+    assert_eq!(
+        parse_as_duration("PT0.000000020s", TimeUnit::Nanosecond),
+        20
+    );
+
+    assert_eq!(
+        format_arrow_duration_as_span(-13, TimeUnit::Second),
+        "-PT13s"
+    );
+    assert_eq!(
+        format_arrow_duration_as_span(-13, TimeUnit::Millisecond),
+        "-PT0.013s"
+    );
+    assert_eq!(
+        format_arrow_duration_as_span(-13, TimeUnit::Microsecond),
+        "-PT0.000013s"
+    );
+    assert_eq!(
+        format_arrow_duration_as_span(-13, TimeUnit::Nanosecond),
+        "-PT0.000000013s"
+    );
+
+    assert_eq!(parse_as_duration("-PT13s", TimeUnit::Second), -13);
+    assert_eq!(parse_as_duration("-PT0.013s", TimeUnit::Millisecond), -13);
+    assert_eq!(
+        parse_as_duration("-PT0.000013s", TimeUnit::Microsecond),
+        -13
+    );
+    assert_eq!(
+        parse_as_duration("-PT0.000000013s", TimeUnit::Nanosecond),
+        -13
+    );
+
+    assert_eq!(
+        format_arrow_duration_as_span(1234, TimeUnit::Second),
+        "PT1234s"
+    );
+    assert_eq!(
+        format_arrow_duration_as_span(1234, TimeUnit::Millisecond),
+        "PT1.234s"
+    );
+    assert_eq!(
+        format_arrow_duration_as_span(1234, TimeUnit::Microsecond),
+        "PT0.001234s"
+    );
+    assert_eq!(
+        format_arrow_duration_as_span(1234, TimeUnit::Nanosecond),
+        "PT0.000001234s"
+    );
+
+    assert_eq!(parse_as_duration("PT1234s", TimeUnit::Second), 1234);
+    assert_eq!(parse_as_duration("PT1.234s", TimeUnit::Millisecond), 1234);
+    assert_eq!(
+        parse_as_duration("PT0.001234s", TimeUnit::Microsecond),
+        1234
+    );
+    assert_eq!(
+        parse_as_duration("PT0.000001234s", TimeUnit::Nanosecond),
+        1234
+    );
+
+    assert_eq!(
+        format_arrow_duration_as_span(-2010, TimeUnit::Second),
+        "-PT2010s"
+    );
+    assert_eq!(
+        format_arrow_duration_as_span(-2010, TimeUnit::Millisecond),
+        "-PT2.010s"
+    );
+    assert_eq!(
+        format_arrow_duration_as_span(-2010, TimeUnit::Microsecond),
+        "-PT0.002010s"
+    );
+    assert_eq!(
+        format_arrow_duration_as_span(-2010, TimeUnit::Nanosecond),
+        "-PT0.000002010s"
+    );
+
+    assert_eq!(parse_as_duration("-PT2010s", TimeUnit::Second), -2010);
+    assert_eq!(parse_as_duration("-PT2.010s", TimeUnit::Millisecond), -2010);
+    assert_eq!(
+        parse_as_duration("-PT0.002010s", TimeUnit::Microsecond),
+        -2010
+    );
+    assert_eq!(
+        parse_as_duration("-PT0.000002010s", TimeUnit::Nanosecond),
+        -2010
+    );
+
+    assert_eq!(
+        format_arrow_duration_as_span(123456789, TimeUnit::Second),
+        "PT123456789s"
+    );
+    assert_eq!(
+        format_arrow_duration_as_span(123456789, TimeUnit::Millisecond),
+        "PT123456.789s"
+    );
+    assert_eq!(
+        format_arrow_duration_as_span(123456789, TimeUnit::Microsecond),
+        "PT123.456789s"
+    );
+    assert_eq!(
+        format_arrow_duration_as_span(123456789, TimeUnit::Nanosecond),
+        "PT0.123456789s"
+    );
+
+    assert_eq!(
+        parse_as_duration("PT123456789s", TimeUnit::Second),
+        123456789
+    );
+    assert_eq!(
+        parse_as_duration("PT123456.789s", TimeUnit::Millisecond),
+        123456789
+    );
+    assert_eq!(
+        parse_as_duration("PT123.456789s", TimeUnit::Microsecond),
+        123456789
+    );
+    assert_eq!(
+        parse_as_duration("PT0.123456789s", TimeUnit::Nanosecond),
+        123456789
+    );
+}
diff --git a/serde_arrow/src/test_with_arrow/impls/jiff.rs b/serde_arrow/src/test_with_arrow/impls/jiff.rs
index 9474d32a..526a0298 100644
--- a/serde_arrow/src/test_with_arrow/impls/jiff.rs
+++ b/serde_arrow/src/test_with_arrow/impls/jiff.rs
@@ -450,15 +450,27 @@ mod timestamp {
 
 mod span {
     use super::*;
+    use crate::internal::arrow::TimeUnit;
+    use jiff::{RoundMode, SpanRound, Unit};
     use serde::{Deserialize, Serialize};
 
     // wrapper around spans that uses compare for PartialEq
     #[derive(Debug, Serialize, Deserialize)]
     struct EquivalentSpan(Span);
 
-    impl From<Span> for EquivalentSpan {
-        fn from(value: Span) -> Self {
-            Self(value)
+    impl EquivalentSpan {
+        pub fn round(self, unit: TimeUnit) -> Self {
+            let unit = match unit {
+                TimeUnit::Second => Unit::Second,
+                TimeUnit::Millisecond => Unit::Millisecond,
+                TimeUnit::Microsecond => Unit::Microsecond,
+                TimeUnit::Nanosecond => Unit::Nanosecond,
+            };
+            Self(
+                self.0
+                    .round(SpanRound::new().smallest(unit).mode(RoundMode::Trunc))
+                    .unwrap(),
+            )
         }
     }
 
@@ -471,30 +483,36 @@ mod span {
         }
     }
 
-    fn items() -> Vec<Item<EquivalentSpan>> {
+    fn items(unit: TimeUnit) -> Vec<Item<EquivalentSpan>> {
         use std::ops::Neg;
 
         // Note: weeks are always considered non-uniform
-        vec![
-            Item(Span::new().hours(5).seconds(20).into()),
-            Item(Span::new().minutes(20).seconds(32).into()),
-            Item(Span::new().days(5).hours(12).into()),
-            Item(
-                Span::new()
-                    .days(1)
-                    .hours(2)
-                    .minutes(3)
-                    .seconds(4)
-                    .neg()
-                    .into(),
-            ),
-            // TODO: examples with subsecond resolution
-        ]
+        let items = vec![
+            Span::new().hours(5).seconds(20),
+            Span::new().minutes(20).seconds(32),
+            Span::new().days(5).hours(12),
+            Span::new().days(1).hours(2).minutes(3).seconds(4).neg(),
+            Span::new()
+                .hours(5)
+                .milliseconds(10)
+                .microseconds(20)
+                .nanoseconds(30),
+            Span::new()
+                .hours(5)
+                .milliseconds(10)
+                .microseconds(20)
+                .nanoseconds(30)
+                .neg(),
+        ];
+        items
+            .into_iter()
+            .map(|span| Item(EquivalentSpan(span).round(unit)))
+            .collect()
     }
 
     #[test]
     fn as_large_utf8() {
-        let items = items();
+        let items = items(TimeUnit::Nanosecond);
         Test::new()
             .with_schema(json!([{"name": "item", "data_type": "LargeUtf8"}]))
             .trace_schema_from_samples(&items, TracingOptions::default())
@@ -504,7 +522,7 @@ mod span {
 
     #[test]
     fn as_utf8() {
-        let items = items();
+        let items = items(TimeUnit::Nanosecond);
         Test::new()
             .with_schema(json!([{"name": "item", "data_type": "Utf8"}]))
             .serialize(&items)
@@ -513,10 +531,37 @@ mod span {
 
     #[test]
     fn as_duration_second() {
-        let items = items();
+        let items = items(TimeUnit::Second);
         Test::new()
             .with_schema(json!([{"name": "item", "data_type": "Duration(Second)"}]))
             .serialize(&items)
             .deserialize(&items);
     }
+
+    #[test]
+    fn as_duration_microsecond() {
+        let items = items(TimeUnit::Microsecond);
+        Test::new()
+            .with_schema(json!([{"name": "item", "data_type": "Duration(Microsecond)"}]))
+            .serialize(&items)
+            .deserialize(&items);
+    }
+
+    #[test]
+    fn as_duration_millisecond() {
+        let items = items(TimeUnit::Millisecond);
+        Test::new()
+            .with_schema(json!([{"name": "item", "data_type": "Duration(Millisecond)"}]))
+            .serialize(&items)
+            .deserialize(&items);
+    }
+
+    #[test]
+    fn as_duration_nanosecond() {
+        let items = items(TimeUnit::Nanosecond);
+        Test::new()
+            .with_schema(json!([{"name": "item", "data_type": "Duration(Nanosecond)"}]))
+            .serialize(&items)
+            .deserialize(&items);
+    }
 }
diff --git a/serde_arrow/src/test_with_arrow/impls/utils.rs b/serde_arrow/src/test_with_arrow/impls/utils.rs
index e2aaecbe..e8f7a348 100644
--- a/serde_arrow/src/test_with_arrow/impls/utils.rs
+++ b/serde_arrow/src/test_with_arrow/impls/utils.rs
@@ -221,7 +221,7 @@ impl Test {
                     .expect("Deserialization requires known arrow arrays"),
             )
             .expect("Failed arrow deserialization");
-            assert_eq!(roundtripped, items);
+            assert_eq!(roundtripped, items, "left: roundtripped, right: items");
         }
 
         if self.impls.arrow2 {
@@ -234,7 +234,7 @@ impl Test {
                     .expect("Deserialization requires known arrow2 arrays"),
             )
             .expect("Failed arrow2 deserialization");
-            assert_eq!(roundtripped, items);
+            assert_eq!(roundtripped, items, "left: roundtripped, right: items");
         }
     }
 

From e2dbaf5902102d6acbb2461c6e47ee0153085c9c Mon Sep 17 00:00:00 2001
From: Christopher Prohm <mail@cprohm.de>
Date: Thu, 3 Oct 2024 15:10:07 +0200
Subject: [PATCH 21/28] Increase robustness

---
 serde_arrow/src/internal/chrono.rs | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/serde_arrow/src/internal/chrono.rs b/serde_arrow/src/internal/chrono.rs
index d03952cf..1f038911 100644
--- a/serde_arrow/src/internal/chrono.rs
+++ b/serde_arrow/src/internal/chrono.rs
@@ -58,8 +58,13 @@ impl<'a> parsing::Span<'a> {
             return Ok(0);
         };
         let subsecond_val: i64 = subsecond.parse()?;
-        // TODO: handle subsecond.len() > 9 gracefully
-        Ok(subsecond_val * 10_i64.pow(9 - u32::try_from(subsecond.len())?))
+        let subsecond_len = u32::try_from(subsecond.len())?;
+
+        if subsecond_len <= 9 {
+            Ok(subsecond_val * 10_i64.pow(9 - subsecond_len))
+        } else {
+            Ok(subsecond_val / 10_i64.pow(subsecond_len - 9))
+        }
     }
 
     fn build_duration(

From d2b849a7e9e37bddb1f4b1c771f6311c6eed52ce Mon Sep 17 00:00:00 2001
From: Christopher Prohm <mail@cprohm.de>
Date: Thu, 3 Oct 2024 15:15:04 +0200
Subject: [PATCH 22/28] Add SignedDuration support

---
 serde_arrow/src/test_with_arrow/impls/jiff.rs | 72 ++++++++++++++++++-
 1 file changed, 70 insertions(+), 2 deletions(-)

diff --git a/serde_arrow/src/test_with_arrow/impls/jiff.rs b/serde_arrow/src/test_with_arrow/impls/jiff.rs
index 526a0298..21a4f9fa 100644
--- a/serde_arrow/src/test_with_arrow/impls/jiff.rs
+++ b/serde_arrow/src/test_with_arrow/impls/jiff.rs
@@ -456,7 +456,7 @@ mod span {
 
     // wrapper around spans that uses compare for PartialEq
     #[derive(Debug, Serialize, Deserialize)]
-    struct EquivalentSpan(Span);
+    pub struct EquivalentSpan(pub Span);
 
     impl EquivalentSpan {
         pub fn round(self, unit: TimeUnit) -> Self {
@@ -483,7 +483,7 @@ mod span {
         }
     }
 
-    fn items(unit: TimeUnit) -> Vec<Item<EquivalentSpan>> {
+    pub fn items(unit: TimeUnit) -> Vec<Item<EquivalentSpan>> {
         use std::ops::Neg;
 
         // Note: weeks are always considered non-uniform
@@ -565,3 +565,71 @@ mod span {
             .deserialize(&items);
     }
 }
+
+mod signed_duration {
+    use super::*;
+    use crate::internal::arrow::TimeUnit;
+    use jiff::SignedDuration;
+
+    fn items(unit: TimeUnit) -> Vec<Item<SignedDuration>> {
+        super::span::items(unit)
+            .into_iter()
+            .map(|span| Item(SignedDuration::try_from(span.0 .0).unwrap()))
+            .collect()
+    }
+
+    #[test]
+    fn as_large_utf8() {
+        let items = items(TimeUnit::Nanosecond);
+        Test::new()
+            .with_schema(json!([{"name": "item", "data_type": "LargeUtf8"}]))
+            .trace_schema_from_samples(&items, TracingOptions::default())
+            .serialize(&items)
+            .deserialize(&items);
+    }
+
+    #[test]
+    fn as_utf8() {
+        let items = items(TimeUnit::Nanosecond);
+        Test::new()
+            .with_schema(json!([{"name": "item", "data_type": "Utf8"}]))
+            .serialize(&items)
+            .deserialize(&items);
+    }
+
+    #[test]
+    fn as_duration_second() {
+        let items = items(TimeUnit::Second);
+        Test::new()
+            .with_schema(json!([{"name": "item", "data_type": "Duration(Second)"}]))
+            .serialize(&items)
+            .deserialize(&items);
+    }
+
+    #[test]
+    fn as_duration_microsecond() {
+        let items = items(TimeUnit::Microsecond);
+        Test::new()
+            .with_schema(json!([{"name": "item", "data_type": "Duration(Microsecond)"}]))
+            .serialize(&items)
+            .deserialize(&items);
+    }
+
+    #[test]
+    fn as_duration_millisecond() {
+        let items = items(TimeUnit::Millisecond);
+        Test::new()
+            .with_schema(json!([{"name": "item", "data_type": "Duration(Millisecond)"}]))
+            .serialize(&items)
+            .deserialize(&items);
+    }
+
+    #[test]
+    fn as_duration_nanosecond() {
+        let items = items(TimeUnit::Nanosecond);
+        Test::new()
+            .with_schema(json!([{"name": "item", "data_type": "Duration(Nanosecond)"}]))
+            .serialize(&items)
+            .deserialize(&items);
+    }
+}

From b3018956d41dd25bff0b028f1216417b159d7cd3 Mon Sep 17 00:00:00 2001
From: Christopher Prohm <mail@cprohm.de>
Date: Fri, 4 Oct 2024 20:20:42 +0200
Subject: [PATCH 23/28] Update the changelog and the overview

---
 Changes.md            |  2 ++
 serde_arrow/Status.md | 37 ++++++++++++++++++++++++++++++++++---
 2 files changed, 36 insertions(+), 3 deletions(-)

diff --git a/Changes.md b/Changes.md
index dab8148c..24659aaf 100644
--- a/Changes.md
+++ b/Changes.md
@@ -8,6 +8,8 @@ New features
   to `Time64(Nanosecond))`) in `from_samples`
 - Improved error messages for non self describing types (`chrono::*`, `uuid::Uuid`,
   `std::net::IpAddr`)
+- Add support for various `jiff` types (`jiff::Date`, `jiff::Time`, `jiff::DateTime`,
+  `jiff::Timestamp`, `jiff::Span`, `jiff::SignedDuration`)
 
 ## 0.12.0
 
diff --git a/serde_arrow/Status.md b/serde_arrow/Status.md
index 86b86464..63327342 100644
--- a/serde_arrow/Status.md
+++ b/serde_arrow/Status.md
@@ -95,21 +95,52 @@ Non-standard Rust types
   - serialized / deserialized as strings
   - can be mapped to `Utf8`, `LargeUtf8`, `Time32(..)` and `Time64` arrays
   - `from_samples` detects the type `LargeUtf8` without configuration, the type `Time64(Nanosecond)`
-    when setting `guess_dates = true` 
+    when setting `guess_dates = true`
   - `from_type` is not supported, as the type is not self-describing
-- [x] `chrono::NaiveDate`: 
+- [x] `chrono::NaiveDate`:
   - is serialized as Serde strings
   - can be mapped to `Utf8`, `LargeUtf8`, `Date32` arrays
   - `from_samples` detects the type `LargeUtf8` without configuration, to `Date32` when setting
     `guess_dates = true`
   - `from_type` is not supported, as the type is not self-describing
 - [ ] `chrono::Duration`: does not support Serde and is therefore not supported
+- [x] `jiff::Date`
+  - is serialized as Serde strings
+  - can me mapped to `Utf8`, `LargeUtf8`, `Date32`
+  - `from_samples` detects the type `LargeUtf8` without configuration, the type `Date32` when
+    setting `guess_dates = true`
+  - `from_type` is not supported, as the type is not self-describing
+- [x] `jiff::Time`
+  - is serialized as Serde strings
+  - can me mapped to `Utf8`, `LargeUtf8`, `Time32(..)`, `Time64(..)`
+  - `from_samples` detects the type `LargeUtf8` without configuration, the type `Time64(Nanosecond)`
+    when setitng `guess_dates = true`
+  - `from_type` is not supported, as the type is not self-describing
+- [x] `jiff::DateTime`
+  - is serialized as Serde strings
+  - can me mapped to `Utf8`, `LargeUtf8`, `Timestmap(.., None)`, `Date64` with strategy
+    `NaiveStrAsDate64`
+  - `from_samples` detects the type `LargeUtf8` without configuration, the type `Date64` with
+    strategy `NaiveStrAsDate64` when setting `guess_dates = true`
+  - `from_type` is not supported, as the type is not self-describing
+- [x] `jiff::Timestamp`
+  - is serialized as Serde strings
+  - can me mapped to `Utf8`, `LargeUtf8`, `Timestamp(.., Some("UTC"))`, `Date64` with strategy
+    `UtcStrAsDate64`
+  - `from_samples` detects the type `LargeUtf8` without configuration, the type `Date64` with
+    strategy `UtcStrDate64` when setting  `guess_dates = true`
+  - `from_type` is not supported, as the type is not self-describing
+- [x] `jiff::Span`, `jiff::SignedDuration`
+  - is serialized as Serde strings
+  - can me mapped to `Utf8`, `LargeUtf8`, `Duration(..)`
+  - `from_samples` detects the type `LargeUtf8`
+  - `from_type` is not supported, as the type is not self-describing
+- [ ] `jiff::Zoned` is not supported as there is no clear way of implementation
 - [x] [`rust_decimal::Decimal`][rust_decimal::Decimal] for the `float` and `str`
   (de)serialization options when using the `Decimal128(..)` data type
 - [x] [`bigdecimal::BigDecimal`][bigdecimal::BigDecimal] when using the
   `Decimal128(..)` data type
 
-
 [crate::base::Event]: https://docs.rs/serde_arrow/latest/serde_arrow/event/enum.Event.html
 [crate::to_record_batch]: https://docs.rs/serde_arrow/latest/serde_arrow/fn.to_record_batch.html
 [crate::trace_schema]: https://docs.rs/serde_arrow/latest/serde_arrow/fn.trace_schema.html

From a4817efa17a455e362cf53aea9bd384566dff717 Mon Sep 17 00:00:00 2001
From: Christopher Prohm <mail@cprohm.de>
Date: Fri, 4 Oct 2024 20:20:49 +0200
Subject: [PATCH 24/28] Update tests

---
 serde_arrow/src/test/jiff.rs                  | 136 +++++++++++++++++
 serde_arrow/src/test/mod.rs                   |   1 +
 .../src/test_with_arrow/impls/bytes.rs        |  39 +++++
 serde_arrow/src/test_with_arrow/impls/jiff.rs | 138 +-----------------
 4 files changed, 178 insertions(+), 136 deletions(-)
 create mode 100644 serde_arrow/src/test/jiff.rs

diff --git a/serde_arrow/src/test/jiff.rs b/serde_arrow/src/test/jiff.rs
new file mode 100644
index 00000000..fb3bcce0
--- /dev/null
+++ b/serde_arrow/src/test/jiff.rs
@@ -0,0 +1,136 @@
+use jiff::{
+    civil::{date, time, Date, DateTime, Time},
+    Span, Timestamp, Zoned,
+};
+
+use crate::internal::{testing::assert_error_contains, utils::value};
+
+#[test]
+fn string_repr_examples() {
+    // date
+    let obj = date(2023, 12, 31);
+    assert_eq!(value::transmute::<String>(&obj).unwrap(), "2023-12-31");
+
+    let obj = date(-10, 10, 30);
+    assert_eq!(value::transmute::<String>(&obj).unwrap(), "-000010-10-30");
+    assert_eq!(value::transmute::<Date>("-000010-10-30").unwrap(), obj);
+    assert_error_contains(
+        &value::transmute::<Date>("-0010-10-30"),
+        "six digit integer",
+    );
+
+    // date time without time zone
+    let obj = date(2023, 12, 31).at(18, 30, 0, 0);
+    assert_eq!(
+        value::transmute::<String>(&obj).unwrap(),
+        "2023-12-31T18:30:00"
+    );
+
+    // date time with timezone
+    let obj = date(2023, 12, 31).at(18, 30, 0, 0).intz("UTC").unwrap();
+    assert_eq!(
+        value::transmute::<String>(&obj).unwrap(),
+        "2023-12-31T18:30:00+00:00[UTC]"
+    );
+
+    // time without fractional part
+    let obj = time(16, 56, 42, 0);
+    assert_eq!(value::transmute::<String>(&obj).unwrap(), "16:56:42");
+
+    // time with fractional part
+    let obj = time(16, 56, 42, 123_000_000);
+    assert_eq!(value::transmute::<String>(&obj).unwrap(), "16:56:42.123");
+
+    // day span
+    let obj = Span::new().days(32);
+    assert_eq!(value::transmute::<String>(&obj).unwrap(), "P32d");
+
+    // year month span
+    let obj = Span::new().years(4).months(7);
+    assert_eq!(value::transmute::<String>(&obj).unwrap(), "P4y7m");
+}
+
+/// Test that the different reprs between chrono and jiff are compatible
+#[test]
+fn transmute_jiff_chrono() {
+    // date
+    let chrono = chrono::NaiveDate::from_ymd_opt(2023, 12, 31).unwrap();
+    let jiff = date(2023, 12, 31);
+
+    assert_eq!(value::transmute::<Date>(&chrono).unwrap(), jiff);
+    assert_eq!(
+        value::transmute::<chrono::NaiveDate>(&jiff).unwrap(),
+        chrono
+    );
+
+    // time without fractional part
+    let chrono = chrono::NaiveTime::from_hms_opt(19, 31, 22).unwrap();
+    let jiff = time(19, 31, 22, 0);
+
+    assert_eq!(value::transmute::<Time>(&chrono).unwrap(), jiff);
+    assert_eq!(
+        value::transmute::<chrono::NaiveTime>(&jiff).unwrap(),
+        chrono
+    );
+
+    // time with fractional part
+    let chrono = chrono::NaiveTime::from_hms_nano_opt(19, 31, 22, 123_456_789).unwrap();
+    let jiff = time(19, 31, 22, 123_456_789);
+
+    assert_eq!(value::transmute::<Time>(&chrono).unwrap(), jiff);
+    assert_eq!(
+        value::transmute::<chrono::NaiveTime>(&jiff).unwrap(),
+        chrono
+    );
+
+    // date time
+    let chrono = chrono::NaiveDate::from_ymd_opt(1234, 5, 6)
+        .unwrap()
+        .and_hms_opt(7, 8, 9)
+        .unwrap();
+    let jiff = date(1234, 5, 6).at(7, 8, 9, 0);
+
+    assert_eq!(value::transmute::<DateTime>(&chrono).unwrap(), jiff);
+    assert_eq!(
+        value::transmute::<chrono::NaiveDateTime>(&jiff).unwrap(),
+        chrono
+    );
+
+    // date times with timezone are not compatible
+    let chrono = chrono::NaiveDate::from_ymd_opt(1234, 5, 6)
+        .unwrap()
+        .and_hms_opt(7, 8, 9)
+        .unwrap()
+        .and_utc();
+    let jiff = date(1234, 5, 6).at(7, 8, 9, 0).intz("UTC").unwrap();
+
+    assert_error_contains(&value::transmute::<Zoned>(&chrono), "");
+    assert_error_contains(
+        &value::transmute::<chrono::DateTime<chrono::Utc>>(&jiff),
+        "",
+    );
+
+    // use timestamp
+    let jiff_timestamp = jiff.timestamp();
+    assert_eq!(
+        value::transmute::<Timestamp>(&chrono).unwrap(),
+        jiff_timestamp
+    );
+    assert_eq!(
+        value::transmute::<chrono::DateTime<chrono::Utc>>(&jiff_timestamp).unwrap(),
+        chrono
+    );
+}
+
+#[test]
+fn invalid_utc_formats() {
+    assert_error_contains(&value::transmute::<Zoned>("2023-12-31T18:30:00+00:00"), "");
+    assert_error_contains(&value::transmute::<Zoned>("2023-12-31T18:30:00Z"), "");
+}
+
+#[test]
+fn empty_string_errors() {
+    assert_error_contains(&value::transmute::<Date>(""), "found end of input");
+    assert_error_contains(&value::transmute::<Time>(""), "found end of input");
+    assert_error_contains(&value::transmute::<Zoned>(""), "found end of input");
+}
diff --git a/serde_arrow/src/test/mod.rs b/serde_arrow/src/test/mod.rs
index 0dcab9bb..d2a03003 100644
--- a/serde_arrow/src/test/mod.rs
+++ b/serde_arrow/src/test/mod.rs
@@ -1,4 +1,5 @@
 mod api_chrono;
 mod error_messages;
+mod jiff;
 mod schema_like;
 mod schema_tracing;
diff --git a/serde_arrow/src/test_with_arrow/impls/bytes.rs b/serde_arrow/src/test_with_arrow/impls/bytes.rs
index 9578098d..16aca2bb 100644
--- a/serde_arrow/src/test_with_arrow/impls/bytes.rs
+++ b/serde_arrow/src/test_with_arrow/impls/bytes.rs
@@ -190,3 +190,42 @@ mod fixed_size_binary {
             .deserialize_borrowed(&items);
     }
 }
+
+/// test that byte can be deserialized from string arrays
+mod deserialize_bytes_from_strings {
+    use super::*;
+
+    fn items() -> (Vec<Item<String>>, Vec<Item<ByteBuf>>) {
+        let input = vec![
+            Item(String::from("foo")),
+            Item(String::from("bar")),
+            Item(String::from("baz")),
+        ];
+        let output = vec![
+            Item(ByteBuf::from(b"foo")),
+            Item(ByteBuf::from(b"bar")),
+            Item(ByteBuf::from(b"baz")),
+        ];
+        (input, output)
+    }
+
+    #[test]
+    fn as_large_utf8() {
+        let (input, output) = items();
+
+        Test::new()
+            .with_schema(json!([{"name": "item", "data_type": "LargeUtf8"}]))
+            .serialize(&input)
+            .deserialize(&output);
+    }
+
+    #[test]
+    fn as_utf8() {
+        let (input, output) = items();
+
+        Test::new()
+            .with_schema(json!([{"name": "item", "data_type": "Utf8"}]))
+            .serialize(&input)
+            .deserialize(&output);
+    }
+}
diff --git a/serde_arrow/src/test_with_arrow/impls/jiff.rs b/serde_arrow/src/test_with_arrow/impls/jiff.rs
index 21a4f9fa..d61e0f1e 100644
--- a/serde_arrow/src/test_with_arrow/impls/jiff.rs
+++ b/serde_arrow/src/test_with_arrow/impls/jiff.rs
@@ -1,148 +1,14 @@
 use jiff::{
     civil::{date, time, Date, DateTime, Time},
-    Span, Timestamp, Zoned,
+    Span, Timestamp,
 };
 use serde_json::json;
 
 use crate::{
-    internal::{
-        schema::TracingOptions,
-        testing::assert_error_contains,
-        utils::{value, Item},
-    },
+    internal::{schema::TracingOptions, utils::Item},
     test_with_arrow::impls::utils::Test,
 };
 
-#[test]
-fn string_repr_examples() {
-    // date
-    let obj = date(2023, 12, 31);
-    assert_eq!(value::transmute::<String>(&obj).unwrap(), "2023-12-31");
-
-    let obj = date(-10, 10, 30);
-    assert_eq!(value::transmute::<String>(&obj).unwrap(), "-000010-10-30");
-    assert_eq!(value::transmute::<Date>("-000010-10-30").unwrap(), obj);
-    assert_error_contains(
-        &value::transmute::<Date>("-0010-10-30"),
-        "six digit integer",
-    );
-
-    // date time without time zone
-    let obj = date(2023, 12, 31).at(18, 30, 0, 0);
-    assert_eq!(
-        value::transmute::<String>(&obj).unwrap(),
-        "2023-12-31T18:30:00"
-    );
-
-    // date time with timezone
-    let obj = date(2023, 12, 31).at(18, 30, 0, 0).intz("UTC").unwrap();
-    assert_eq!(
-        value::transmute::<String>(&obj).unwrap(),
-        "2023-12-31T18:30:00+00:00[UTC]"
-    );
-
-    // time without fractional part
-    let obj = time(16, 56, 42, 0);
-    assert_eq!(value::transmute::<String>(&obj).unwrap(), "16:56:42");
-
-    // time with fractional part
-    let obj = time(16, 56, 42, 123_000_000);
-    assert_eq!(value::transmute::<String>(&obj).unwrap(), "16:56:42.123");
-
-    // day span
-    let obj = Span::new().days(32);
-    assert_eq!(value::transmute::<String>(&obj).unwrap(), "P32d");
-
-    // year month span
-    let obj = Span::new().years(4).months(7);
-    assert_eq!(value::transmute::<String>(&obj).unwrap(), "P4y7m");
-}
-
-/// Test that the different reprs between chrono and jiff are compatible
-#[test]
-fn transmute_jiff_chrono() {
-    // date
-    let chrono = chrono::NaiveDate::from_ymd_opt(2023, 12, 31).unwrap();
-    let jiff = date(2023, 12, 31);
-
-    assert_eq!(value::transmute::<Date>(&chrono).unwrap(), jiff);
-    assert_eq!(
-        value::transmute::<chrono::NaiveDate>(&jiff).unwrap(),
-        chrono
-    );
-
-    // time without fractional part
-    let chrono = chrono::NaiveTime::from_hms_opt(19, 31, 22).unwrap();
-    let jiff = time(19, 31, 22, 0);
-
-    assert_eq!(value::transmute::<Time>(&chrono).unwrap(), jiff);
-    assert_eq!(
-        value::transmute::<chrono::NaiveTime>(&jiff).unwrap(),
-        chrono
-    );
-
-    // time with fractional part
-    let chrono = chrono::NaiveTime::from_hms_nano_opt(19, 31, 22, 123_456_789).unwrap();
-    let jiff = time(19, 31, 22, 123_456_789);
-
-    assert_eq!(value::transmute::<Time>(&chrono).unwrap(), jiff);
-    assert_eq!(
-        value::transmute::<chrono::NaiveTime>(&jiff).unwrap(),
-        chrono
-    );
-
-    // date time
-    let chrono = chrono::NaiveDate::from_ymd_opt(1234, 5, 6)
-        .unwrap()
-        .and_hms_opt(7, 8, 9)
-        .unwrap();
-    let jiff = date(1234, 5, 6).at(7, 8, 9, 0);
-
-    assert_eq!(value::transmute::<DateTime>(&chrono).unwrap(), jiff);
-    assert_eq!(
-        value::transmute::<chrono::NaiveDateTime>(&jiff).unwrap(),
-        chrono
-    );
-
-    // date times with timezone are not compatible
-    let chrono = chrono::NaiveDate::from_ymd_opt(1234, 5, 6)
-        .unwrap()
-        .and_hms_opt(7, 8, 9)
-        .unwrap()
-        .and_utc();
-    let jiff = date(1234, 5, 6).at(7, 8, 9, 0).intz("UTC").unwrap();
-
-    assert_error_contains(&value::transmute::<Zoned>(&chrono), "");
-    assert_error_contains(
-        &value::transmute::<chrono::DateTime<chrono::Utc>>(&jiff),
-        "",
-    );
-
-    // use timestamp
-    let jiff_timestamp = jiff.timestamp();
-    assert_eq!(
-        value::transmute::<Timestamp>(&chrono).unwrap(),
-        jiff_timestamp
-    );
-    assert_eq!(
-        value::transmute::<chrono::DateTime<chrono::Utc>>(&jiff_timestamp).unwrap(),
-        chrono
-    );
-}
-
-#[test]
-fn invalid_utc_formats() {
-    assert_error_contains(&value::transmute::<Zoned>("2023-12-31T18:30:00+00:00"), "");
-    assert_error_contains(&value::transmute::<Zoned>("2023-12-31T18:30:00Z"), "");
-}
-
-#[test]
-fn empty_string_errors() {
-    assert_error_contains(&value::transmute::<Date>(""), "found end of input");
-    assert_error_contains(&value::transmute::<Time>(""), "found end of input");
-    assert_error_contains(&value::transmute::<Zoned>(""), "found end of input");
-}
-
 mod time {
     use super::*;
 

From 587ecd5801b06bbc54daae3ffc09b9031f27ab77 Mon Sep 17 00:00:00 2001
From: Christopher Prohm <mail@cprohm.de>
Date: Fri, 4 Oct 2024 20:35:30 +0200
Subject: [PATCH 25/28] Reorg status page to allow deep linking

---
 serde_arrow/Status.md | 206 +++++++++++++++++++++++++-----------------
 1 file changed, 125 insertions(+), 81 deletions(-)

diff --git a/serde_arrow/Status.md b/serde_arrow/Status.md
index 63327342..9a68cc11 100644
--- a/serde_arrow/Status.md
+++ b/serde_arrow/Status.md
@@ -1,6 +1,15 @@
 # Status
 
-Supported arrow data types:
+The page documents the supported types both from an Arrow and a Rust perspective.
+
+- [Arrow data types](#arrow-data-types)
+- [Rust types](#rust-types)
+  - [Native / standard types](#native--standard-types)
+  - [`chrono` types](#chrono-types)
+  - [`jiff` types](#jiff-types)
+  - [`rust_decimal` and `bigdecimal` types](#rust_decimal-and-bigdecimal-types)
+
+## Arrow data types
 
 - [x] [`Null`](https://docs.rs/arrow/latest/arrow/datatypes/enum.DataType.html#variant.Null)
 - [x] [`Boolean`](https://docs.rs/arrow/latest/arrow/datatypes/enum.DataType.html#variant.Boolean)
@@ -49,7 +58,9 @@ Supported arrow data types:
   serialization error.
 - [ ] [`Decimal256(precision, scale)`](https://docs.rs/arrow/latest/arrow/datatypes/enum.DataType.html#variant.Decimal256)
 
-Native / standard Rust types:
+## Rust types
+
+### Native / standard types
 
 - [x] `bool`
 - [x] `i8`, `i16`, `i32`, `i64`
@@ -72,85 +83,118 @@ Native / standard Rust types:
   supported
 - [x] `struct S(T)`: newtype structs are supported, if `T` is supported
 
-Non-standard Rust types
-
-- [x] `chrono::DateTime<Utc>`:
-  - is serialized / deserialized as strings
-  - can be mapped to `Utf8`, `LargeUtf8`, `Timestamp(.., Some("Utc"))`, `Date64` with strategy `UtcStrAsDate64`
-  - `from_samples` detects the type `LargeUtf8` without configuration, the type `Date64` with
-    strategy `UtcStrAsDate64` when setting `guess_dates = true`
-  - `from_type` is not supported, as the type is not self-describing
-- [x] `chrono::DateTime<Utc>` using [`chrono::serde::ts_microseconds`][chrono-ts-microseconds]:
-  - is serialized / deserialized  as `i64`
-  - can be mapped to `Utf8`, `LargeUtf8`, `Timestamp(.., Some("Utc"))`, `Date64` without Strategy,
-    `Date64` with strategy `UtcStrAsDate64`
-  - `from_samples` and `from_type` detect the type `Int64`
-- [x] `chrono::NaiveDateTime`:
-  - is serialized / deserialized as strings
-  - can be mapped to `Utf8`, `LargeUtf8`, `Timestamp(.., None)`, `Date64` with strategy `NaiveStrAsDate64`
-  - `from_samples` detects the type `LargeUtf8` without configuration, the type `Date64` with
-    strategy `NaiveStrAsDate64` when setting `guess_dates = true`
-  - `from_type` is not supported, as the type is not self-describing
-- [x] `chrono::NaiveTime`:
-  - serialized / deserialized as strings
-  - can be mapped to `Utf8`, `LargeUtf8`, `Time32(..)` and `Time64` arrays
-  - `from_samples` detects the type `LargeUtf8` without configuration, the type `Time64(Nanosecond)`
-    when setting `guess_dates = true`
-  - `from_type` is not supported, as the type is not self-describing
-- [x] `chrono::NaiveDate`:
-  - is serialized as Serde strings
-  - can be mapped to `Utf8`, `LargeUtf8`, `Date32` arrays
-  - `from_samples` detects the type `LargeUtf8` without configuration, to `Date32` when setting
-    `guess_dates = true`
-  - `from_type` is not supported, as the type is not self-describing
-- [ ] `chrono::Duration`: does not support Serde and is therefore not supported
-- [x] `jiff::Date`
-  - is serialized as Serde strings
-  - can me mapped to `Utf8`, `LargeUtf8`, `Date32`
-  - `from_samples` detects the type `LargeUtf8` without configuration, the type `Date32` when
-    setting `guess_dates = true`
-  - `from_type` is not supported, as the type is not self-describing
-- [x] `jiff::Time`
-  - is serialized as Serde strings
-  - can me mapped to `Utf8`, `LargeUtf8`, `Time32(..)`, `Time64(..)`
-  - `from_samples` detects the type `LargeUtf8` without configuration, the type `Time64(Nanosecond)`
-    when setitng `guess_dates = true`
-  - `from_type` is not supported, as the type is not self-describing
-- [x] `jiff::DateTime`
-  - is serialized as Serde strings
-  - can me mapped to `Utf8`, `LargeUtf8`, `Timestmap(.., None)`, `Date64` with strategy
-    `NaiveStrAsDate64`
-  - `from_samples` detects the type `LargeUtf8` without configuration, the type `Date64` with
-    strategy `NaiveStrAsDate64` when setting `guess_dates = true`
-  - `from_type` is not supported, as the type is not self-describing
-- [x] `jiff::Timestamp`
-  - is serialized as Serde strings
-  - can me mapped to `Utf8`, `LargeUtf8`, `Timestamp(.., Some("UTC"))`, `Date64` with strategy
-    `UtcStrAsDate64`
-  - `from_samples` detects the type `LargeUtf8` without configuration, the type `Date64` with
-    strategy `UtcStrDate64` when setting  `guess_dates = true`
-  - `from_type` is not supported, as the type is not self-describing
-- [x] `jiff::Span`, `jiff::SignedDuration`
-  - is serialized as Serde strings
-  - can me mapped to `Utf8`, `LargeUtf8`, `Duration(..)`
-  - `from_samples` detects the type `LargeUtf8`
-  - `from_type` is not supported, as the type is not self-describing
-- [ ] `jiff::Zoned` is not supported as there is no clear way of implementation
-- [x] [`rust_decimal::Decimal`][rust_decimal::Decimal] for the `float` and `str`
-  (de)serialization options when using the `Decimal128(..)` data type
-- [x] [`bigdecimal::BigDecimal`][bigdecimal::BigDecimal] when using the
-  `Decimal128(..)` data type
-
-[crate::base::Event]: https://docs.rs/serde_arrow/latest/serde_arrow/event/enum.Event.html
-[crate::to_record_batch]: https://docs.rs/serde_arrow/latest/serde_arrow/fn.to_record_batch.html
-[crate::trace_schema]: https://docs.rs/serde_arrow/latest/serde_arrow/fn.trace_schema.html
-[serde::Serialize]: https://docs.serde.rs/serde/trait.Serialize.html
-[serde::Deserialize]: https://docs.serde.rs/serde/trait.Deserialize.html
-[crate::Schema::from_records]: https://docs.rs/serde_arrow/latest/serde_arrow/struct.Schema.html#method.from_records
-[chrono]: https://docs.rs/chrono/latest/chrono/
-
-[crate::base::EventSource]: https://docs.rs/serde_arrow
-[crate::base::EventSink]: https://docs.rs/serde_arrow
+### `chrono` types
+
+#### `chrono::DateTime<Utc>`
+
+- is serialized / deserialized as strings
+- can be mapped to `Utf8`, `LargeUtf8`, `Timestamp(.., Some("Utc"))`, `Date64` with strategy `UtcStrAsDate64`
+- `from_samples` detects
+  - `LargeUtf8` without configuration
+  - `Date64` with strategy `UtcStrAsDate64` when setting `guess_dates = true`
+- `from_type` is not supported, as the type is not self-describing
+
+With [`chrono::serde::ts_microseconds`][chrono-ts-microseconds]:
+
+- is serialized / deserialized  as `i64`
+- can be mapped to `Utf8`, `LargeUtf8`, `Timestamp(.., Some("Utc"))`, `Date64` without Strategy,
+  `Date64` with strategy `UtcStrAsDate64`
+- `from_samples` and `from_type` detect `Int64`
+
+#### `chrono::NaiveDateTime`
+
+- is serialized / deserialized as strings
+- can be mapped to `Utf8`, `LargeUtf8`, `Timestamp(.., None)`, `Date64` with strategy `NaiveStrAsDate64`
+- `from_samples` detects
+  - `LargeUtf8` without configuration
+  - `Date64` with strategy `NaiveStrAsDate64` when setting `guess_dates = true`
+- `from_type` is not supported, as the type is not self-describing
+
+#### `chrono::NaiveTime`
+
+- serialized / deserialized as strings
+- can be mapped to `Utf8`, `LargeUtf8`, `Time32(..)` and `Time64` arrays
+- `from_samples` detects
+  - `LargeUtf8` without configuration
+  - `Time64(Nanosecond)` when setting `guess_dates = true`
+- `from_type` is not supported, as the type is not self-describing
+
+#### `chrono::NaiveDate`
+
+- is serialized as Serde strings
+- can be mapped to `Utf8`, `LargeUtf8`, `Date32` arrays
+- `from_samples` detects
+  - `LargeUtf8` without configuration
+  - `Date32` when setting `guess_dates = true`
+- `from_type` is not supported, as the type is not self-describing
+
+`chrono::Duration` does not support Serde and is therefore not supported
+
+###  `jiff` types
+
+#### `jiff::Date`
+
+- is serialized as Serde strings
+- can me mapped to `Utf8`, `LargeUtf8`, `Date32`
+- `from_samples` detects
+  - `LargeUtf8` without configuration
+  - `Date32` when setting `guess_dates = true`
+- `from_type` is not supported, as the type is not self-describing
+
+#### `jiff::Time`
+
+- is serialized as Serde strings
+- can me mapped to `Utf8`, `LargeUtf8`, `Time32(..)`, `Time64(..)`
+- `from_samples` detects
+  - `LargeUtf8` without configuration
+  - `Time64(Nanosecond)` when setitng `guess_dates = true`
+- `from_type` is not supported, as the type is not self-describing
+
+#### `jiff::DateTime`
+
+- is serialized as Serde strings
+- can me mapped to `Utf8`, `LargeUtf8`, `Timestmap(.., None)`, `Date64` with strategy
+  `NaiveStrAsDate64`
+- `from_samples` detects
+  - `LargeUtf8` without configuration
+  - `Date64` with strategy `NaiveStrAsDate64` when setting `guess_dates = true`
+- `from_type` is not supported, as the type is not self-describing
+
+#### `jiff::Timestamp`
+
+- is serialized as Serde strings
+- can me mapped to `Utf8`, `LargeUtf8`, `Timestamp(.., Some("UTC"))`, `Date64` with strategy
+  `UtcStrAsDate64`
+- `from_samples` detects
+  - `LargeUtf8` without configuration
+  - `Date64` with strategy `UtcStrDate64` when setting  `guess_dates = true`
+- `from_type` is not supported, as the type is not self-describing
+
+#### `jiff::Span`
+
+- is serialized as Serde strings
+- can me mapped to `Utf8`, `LargeUtf8`, `Duration(..)`
+- `from_samples` detects `LargeUtf8`
+- `from_type` is not supported, as the type is not self-describing
+
+#### `jiff::SignedDuration`
+
+Same as `jiff::Span`
+
+#### `jiff::Zoned`
+
+is not supported as there is no clear way of implementation
+
+###  `rust_decimal` and `bigdecimal` types
+
+### [`rust_decimal::Decimal`][rust_decimal::Decimal]
+
+- for the `float` and `str` (de)serialization options when using the `Decimal128(..)` data type
+
+### [`bigdecimal::BigDecimal`][bigdecimal::BigDecimal]
+
+- when using the `Decimal128(..)` data type
+
 [chrono-ts-microseconds]: https://docs.rs/chrono/latest/chrono/serde/ts_microseconds/
 [rust_decimal::Decimal]: https://docs.rs/rust_decimal/latest/rust_decimal/struct.Decimal.html
 [bigdecimal::BigDecimal]: https://docs.rs/bigdecimal/0.4.2/bigdecimal/struct.BigDecimal.html

From e37e3b0c46672e63ae253898ffc9dd76b187998d Mon Sep 17 00:00:00 2001
From: Christopher Prohm <mail@cprohm.de>
Date: Fri, 4 Oct 2024 20:37:55 +0200
Subject: [PATCH 26/28] Fix clippy

---
 serde_arrow/src/internal/chrono.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/serde_arrow/src/internal/chrono.rs b/serde_arrow/src/internal/chrono.rs
index 1f038911..e351c817 100644
--- a/serde_arrow/src/internal/chrono.rs
+++ b/serde_arrow/src/internal/chrono.rs
@@ -160,7 +160,7 @@ mod parsing {
 
         fn into_result(self, output_type: &str) -> crate::internal::error::Result<Self::Output> {
             match self {
-                Ok((rest, output)) if rest.is_empty() => Ok(output),
+                Ok(("", output)) => Ok(output),
                 Ok((unmatched, _)) | Err(unmatched) => crate::internal::error::fail!(
                     "Could not parse the string as {output_type}, unmatched content: {unmatched:?}"
                 ),

From c3a470a9cfe669e0aeaa9c18efa68f5ac5210242 Mon Sep 17 00:00:00 2001
From: Christopher Prohm <mail@cprohm.de>
Date: Fri, 4 Oct 2024 20:46:29 +0200
Subject: [PATCH 27/28] Small code improvements

---
 serde_arrow/src/internal/chrono.rs              |  4 ++--
 .../deserialization/date64_deserializer.rs      | 17 +++++------------
 2 files changed, 7 insertions(+), 14 deletions(-)

diff --git a/serde_arrow/src/internal/chrono.rs b/serde_arrow/src/internal/chrono.rs
index e351c817..d7a0fbe7 100644
--- a/serde_arrow/src/internal/chrono.rs
+++ b/serde_arrow/src/internal/chrono.rs
@@ -33,8 +33,8 @@ pub fn parse_span(s: &str) -> Result<Span<'_>> {
     parsing::match_span(s).into_result("Span")
 }
 
-// TODO: handle signs
 impl<'a> parsing::Span<'a> {
+    /// Convert the `Span` into an `i64`` with the given `unit`
     pub fn to_arrow_duration(&self, unit: TimeUnit) -> Result<i64> {
         if get_optional_digit_value(self.year)? != 0 || get_optional_digit_value(self.month)? != 0 {
             fail!("Cannot convert interval style spans to a duration");
@@ -136,7 +136,7 @@ fn get_optional_digit_value(s: Option<&str>) -> Result<i64> {
 ///
 /// Each parser has the the following interface:
 ///
-/// `fn (string_to_parser, ..extra_args) -> Result<(rest, result), unmatched_string>`
+/// `fn (string_to_parse, ..extra_args) -> Result<(rest, result), unmatched_string>`
 ///
 mod parsing {
     pub const DIGIT: &[char] = &['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'];
diff --git a/serde_arrow/src/internal/deserialization/date64_deserializer.rs b/serde_arrow/src/internal/deserialization/date64_deserializer.rs
index 611c98ec..9db12467 100644
--- a/serde_arrow/src/internal/deserialization/date64_deserializer.rs
+++ b/serde_arrow/src/internal/deserialization/date64_deserializer.rs
@@ -43,20 +43,13 @@ impl<'a> Date64Deserializer<'a> {
         };
 
         if self.is_utc {
-            Ok(self.format_utc(date_time))
+            Ok(self.format_with_suffix(date_time, "Z"))
         } else {
-            Ok(self.format_non_utc(date_time))
+            Ok(self.format_with_suffix(date_time, ""))
         }
     }
 
-    pub fn format_utc(&self, date_time: DateTime<Utc>) -> String {
-        // NOTE: chrono documents that Debug, not Display, can be parsed
-        let mut s = self.format_non_utc(date_time);
-        s.push('Z');
-        s
-    }
-
-    pub fn format_non_utc(&self, date_time: DateTime<Utc>) -> String {
+    pub fn format_with_suffix(&self, date_time: DateTime<Utc>, suffix: &str) -> String {
         let date_time = date_time.naive_utc();
         // special handling of negative dates:
         //
@@ -67,7 +60,7 @@ impl<'a> Date64Deserializer<'a> {
         if date_time.year() < 0 {
             // NOTE: chrono documents that Debug, not Display, can be parsed
             format!(
-                "-{positive_year:06}-{month:02}-{day:02}T{time:?}",
+                "-{positive_year:06}-{month:02}-{day:02}T{time:?}{suffix}",
                 positive_year = -date_time.year(),
                 month = date_time.month(),
                 day = date_time.day(),
@@ -75,7 +68,7 @@ impl<'a> Date64Deserializer<'a> {
             )
         } else {
             // NOTE: chrono documents that Debug, not Display, can be parsed
-            format!("{:?}", date_time)
+            format!("{:?}{suffix}", date_time)
         }
     }
 }

From c5698bf9ff299aa4edf43e4bda433d0ca2125eb0 Mon Sep 17 00:00:00 2001
From: Christopher Prohm <mail@cprohm.de>
Date: Sat, 5 Oct 2024 09:22:49 +0200
Subject: [PATCH 28/28] Remove outdated todo

---
 serde_arrow/src/internal/utils/mod.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/serde_arrow/src/internal/utils/mod.rs b/serde_arrow/src/internal/utils/mod.rs
index 7fa35e5d..43536bf4 100644
--- a/serde_arrow/src/internal/utils/mod.rs
+++ b/serde_arrow/src/internal/utils/mod.rs
@@ -90,7 +90,6 @@ impl<'de, T: Deserialize<'de>> Deserialize<'de> for Item<T> {
     }
 }
 
-// TODO: implement for all types?
 impl<'de, T: Deserialize<'de>> Deserialize<'de> for Items<Vec<T>> {
     fn deserialize<D: serde::Deserializer<'de>>(
         deserializer: D,