Struct RewriteStats 

#[non_exhaustive]
pub struct RewriteStats {
    pub keys: u64,
    pub bytes: u64,
}

Result of an Aof::rewrite_from call. Surfaced by BGREWRITEAOF / INFO persistence. The default is the empty rewrite (no keys, no bytes), the starting point for summing several shards’ stats.

use kevy_persist::{Aof, Fsync, RewriteStats};

let dir = kevy_tmpdir::unique_dir("stats-doc");
let mut total = RewriteStats::default();
for shard in 0..2 {
    let mut aof = Aof::open(&kevy_persist::layout::aof_path(&dir, shard), Fsync::No)?;
    let stats = aof.rewrite_from(&kevy_store::Store::new())?;
    (total.keys, total.bytes) = (total.keys + stats.keys, total.bytes + stats.bytes);
}
assert_eq!(total.keys, 0);
// an empty image is its header alone
let empty = kevy_persist::estimate_rewrite_size(&kevy_store::Store::new());
assert_eq!(total.bytes, 2 * empty);

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.

keys: u64

Keys dumped into the new AOF.

use kevy_persist::{Aof, Argv, Fsync};
use kevy_store::{SetCondition, Store};

let path = std::env::temp_dir().join(format!("stats-keys-doc-{}.aof", std::process::id()));
let mut aof = Aof::open(&path, Fsync::No)?;
let mut store = Store::new();
for _ in 0..3 {
    // three writes to one key compact to one key
    store.set(b"k", b"v".to_vec(), None, SetCondition::Always);
    aof.append(&Argv::from(vec![b"SET".to_vec(), b"k".to_vec(), b"v".to_vec()]))?;
}
assert_eq!(aof.rewrite_from(&store)?.keys, 1);

bytes: u64

New AOF size in bytes.

use kevy_persist::{Aof, Fsync};

let path = std::env::temp_dir().join(format!("stats-bytes-doc-{}.aof", std::process::id()));
let mut aof = Aof::open(&path, Fsync::No)?;
let stats = aof.rewrite_from(&kevy_store::Store::new())?;
assert_eq!(stats.bytes, std::fs::metadata(&path)?.len());
assert_eq!(aof.size_bytes(), stats.bytes);

Trait Implementations

impl Clone for RewriteStats

fn clone(&self) -> RewriteStats

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for RewriteStats

impl Debug for RewriteStats

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

Formats the value using the given formatter.

impl Default for RewriteStats

fn default() -> RewriteStats

Returns the “default value” for a type.

impl Eq for RewriteStats

impl Hash for RewriteStats

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 RewriteStats

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for RewriteStats