Struct persy::Snapshot

pub struct Snapshot { /* fields omitted */ }

Read snapshot at a specific point in time.

All the changes from transactions committed at the specific point in time were the snapshot was create are readable from this snapshot, all subsequent transactions are ignored.

Copy of the data old data is kept on the disc, with indexing access from in memory structures, on drop of the Snapshot, if there are no older snapshot all the data old by this snapshot not existing anymore in the final state will be cleaned up.

Implementations

impl Snapshot

pub fn read_record(
    &self,
    segment: impl ToSegmentId,
    id: &PersyId
) -> PRes<Option<Vec<u8>>>

👎 Deprecated:

replaced by Snapshot::read

pub fn read(
    &self,
    segment: impl ToSegmentId,
    id: &PersyId
) -> PRes<Option<Vec<u8>>>

Read the record content at the point of time the snapshot was taken ignoring all following committed transactions

Example

let mut tx = persy.begin()?;
let data = vec![1;20];
let id = tx.insert("seg", &data)?;
tx.prepare()?.commit()?;
let snapshot = persy.snapshot()?;
let read = snapshot.read("seg", &id)?.expect("record exists");
assert_eq!(data,read);

pub fn scan(&self, segment: impl ToSegmentId) -> PRes<SnapshotSegmentIter>

Scan for records existing at the moment of snapshot creation, ignoring all the following committed transactions.

Example

let mut tx = persy.begin()?;
let data = vec![1;20];
let id = tx.insert("seg", &data)?;
tx.prepare()?.commit()?;
let snapshot = persy.snapshot()?;
let mut count = 0;
for (id,content) in snapshot.scan("seg")? {
    println!("record size:{}",content.len());
    count+=1;
}
assert_eq!(count,1);

pub fn get<K, V>(&self, index_name: &str, k: &K) -> PRes<Option<Value<V>>> where
    K: IndexType,
    V: IndexType, 

Get a value or a group of values from a key at the point the snapshot was taken ignoring all following committed transactions.

Example

tx.put::<u8,u8>("my_new_index",10,10)?;
tx.prepare()?.commit()?;
let snapshot = persy.snapshot()?;
let val = snapshot.get::<u8,u8>("my_new_index",&10)?;
if let Some(is_there) = val {
    // A value is actually there
    match is_there {
        Value::SINGLE(actual_value) => {
        },
        Value::CLUSTER(actual_value) => {
        },
    }
}

pub fn range<K, V, R>(
    &self,
    index_name: &str,
    range: R
) -> PRes<IndexIter<K, V>> where
    K: IndexType,
    V: IndexType,
    R: RangeBounds<K>, 

Browse a range of keys and values from an index at the pointing that the snapshot was created ignoring all the following committed transactions.

Example

let persy = Persy::open("./data.persy",Config::new())?;
let mut tx = persy.begin()?;
tx.put::<u8,u8>("my_new_index",10,10)?;
tx.prepare()?.commit()?;
let snapshot = persy.snapshot()?;
let iter:IndexIter<u8,u8> = snapshot.range("my_new_index",10..12)?;
for (k,val) in iter  {
    // A value is actually there
    match val {
        Value::SINGLE(actual_value) => {
        },
        Value::CLUSTER(actual_value) => {
        },
    }
}

pub fn list_segments(&self) -> PRes<Vec<(String, SegmentId)>>

List all the existing segments, at the pointing that the snapshot was created ignoring all the following committed transactions.

Example

let mut tx = persy.begin()?;
tx.create_segment("seg")?;
tx.prepare()?.commit()?;
let snapshot = persy.snapshot()?;
let segments = snapshot.list_segments()?;
let names = segments.into_iter().map(|(name,_id)|name).collect::<Vec<String>>();
assert!(names.contains(&"seg".to_string()));

pub fn list_indexes(&self) -> PRes<Vec<(String, IndexInfo)>>

List all the existing indexes, at the pointing that the snapshot was created ignoring all the following committed transactions.

Example

let mut tx = persy.begin()?;
tx.create_index::<u8, u8>("idx", ValueMode::REPLACE)?;
tx.prepare()?.commit()?;
let snapshot = persy.snapshot()?;
let indexes = snapshot.list_indexes()?;
let names = indexes.into_iter().map(|(name,_id)|name).collect::<Vec<String>>();
assert!(names.contains(&"idx".to_string()));

Trait Implementations

impl Clone for Snapshot

fn clone(&self) -> Snapshot

Returns a copy of the value.

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

Performs copy-assignment from source.