Skip to main content

arrow_json/reader/
map_array.rs

1// SPDX-License-Identifier: Apache-2.0
2// SPDX-FileCopyrightText: See the NOTICE file distributed with this work for additional information regarding copyright ownership
3// SPDX-FileContributor: Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements
4
5use 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        // SAFETY: offsets are built monotonically starting from 0
122        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}