Struct StorageStats 

pub struct StorageStats {

    pub used_bytes: u64,
    pub capacity_bytes: Option<u64>,
    pub available_bytes: Option<u64>,
    pub compaction_possible: bool,
    pub full_compaction_bytes: u64,
    pub tight_compaction_bytes: u64,
    pub item_count: u64,
    pub table_count: u64,
    pub avg_entry_on_disk_bytes: u64,
    pub avg_key_bytes: Option<u64>,
    pub avg_value_bytes: Option<u64>,
    pub reclaimable_bytes_estimate: u64,
    pub status: StorageStatus,
}

A point-in-time snapshot of a tree’s on-disk storage footprint and the average shape of a stored entry.

All byte figures are on-disk (post-compression, including any per-block overhead and blob files). Averages are over every stored entry version, so they pair with Self::item_count.

Fields

used_bytes: u64

Total on-disk bytes of all live SSTs plus blob files: how much is occupied. Pairs with Self::capacity_bytes / Self::available_bytes for an “X of Y used” view in a single call.

capacity_bytes: Option<u64>

Total bytes the tree may occupy: the tighter of a configured byte quota (storage_limit_bytes) and the physical disk headroom (free space plus what is already used), across every volume the tree writes to. None when unbounded: no quota set AND the backend cannot report free space.

available_bytes: Option<u64>

Free room left before the tree turns read-only: capacity_bytes - used_bytes (saturating). None exactly when Self::capacity_bytes is None (unbounded).

compaction_possible: bool

Whether a compaction can still run given the remaining free space (it needs working room to write merged output). true when unbounded or when at least Self::tight_compaction_bytes of free space remains; false when the disk is too full for a compaction to make progress. The finer full-vs-tight distinction is carried by Self::status.

full_compaction_bytes: u64

Estimated free space (bytes) a FULL compaction needs for its transient output while the inputs still exist: the largest level’s on-disk size (an upper bound on a single merge’s input set). A full compaction has room when Self::available_bytes >= this. Pair with used_bytes / capacity_bytes to draw a capacity gauge: used → used + tight_compaction_bytes → used + full_compaction_bytes → capacity.

tight_compaction_bytes: u64

Estimated free space (bytes) a minimal (tight) space-reclaiming compaction needs to make forward progress: the reserved working floor. Tight compaction has room when Self::available_bytes >= this.

item_count: u64

Number of live entries (all versions) across all live SSTs.

table_count: u64

Number of live SSTs.

avg_entry_on_disk_bytes: u64

Average on-disk bytes per entry (used_bytes / item_count), or 0 when the tree is empty. This is the figure Self::estimated_remaining_entries divides a budget by.

avg_key_bytes: Option<u64>

Average user-key byte length per entry, or None if any live table was written before per-table key/value byte sums were recorded (the average key/value split is only exact when every table carries the figures).

avg_value_bytes: Option<u64>

Average value byte length per entry, or None under the same condition as Self::avg_key_bytes.

reclaimable_bytes_estimate: u64

Estimated bytes a full compaction could reclaim, from the weak-tombstone-reclaimable entry count times the average on-disk entry size. An estimate, not an exact figure.

status: StorageStatus

Coarse storage state.

Implementations

impl StorageStats

pub fn estimated_remaining_entries(&self, budget_bytes: u64) -> u64

Approximately how many more average-shaped entries fit in budget_bytes, using Self::avg_entry_on_disk_bytes.

Returns 0 when the average entry size is unknown (an empty tree), since there is no basis for the estimate.

Trait Implementations

impl Clone for StorageStats

fn clone(&self) -> StorageStats

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for StorageStats

impl Debug for StorageStats

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

Formats the value using the given formatter.

impl Eq for StorageStats

impl PartialEq for StorageStats

fn eq(&self, other: &StorageStats) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for StorageStats