Method read

parquet/src/arrow/array_reader/fixed_len_byte_array.rs:423–498

(&mut self, out: &mut Self::Buffer, num_values: usize)

    }

    fn read(&mut self, out: &mut Self::Buffer, num_values: usize) -> Result<usize> {
        match out.byte_length {
            Some(x) => assert_eq!(x, self.byte_length),
            None => {
                out.byte_length = Some(self.byte_length);
                // TODO: collapse to a let-chain once MSRV ≥ 1.88
                // (`if out.buffer.is_empty() && let Some(cap) = out.values_capacity.take()`)
                if out.buffer.is_empty() {
                    if let Some(values_capacity) = out.values_capacity.take() {
                        // now that the byte length per output element is known,
                        // allocate the actual needed space.
                        let byte_capacity = values_capacity.saturating_mul(self.byte_length);
                        out.buffer = Vec::with_capacity(byte_capacity);
                    }
                }
            }
        }

        match self.decoder.as_mut().unwrap() {
            Decoder::Plain { offset, buf } => {
                let to_read =
                    (num_values * self.byte_length).min(buf.len() - *offset) / self.byte_length;
                let end_offset = *offset + to_read * self.byte_length;
                out.buffer
                    .extend_from_slice(&buf.as_ref()[*offset..end_offset]);
                *offset = end_offset;
                Ok(to_read)
            }
            Decoder::Dict { decoder } => {
                let dict = self.dict_page.as_ref().unwrap();
                // All data must be NULL
                if dict.is_empty() {
                    return Ok(0);
                }

                decoder.read(num_values, |keys| {
                    out.buffer.reserve(keys.len() * self.byte_length);
                    for key in keys {
                        let offset = *key as usize * self.byte_length;
                        let val = &dict.as_ref()[offset..offset + self.byte_length];
                        out.buffer.extend_from_slice(val);
                    }
                    Ok(())
                })
            }
            Decoder::Delta { decoder } => {
                let to_read = num_values.min(decoder.remaining());
                out.buffer.reserve(to_read * self.byte_length);

                decoder.read(to_read, |slice| {
                    if slice.len() != self.byte_length {
                        return Err(general_err!(
                            "encountered array with incorrect length, got {} expected {}",
                            slice.len(),
                            self.byte_length
                        ));
                    }
                    out.buffer.extend_from_slice(slice);