Struct IndexStats 

#[non_exhaustive]
pub struct IndexStats {
    pub entries: u64,
    pub approx_bytes: u64,
    pub coerce_failures: u64,
    pub duplicates: u64,
}

Sizing + health counters (IDX.LIST / memory formula).

use kevy_index::{Segment, SegmentStats};
let s = Segment::new().stats();
assert_eq!((s.entries, s.duplicates), (0, SegmentStats::default().duplicates));

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

entries: u64

Live entries.

let mut s = Segment::new();
s.apply(b"a", None, Some(IndexValue::I64(1)));
s.apply(b"a", Some(&IndexValue::I64(1)), Some(IndexValue::I64(2)));
assert_eq!(s.stats().entries, 1, "a key holds one entry");

approx_bytes: u64

Approximate heap bytes (the measured side of the documented memory formula).

let mut s = Segment::new();
s.apply(b"a", None, Some(IndexValue::Str(vec![b'x'; 1000])));
assert!(s.stats().approx_bytes >= 1000);

coerce_failures: u64

Rows excluded because the field failed coercion / was missing.

let mut s = Segment::new();
s.apply(b"a", None, IndexValue::coerce(ValType::I64, b"not a number"));
assert_eq!(s.stats().coerce_failures, 1);

duplicates: u64

Values currently held by more than one key (unique fence).

let mut s = Segment::new();
s.apply(b"a", None, Some(IndexValue::I64(7)));
s.apply(b"b", None, Some(IndexValue::I64(7)));
assert_eq!(s.stats().duplicates, 1);

Trait Implementations

impl Clone for SegmentStats

fn clone(&self) -> SegmentStats

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for SegmentStats

impl Debug for SegmentStats

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

Formats the value using the given formatter.

impl Default for SegmentStats

fn default() -> SegmentStats

Returns the “default value” for a type.

impl Eq for SegmentStats

impl Hash for SegmentStats

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for SegmentStats

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for SegmentStats