Struct FullKeyTracker

pub struct FullKeyTracker<T: AsRef<[u8]> + Ord + Eq, const SKIP_DEDUP: bool = false> {
    pub latest_full_key: FullKey<T>,
    last_observed_epoch_with_gap: EpochWithGap,
}

TODO: Temporary bypass full key check. Remove this field after #15099 is resolved.

Fields

latest_full_key: FullKey<T>

last_observed_epoch_with_gap: EpochWithGap

Implementations

impl<T: AsRef<[u8]> + Ord + Eq, const SKIP_DEDUP: bool> FullKeyTracker<T, SKIP_DEDUP>

pub fn new(init_full_key: FullKey<T>) -> Self

pub fn observe<F>(&mut self, key: FullKey<F>) -> bool

where T: SetSlice<F>, F: AsRef<[u8]>,

Check and observe a new full key during iteration

Examples:

use bytes::Bytes;
use risingwave_common::catalog::TableId;
use risingwave_common::util::epoch::EPOCH_AVAILABLE_BITS;
use risingwave_hummock_sdk::EpochWithGap;
use risingwave_hummock_sdk::key::{FullKey, FullKeyTracker, TableKey};

let table_id = TableId { table_id: 1 };
let full_key1 = FullKey::new(table_id, TableKey(Bytes::from("c")), 5 << EPOCH_AVAILABLE_BITS);
let mut a: FullKeyTracker<_> = FullKeyTracker::<Bytes>::new(full_key1.clone());

// Panic on non-decreasing epoch observed for the same user key.
// let full_key_with_larger_epoch = FullKey::new(table_id, TableKey(Bytes::from("c")), 6 << EPOCH_AVAILABLE_BITS);
// a.observe(full_key_with_larger_epoch);

// Panic on non-increasing user key observed.
// let full_key_with_smaller_user_key = FullKey::new(table_id, TableKey(Bytes::from("b")), 3 << EPOCH_AVAILABLE_BITS);
// a.observe(full_key_with_smaller_user_key);

let full_key2 = FullKey::new(table_id, TableKey(Bytes::from("c")), 3 << EPOCH_AVAILABLE_BITS);
assert_eq!(a.observe(full_key2.clone()), false);
assert_eq!(a.latest_user_key(), &full_key2.user_key);

let full_key3 = FullKey::new(table_id, TableKey(Bytes::from("f")), 4 << EPOCH_AVAILABLE_BITS);
assert_eq!(a.observe(full_key3.clone()), true);
assert_eq!(a.latest_user_key(), &full_key3.user_key);

Return:

• If the provided key contains a new user key, return true.
• Otherwise: return false

pub fn observe_multi_version<F>( &mut self, user_key: UserKey<F>, epochs: impl Iterator<Item = EpochWithGap>, ) -> bool

where T: SetSlice<F>, F: AsRef<[u8]>,

epochs comes from greater to smaller

pub fn latest_user_key(&self) -> &UserKey<T>