Struct ChangeLogIteratorInner

struct ChangeLogIteratorInner<NI: HummockIterator<Direction = Forward>, OI: HummockIterator<Direction = Forward>> {
    new_value_iter: NI,
    old_value_iter: OI,
    max_epoch: u64,
    min_epoch: u64,
    key_range: UserKeyRange,
    curr_key: FullKey<Vec<u8>>,
    new_value: Vec<u8>,
    is_new_value_delete: bool,
    is_old_value_set: bool,
    is_current_pos_valid: bool,
}

Fields

new_value_iter: NI

Iterator for new value. In each next, the iterator will iterate over all value of the current key. Therefore, we need to buffer the key and newest value in curr_key and new_value.

We assume that all operation between min_epoch and max_epoch will be included in the new_value_iter.

old_value_iter: OI

Iterator for old value. When is_old_value_set is true, its value is the old value in the change log value.

We assume that each old value will have a new value of the same epoch in the new_value_iter. This is to say, For a specific key, we won’t have an epoch that only exists in the old_value_iter but not exists in new_value_iter. Delete also contains a tombstone value.

max_epoch: u64

Inclusive max epoch

min_epoch: u64

Inclusive min epoch

key_range: UserKeyRange

curr_key: FullKey<Vec<u8>>

Buffer of current key

new_value: Vec<u8>

Buffer for new value. Only valid when is_new_value_delete is true

is_new_value_delete: bool

Indicate whether the current new value is delete.

is_old_value_set: bool

Whether Indicate whether the current old_value_iter represents the old value in ChangeLogValue

is_current_pos_valid: bool

Whether the iterator is currently pointing at a valid key with ChangeLogValue

Implementations

impl<NI: HummockIterator<Direction = Forward>, OI: HummockIterator<Direction = Forward>> ChangeLogIteratorInner<NI, OI>

fn new( (min_epoch, max_epoch): (u64, u64), key_range: UserKeyRange, new_value_iter: NI, old_value_iter: OI, ) -> Self

pub async fn rewind(&mut self) -> HummockResult<()>

Resets the iterating position to the beginning.

pub async fn next(&mut self) -> HummockResult<()>

pub fn is_valid(&self) -> bool

pub fn log_value(&self) -> ChangeLogValue<&[u8]>

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

impl<NI: HummockIterator<Direction = Forward>, OI: HummockIterator<Direction = Forward>> ChangeLogIteratorInner<NI, OI>

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

fn user_key_out_of_range(&self, user_key: UserKey<&[u8]>) -> bool

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

Advance the new_value_iter to a valid key and valid epoch.

async fn advance_to_find_oldest_epoch(&mut self) -> HummockResult<EpochWithGap>

Advance the new_value_iter to find the oldest epoch of the current key.

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

Advance the two iters to a valid position. After it returns with Ok, it is possible that the position is valid but there is no change log value, because the new and old value may consume each other, such as Insert in old epoch, but then Delete in new epoch

fn is_valid_epoch(&self, epoch: EpochWithGap) -> bool

fn old_value(&self) -> Option<&[u8]>

fn has_log_value(&self) -> bool