Struct BlockStreamIterator 

pub(crate) struct BlockStreamIterator {
    block_stream: SstableBlockStream,
    iter: Option<BlockIterator>,
    task_progress: Arc<TaskProgress>,
    stats_ptr: Arc<AtomicU64>,
}

Streams physical SST blocks for raw copy or decoded compaction.

Fields

block_stream: SstableBlockStream

iter: Option<BlockIterator>

When present, this is the decoded block immediately before the stream cursor. Otherwise the next block is still eligible for raw copy, or the SST is exhausted.

task_progress: Arc<TaskProgress>

stats_ptr: Arc<AtomicU64>

Implementations

impl BlockStreamIterator

pub(crate) fn new( sstable: TableHolder, task_progress: Arc<TaskProgress>, sstable_store: SstableStoreRef, sstable_info: SstableInfo, max_io_retry_times: usize, stats_ptr: Arc<AtomicU64>, ) -> Self

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

fn current_block_raw_metadata(&self) -> (Vec<u8>, BlockMeta)

Materialize writer metadata only when copying the most recently downloaded block. Decoded compaction uses the uncompressed size returned by download_next_block instead.

fn has_decoded_block(&self) -> bool

async fn ensure_block_iter(&mut self) -> HummockResult<()>

pub(crate) fn init_block_iter( &mut self, buf: Bytes, uncompressed_capacity: usize, ) -> HummockResult<()>

fn next_block_smallest(&self) -> &[u8]

fn next_block_upper_bound(&self) -> &[u8]

Upper bound used to decide whether the unread block precedes the other input. The next block’s lower bound is exclusive; the SST’s largest key is inclusive. Callers must compare user keys strictly to avoid copying across versions of one key.

fn current_block_largest(&self) -> Vec<u8>

Builder boundary for the just-downloaded block, not necessarily its last stored key.

fn key(&self) -> FullKey<&[u8]>

Current decoded key, or a possibly shortened lower bound of the unread block.

pub(crate) fn is_valid(&self) -> bool

Trait Implementations

impl Drop for BlockStreamIterator

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.