Struct BlockDataStream

pub struct BlockDataStream {
    buf_reader: MonitoredStreamingReader,
    block_idx: usize,
    block_metas: Vec<BlockMeta>,
    buf: Bytes,
    buff_offset: usize,
}

An iterator that reads the blocks of an SST step by step from a given stream of bytes.

Fields

buf_reader: MonitoredStreamingReader

block_idx: usize

The index of the next block. Note that block_idx is relative to the start index of the stream (and is compatible with block_size_vec); it is not relative to the corresponding SST. That is, if streaming starts at block 2 of a given SST T, then block_idx = 0 refers to the third block of T.

block_metas: Vec<BlockMeta>

The sizes of each block which the stream reads. The first number states the compressed size in the stream. The second number is the block’s uncompressed size. Note that the list does not contain the size of blocks which precede the first streamed block. That is, if streaming starts at block 2 of a given SST, then the list does not contain information about block 0 and block 1.

buf: Bytes

buff_offset: usize

Implementations

impl BlockDataStream

pub fn new( byte_stream: MonitoredStreamingReader, block_metas: Vec<BlockMeta>, ) -> Self

Constructs a new BlockStream object that reads from the given byte_stream and interprets the data as blocks of the SST described in sst_meta, starting at block block_index.

If block_index >= sst_meta.block_metas.len(), then BlockStream will not read any data from byte_stream.

pub async fn next_block_impl(&mut self) -> HummockResult<Option<(Bytes, usize)>>

Reads the next block from the stream and returns it. Returns None if there are no blocks left to read.

async fn read_next_buf(&mut self, read_size: usize) -> HummockResult<Bytes>

pub fn next_block_index(&self) -> usize

pub async fn next_block(&mut self) -> HummockResult<Option<Box<Block>>>