Struct StatsDiff

Source

pub struct StatsDiff {Show 24 fields
    pub num_nodes_diff: i64,
    pub num_leaves_diff: i64,
    pub num_internal_nodes_diff: i64,
    pub tree_height_diff: i8,
    pub total_key_value_pairs_diff: i64,
    pub total_tree_size_bytes_diff: i64,
    pub avg_node_size_bytes_diff: f64,
    pub min_node_size_bytes_diff: i64,
    pub max_node_size_bytes_diff: i64,
    pub avg_entries_per_node_diff: f64,
    pub avg_fanout_diff: f64,
    pub min_fanout_diff: i64,
    pub max_fanout_diff: i64,
    pub avg_fill_factor_diff: f64,
    pub avg_leaf_fill_factor_diff: f64,
    pub avg_internal_fill_factor_diff: f64,
    pub avg_key_size_bytes_diff: f64,
    pub avg_value_size_bytes_diff: f64,
    pub min_key_size_bytes_diff: i64,
    pub max_key_size_bytes_diff: i64,
    pub min_value_size_bytes_diff: i64,
    pub max_value_size_bytes_diff: i64,
    pub total_keys_size_bytes_diff: i64,
    pub total_values_size_bytes_diff: i64,
}

Expand description

Difference between two statistics objects

Contains the absolute difference for each numeric metric between two TreeStats objects. Positive values indicate an increase, negative values indicate a decrease.

Created by calling TreeStats::diff.

§Example

use prolly::{Config, MemStore, Prolly};

let store = MemStore::new();
let prolly = Prolly::new(store, Config::default());

let tree1 = prolly.create();
let stats1 = prolly.collect_stats(&tree1).unwrap();

let mut tree2 = tree1.clone();
tree2 = prolly.put(&tree2, b"key".to_vec(), b"value".to_vec()).unwrap();
let stats2 = prolly.collect_stats(&tree2).unwrap();

let diff = stats2.diff(&stats1);
assert!(diff.num_nodes_diff > 0); // Tree grew
assert!(diff.total_key_value_pairs_diff > 0); // Added entries

Fields§

§num_nodes_diff: i64§num_leaves_diff: i64§num_internal_nodes_diff: i64§tree_height_diff: i8§total_key_value_pairs_diff: i64§total_tree_size_bytes_diff: i64§avg_node_size_bytes_diff: f64§min_node_size_bytes_diff: i64§max_node_size_bytes_diff: i64§avg_entries_per_node_diff: f64§avg_fanout_diff: f64§min_fanout_diff: i64§max_fanout_diff: i64§avg_fill_factor_diff: f64§avg_leaf_fill_factor_diff: f64§avg_internal_fill_factor_diff: f64§avg_key_size_bytes_diff: f64§avg_value_size_bytes_diff: f64§min_key_size_bytes_diff: i64§max_key_size_bytes_diff: i64§min_value_size_bytes_diff: i64§max_value_size_bytes_diff: i64§total_keys_size_bytes_diff: i64§total_values_size_bytes_diff: i64

Struct StatsDiff Copy item path

§Example

Fields§

Trait Implementations§

impl Clone for StatsDiff

fn clone(&self) -> StatsDiff

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

impl Debug for StatsDiff

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

impl<'de> Deserialize<'de> for StatsDiff

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where __D: Deserializer<'de>,

impl PartialEq for StatsDiff

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

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

impl Serialize for StatsDiff

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where __S: Serializer,

impl StructuralPartialEq for StatsDiff

Auto Trait Implementations§

impl Freeze for StatsDiff

impl RefUnwindSafe for StatsDiff

impl Send for StatsDiff

impl Sync for StatsDiff

impl Unpin for StatsDiff

impl UnsafeUnpin for StatsDiff

impl UnwindSafe for StatsDiff

Blanket Implementations§

impl<T> Any for Twhere T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for Twhere T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for Twhere T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

impl<T> CloneToUninit for Twhere T: Clone,

unsafe fn clone_to_uninit(&self, dest: *mut u8)

impl<T> DeserializeOwned for Twhere T: for<'de> Deserialize<'de>,

impl<T> From<T> for T

fn from(t: T) -> T

impl<T, U> Into<U> for Twhere U: From<T>,

fn into(self) -> U

impl<T> IntoEither for T

fn into_either(self, into_left: bool) -> Either<Self, Self>

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>where F: FnOnce(&Self) -> bool,

impl<T> Pointable for T

const ALIGN: usize

type Init = T

unsafe fn init(init: <T as Pointable>::Init) -> usize

unsafe fn deref<'a>(ptr: usize) -> &'a T

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

unsafe fn drop(ptr: usize)

impl<T> Same for T

type Output = T

impl<T> ToOwned for Twhere T: Clone,

type Owned = T

fn to_owned(&self) -> T

fn clone_into(&self, target: &mut T)

impl<T, U> TryFrom<U> for Twhere U: Into<T>,

type Error = Infallible

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Struct StatsDiff

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where __D: Deserializer<'de>,

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where S: Serializer,

impl<T> Any for T
where T: 'static + ?Sized,

impl<T> Borrow<T> for T
where T: ?Sized,

impl<T> BorrowMut<T> for T
where T: ?Sized,

impl<T> CloneToUninit for T
where T: Clone,

impl<T> DeserializeOwned for T
where T: for<'de> Deserialize<'de>,

impl<T, U> Into<U> for T
where U: From<T>,

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

impl<T> ToOwned for T
where T: Clone,

impl<T, U> TryFrom<U> for T
where U: Into<T>,

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,