Struct LeafNode 

pub struct LeafNode<K, V>
where
    K: Clone + Ord + Debug,
    V: Clone + Debug,
{
    pub id: NodeId,
    pub keys: Vec<K>,
    pub entries: Vec<LeafEntry<K, V>>,
    pub next: Option<NodeId>,
    pub prev: Option<NodeId>,
}

Leaf node (keys + versioned values)

Fields

id: NodeId

Node ID

keys: Vec<K>

Keys

entries: Vec<LeafEntry<K, V>>

Versioned values (parallel to keys)

next: Option<NodeId>

Next leaf (for range scans)

prev: Option<NodeId>

Previous leaf (for reverse scans)

Implementations

impl<K, V> LeafNode<K, V>

where K: Clone + Ord + Debug, V: Clone + Debug,

pub fn new() -> Self

Create new leaf node

pub fn find_index(&self, key: &K) -> Result<usize, usize>

Find index for key

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

Get value for key

pub fn contains(&self, key: &K, snapshot: &Snapshot) -> bool

Check if key exists

pub fn insert( &mut self, key: K, value: V, txn_id: TxnId, timestamp: Timestamp, ) -> bool

Insert key-value pair

pub fn delete(&mut self, key: &K, txn_id: TxnId, timestamp: Timestamp) -> bool

Delete key

pub fn split(&mut self) -> (K, Self)

Split node at middle

pub fn merge(&mut self, right: &mut Self)

Merge with right sibling

pub fn borrow_from_left(&mut self, left: &mut Self) -> K

Borrow from left sibling

Invariant

Caller must have verified that left.keys.len() > MIN_KEYS before invoking this function. In leaf nodes keys.len() == entries.len() always, so one invariant check covers both pops.

pub fn borrow_from_right(&mut self, right: &mut Self) -> K

Borrow from right sibling

pub fn range<'a>( &'a self, start: Option<&K>, end: Option<&K>, snapshot: &'a Snapshot, ) -> impl Iterator<Item = (&'a K, &'a V)>

Get all keys in range

pub fn gc(&mut self, watermark: Timestamp) -> usize

Garbage collect old versions

Trait Implementations

impl<K, V> Debug for LeafNode<K, V>

where K: Clone + Ord + Debug + Debug, V: Clone + Debug + Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<K, V> Default for LeafNode<K, V>

where K: Clone + Ord + Debug, V: Clone + Debug,

fn default() -> Self

Returns the “default value” for a type.