Function read_header

arrow-avro/src/reader/async_reader/builder.rs:138–184

(
    reader: &mut R,
    file_size: u64,
    header_size_hint: Option<u64>,
)

}

async fn read_header<R>(
    reader: &mut R,
    file_size: u64,
    header_size_hint: Option<u64>,
) -> Result<(Header, u64), AvroError>
where
    R: AsyncFileReader,
{
    let mut decoder = HeaderDecoder::default();
    let mut position = 0;
    loop {
        let range_to_fetch = position
            ..(position + header_size_hint.unwrap_or(DEFAULT_HEADER_SIZE_HINT)).min(file_size);

        // Maybe EOF after the header, no actual data
        if range_to_fetch.is_empty() {
            break;
        }

        let current_data = reader
            .get_bytes(range_to_fetch.clone())
            .await
            .map_err(|err| {
                AvroError::General(format!(
                    "Error fetching Avro header from file reader: {err}"
                ))
            })?;
        if current_data.is_empty() {
            return Err(AvroError::EOF(
                "Unexpected EOF while fetching header data".into(),
            ));
        }

        let read = current_data.len();
        let decoded = decoder.decode(&current_data)?;
        if decoded != read {
            position += decoded as u64;
            break;
        }
        position += read as u64;
    }

    decoder
        .flush()
        .map(|header| (header, position))
        .ok_or_else(|| AvroError::EOF("Unexpected EOF while reading Avro header".into()))
}

impl<R: AsyncFileReader> ReaderBuilder<R> {
    /// Build the asynchronous Avro reader with the provided parameters.