arrow_json/reader/
map_array.rs1use std::sync::Arc;
6
7use arrow_array::{ArrayRef, MapArray, StructArray};
8use arrow_buffer::{ArrowNativeType, NullBufferBuilder, OffsetBuffer, ScalarBuffer};
9use arrow_schema::{ArrowError, DataType, FieldRef, Fields};
10
11use crate::reader::tape::{Tape, TapeElement};
12use crate::reader::{ArrayDecoder, DecoderContext};
13
14pub struct MapArrayDecoder {
15 entries_field: FieldRef,
16 key_value_fields: Fields,
17 ordered: bool,
18 keys: Box<dyn ArrayDecoder>,
19 values: Box<dyn ArrayDecoder>,
20 ignore_type_conflicts: bool,
21 is_nullable: bool,
22}
23
24impl MapArrayDecoder {
25 pub fn new(
26 ctx: &DecoderContext,
27 data_type: &DataType,
28 is_nullable: bool,
29 ) -> Result<Self, ArrowError> {
30 let (entries_field, ordered) = match data_type {
31 DataType::Map(_, true) => {
32 return Err(ArrowError::NotYetImplemented(
33 "Decoding MapArray with sorted fields".to_string(),
34 ));
35 }
36 DataType::Map(f, ordered) => (f.clone(), *ordered),
37 _ => unreachable!(),
38 };
39
40 let key_value_fields = match entries_field.data_type() {
41 DataType::Struct(fields) if fields.len() == 2 => fields.clone(),
42 d => {
43 return Err(ArrowError::InvalidArgumentError(format!(
44 "MapArray must contain struct with two fields, got {d}"
45 )));
46 }
47 };
48
49 let keys = ctx.make_decoder(&key_value_fields[0], key_value_fields[0].is_nullable())?;
50 let values = ctx.make_decoder(&key_value_fields[1], key_value_fields[1].is_nullable())?;
51
52 Ok(Self {
53 entries_field,
54 key_value_fields,
55 ordered,
56 keys,
57 values,
58 ignore_type_conflicts: ctx.ignore_type_conflicts(),
59 is_nullable,
60 })
61 }
62}
63
64impl ArrayDecoder for MapArrayDecoder {
65 fn decode(&mut self, tape: &Tape<'_>, pos: &[u32]) -> Result<ArrayRef, ArrowError> {
66 let mut offsets = Vec::with_capacity(pos.len() + 1);
67 offsets.push(0);
68
69 let mut key_pos = Vec::with_capacity(pos.len());
70 let mut value_pos = Vec::with_capacity(pos.len());
71
72 let mut nulls = self.is_nullable.then(|| NullBufferBuilder::new(pos.len()));
73
74 for p in pos.iter().copied() {
75 let end_idx = match (tape.get(p), nulls.as_mut()) {
76 (TapeElement::StartObject(end_idx), None) => end_idx,
77 (TapeElement::StartObject(end_idx), Some(nulls)) => {
78 nulls.append_non_null();
79 end_idx
80 }
81 (TapeElement::Null, Some(nulls)) => {
82 nulls.append_null();
83 p + 1
84 }
85 (_, Some(nulls)) if self.ignore_type_conflicts => {
86 nulls.append_null();
87 p + 1
88 }
89 _ => return Err(tape.error(p, "{")),
90 };
91
92 let mut cur_idx = p + 1;
93 while cur_idx < end_idx {
94 let key = cur_idx;
95 let value = tape.next(key, "map key")?;
96 cur_idx = tape.next(value, "map value")?;
97
98 key_pos.push(key);
99 value_pos.push(value);
100 }
101
102 let offset = i32::from_usize(key_pos.len()).ok_or_else(|| {
103 ArrowError::JsonError("offset overflow decoding MapArray".to_string())
104 })?;
105 offsets.push(offset)
106 }
107
108 assert_eq!(key_pos.len(), value_pos.len());
109
110 let key_array = self.keys.decode(tape, &key_pos)?;
111 let value_array = self.values.decode(tape, &value_pos)?;
112
113 let entries = StructArray::try_new_with_length(
114 self.key_value_fields.clone(),
115 vec![key_array, value_array],
116 None,
117 key_pos.len(),
118 )?;
119
120 let nulls = nulls.as_mut().and_then(|x| x.finish());
121 let offsets = unsafe { OffsetBuffer::new_unchecked(ScalarBuffer::from(offsets)) };
123
124 let array = MapArray::try_new(
125 self.entries_field.clone(),
126 offsets,
127 entries,
128 nulls,
129 self.ordered,
130 )?;
131 Ok(Arc::new(array))
132 }
133}