Struct BTreeMapTransactionInner

pub struct BTreeMapTransactionInner<K: Ord, V, P: DerefMut<Target = BTreeMap<K, V>>> {
    tree_ref: P,
    staging: BTreeMap<K, BTreeMapOp<V>>,
}

A ValTransaction that wraps a BTreeMap. It supports basic BTreeMap operations like get, get_mut, insert and remove. Incremental modification of insert, remove and get_mut are stored in staging. On commit, it will apply the changes stored in staging to the in memory btree map. When serve get and get_mut, it merges the value stored in staging and tree_ref.

Fields

tree_ref: P

A reference to the original BTreeMap. All access to this field should be immutable, except when we commit the staging changes to the original map.

staging: BTreeMap<K, BTreeMapOp<V>>

Store all the staging changes that will be applied to the original map on commit

Implementations

impl BTreeMapTransactionInner<u64, CompactionGroup, &mut BTreeMap<u64, CompactionGroup>>

pub fn try_create_compaction_groups( &mut self, compaction_group_ids: &[CompactionGroupId], config: Arc<CompactionConfig>, ) -> bool

Inserts compaction group configs if they do not exist.

pub fn create_compaction_groups( &mut self, compaction_group_id: CompactionGroupId, config: Arc<CompactionConfig>, )

pub(crate) fn try_get_compaction_group_config( &self, compaction_group_id: CompactionGroupId, ) -> Option<&CompactionGroup>

Tries to get compaction group config for compaction_group_id.

pub fn purge(&mut self, existing_groups: HashSet<CompactionGroupId>)

Removes stale group configs.

pub(crate) fn update_compaction_config( &mut self, compaction_group_ids: &[CompactionGroupId], config_to_update: &[MutableConfig], ) -> Result<HashMap<CompactionGroupId, CompactionGroup>>

impl<K: Ord + Debug, V: Clone, P: DerefMut<Target = BTreeMap<K, V>>> BTreeMapTransactionInner<K, V, P>

pub fn new(tree_ref: P) -> BTreeMapTransactionInner<K, V, P>

pub fn new_entry_txn( &mut self, key: K, ) -> Option<BTreeMapEntryTransaction<'_, K, V>>

Start a BTreeMapEntryTransaction when the key exists

pub fn new_entry_txn_or_default( &mut self, key: K, default_val: V, ) -> BTreeMapEntryTransaction<'_, K, V>

Start a BTreeMapEntryTransaction. If the key does not exist, the the default_val will be taken as the initial value of the transaction and will be applied to the original BTreeMap on commit.

pub fn new_entry_insert_txn( &mut self, key: K, val: V, ) -> BTreeMapEntryTransaction<'_, K, V>

Start a BTreeMapEntryTransaction that inserts the val into key.

pub fn tree_ref(&self) -> &BTreeMap<K, V>

pub fn get(&self, key: &K) -> Option<&V>

Get the value of the provided key by merging the staging value and the original value

pub fn contains_key(&self, key: &K) -> bool

pub fn get_mut( &mut self, key: K, ) -> Option<BTreeMapTransactionValueGuard<'_, K, V>>

This method serves the same semantic to the get_mut of BTreeMap.

It return a BTreeMapTransactionValueGuard of the corresponding key for mutable access to guarded staging value.

When the value does not exist in the staging (either key not exist or with a Delete record) and the value does not exist in the original BTreeMap, return None.

pub fn insert(&mut self, key: K, value: V)

pub fn remove(&mut self, key: K) -> Option<V>

pub fn commit_memory(self)

Trait Implementations

impl<K: Ord + Debug, V: Clone, P: DerefMut<Target = BTreeMap<K, V>>> InMemValTransaction for BTreeMapTransactionInner<K, V, P>

fn commit(self)

Commit the change to local memory value

impl<K: Ord + Debug, V: Transactional<TXN> + Clone, P: DerefMut<Target = BTreeMap<K, V>>, TXN> ValTransaction<TXN> for BTreeMapTransactionInner<K, V, P>

async fn apply_to_txn(&self, txn: &mut TXN) -> MetadataModelResult<()>

Apply the change (upsert or delete) to txn