[Variant][Shredding] Support typed_access for timestamp_micro/timestamp_nano (#8401)

# Which issue does this PR close?

- Closes #8331 .

# Rationale for this change

- Add typed_access for `Timestamp(Micro, _)` and `Timestamp(Nano, -)`

# What changes are included in this PR?

- Extract some data gen logic in tests to simplify the test logic
(commit 93090d5), but it based on some
old code(before #8392), rebase the master in the last commit
- Add typed_access for `Timestamp(Micro, _)` and `Timestamp(Nano, _)`
- Add test for typed_access for `Timestamp(Micro, _)` and
`Timestamp(Nano, _)`

# Are these changes tested?

Covered by existing and added tests

# Are there any user-facing changes?

No

Author: klion26

parquet-variant-compute/src/variant_array.rs

@@ -17,15 +17,17 @@
 
 //! [`VariantArray`] implementation
 
-use crate::type_conversion::primitive_conversion_single_value;
+use crate::type_conversion::{generic_conversion_single_value, primitive_conversion_single_value};
 use arrow::array::{Array, ArrayRef, AsArray, BinaryViewArray, StructArray};
 use arrow::buffer::NullBuffer;
 use arrow::compute::cast;
 use arrow::datatypes::{
     Date32Type, Float16Type, Float32Type, Float64Type, Int16Type, Int32Type, Int64Type, Int8Type,
+    TimestampMicrosecondType, TimestampNanosecondType,
 };
 use arrow_schema::extension::ExtensionType;
 use arrow_schema::{ArrowError, DataType, Field, FieldRef, Fields, TimeUnit};
+use chrono::DateTime;
 use parquet_variant::Uuid;
 use parquet_variant::Variant;
 
@@ -837,6 +839,42 @@ fn typed_value_to_variant<'a>(
         DataType::Float64 => {
             primitive_conversion_single_value!(Float64Type, typed_value, index)
         }
+        DataType::Timestamp(TimeUnit::Microsecond, Some(_)) => {
+            generic_conversion_single_value!(
+                TimestampMicrosecondType,
+                as_primitive,
+                |v| DateTime::from_timestamp_micros(v).unwrap(),
+                typed_value,
+                index
+            )
+        }
+        DataType::Timestamp(TimeUnit::Microsecond, None) => {
+            generic_conversion_single_value!(
+                TimestampMicrosecondType,
+                as_primitive,
+                |v| DateTime::from_timestamp_micros(v).unwrap().naive_utc(),
+                typed_value,
+                index
+            )
+        }
+        DataType::Timestamp(TimeUnit::Nanosecond, Some(_)) => {
+            generic_conversion_single_value!(
+                TimestampNanosecondType,
+                as_primitive,
+                DateTime::from_timestamp_nanos,
+                typed_value,
+                index
+            )
+        }
+        DataType::Timestamp(TimeUnit::Nanosecond, None) => {
+            generic_conversion_single_value!(
+                TimestampNanosecondType,
+                as_primitive,
+                |v| DateTime::from_timestamp_nanos(v).naive_utc(),
+                typed_value,
+                index
+            )
+        }
         // todo other types here (note this is very similar to cast_to_variant.rs)
         // so it would be great to figure out how to share this code
         _ => {