Method new

arrow-json/src/reader/map_array.rs:39–81

(
        ctx: &DecoderContext,
        data_type: &DataType,
        is_nullable: bool,
    )

impl MapArrayDecoder {
    pub fn new(
        ctx: &DecoderContext,
        data_type: &DataType,
        is_nullable: bool,
    ) -> Result<Self, ArrowError> {
        let (entries_field, ordered) = match data_type {
            DataType::Map(_, true) => {
                return Err(ArrowError::NotYetImplemented(
                    "Decoding MapArray with sorted fields".to_string(),
                ));
            }
            DataType::Map(f, ordered) => (f.clone(), *ordered),
            _ => unreachable!(),
        };

        let key_value_fields = match entries_field.data_type() {
            DataType::Struct(fields) if fields.len() == 2 => fields.clone(),
            d => {
                return Err(ArrowError::InvalidArgumentError(format!(
                    "MapArray must contain struct with two fields, got {d}"
                )));
            }
        };

        let keys = ctx.make_decoder(
            key_value_fields[0].data_type(),
            key_value_fields[0].is_nullable(),
        )?;
        let values = ctx.make_decoder(
            key_value_fields[1].data_type(),
            key_value_fields[1].is_nullable(),
        )?;

        Ok(Self {
            entries_field,
            key_value_fields,
            ordered,
            keys,
            values,
            ignore_type_conflicts: ctx.ignore_type_conflicts(),
            is_nullable,
        })
    }
}

impl ArrayDecoder for MapArrayDecoder {