arrow_json/reader/
timestamp_array.rs1use std::marker::PhantomData;
6use std::sync::Arc;
7
8use arrow_array::ArrayRef;
9use arrow_array::builder::PrimitiveBuilder;
10use arrow_array::types::ArrowTimestampType;
11use arrow_cast::parse::string_to_datetime;
12use arrow_schema::{ArrowError, DataType, TimeUnit};
13use chrono::TimeZone;
14use num_traits::NumCast;
15
16use crate::reader::tape::{Tape, TapeElement};
17use crate::reader::{ArrayDecoder, DecoderContext};
18
19pub struct TimestampArrayDecoder<P: ArrowTimestampType, Tz: TimeZone> {
21 data_type: DataType,
22 timezone: Tz,
23 ignore_type_conflicts: bool,
24 phantom: PhantomData<fn(P) -> P>,
26}
27
28impl<P: ArrowTimestampType, Tz: TimeZone> TimestampArrayDecoder<P, Tz> {
29 pub fn new(ctx: &DecoderContext, data_type: &DataType, timezone: Tz) -> Self {
30 Self {
31 data_type: data_type.clone(),
32 timezone,
33 ignore_type_conflicts: ctx.ignore_type_conflicts(),
34 phantom: Default::default(),
35 }
36 }
37}
38
39impl<P, Tz> ArrayDecoder for TimestampArrayDecoder<P, Tz>
40where
41 P: ArrowTimestampType,
42 Tz: TimeZone + Send,
43{
44 fn decode(&mut self, tape: &Tape<'_>, pos: &[u32]) -> Result<ArrayRef, ArrowError> {
45 let mut builder =
46 PrimitiveBuilder::<P>::with_capacity(pos.len()).with_data_type(self.data_type.clone());
47 for p in pos {
48 let value = match tape.get(*p) {
49 TapeElement::Null => {
50 builder.append_null();
51 continue;
52 }
53 TapeElement::String(idx) => {
54 let s = tape.get_string(idx);
55 let date = string_to_datetime(&self.timezone, s).map_err(|e| {
56 ArrowError::JsonError(format!(
57 "failed to parse \"{s}\" as {}: {}",
58 self.data_type, e
59 ))
60 });
61
62 date.and_then(|date| match P::UNIT {
63 TimeUnit::Second => Ok(date.timestamp()),
64 TimeUnit::Millisecond => Ok(date.timestamp_millis()),
65 TimeUnit::Microsecond => Ok(date.timestamp_micros()),
66 TimeUnit::Nanosecond => date.timestamp_nanos_opt().ok_or_else(|| {
67 ArrowError::ParseError(format!(
68 "{} would overflow 64-bit signed nanoseconds",
69 date.to_rfc3339(),
70 ))
71 }),
72 })
73 }
74 TapeElement::Number(idx) => {
75 let s = tape.get_string(idx);
76 let b = s.as_bytes();
77 lexical_core::parse::<i64>(b)
78 .ok()
79 .or_else(|| lexical_core::parse::<f64>(b).ok().and_then(NumCast::from))
81 .ok_or_else(|| {
82 ArrowError::JsonError(format!(
83 "failed to parse {s} as {}",
84 self.data_type
85 ))
86 })
87 }
88 TapeElement::I32(v) => Ok(v as i64),
89 TapeElement::I64(high) => match tape.get(p + 1) {
90 TapeElement::I32(low) => Ok(((high as i64) << 32) | (low as u32) as i64),
91 _ => unreachable!(),
92 },
93 _ => Err(tape.error(*p, "primitive")),
94 };
95
96 match value {
97 Ok(value) => builder.append_value(value),
98 Err(_) if self.ignore_type_conflicts => builder.append_null(),
99 Err(e) => return Err(e),
100 }
101 }
102
103 Ok(Arc::new(builder.finish()))
104 }
105}