Struct structsy::Snapshot

source ·

pub struct Snapshot { /* private fields */ }

Expand description

Read data from a snapshot freezed in a specific moment ignoring all the subsequent committed transactions.

Implementations§

source §

impl Snapshot

source

pub fn read<T: Persistent>(&self, sref: &Ref<T>) -> SRes<Option<T>>

Read a persistent instance.

Example

use structsy::{Structsy,StructsyTx};
use structsy_derive::Persistent;
#[derive(Persistent)]
struct Example {
    value:u8,
}
//.. open structsy etc.
let mut tx = structsy.begin()?;
let id = tx.insert(&Example{value:10})?;
tx.commit()?;
let snapshot = structsy.snapshot()?;
let read = snapshot.read(&id)?;
assert_eq!(10,read.unwrap().value);

source

pub fn scan<T: Persistent>(&self) -> SRes<SnapshotRecordIter<T>>

Scan records of a specific struct.

Example

use structsy::Structsy;
use structsy_derive::Persistent;
#[derive(Persistent)]
struct Simple {
    name:String,
}
let stry = Structsy::open("path/to/file.stry")?;
stry.define::<Simple>()?;
let snapshot = stry.snapshot()?;
for (id, inst) in snapshot.scan::<Simple>()? {
    // logic here
}

source

pub fn fetch<R: Fetch<T>, T>(&self, filter: R) -> StructsyIter<'_, T> ⓘ

Execute a filter query and return an iterator of results for the current snapshot

Example

use structsy::{ Structsy, StructsyTx, StructsyError, Filter};
use structsy_derive::{queries, embedded_queries, Persistent, PersistentEmbedded};

#[derive(Persistent)]
struct WithEmbedded {
    embedded: Embedded,
}

#[derive(PersistentEmbedded)]
struct Embedded {
    name: String,
}
impl WithEmbedded {
    fn new(name: &str) -> WithEmbedded {
        WithEmbedded {
            embedded: Embedded { name: name.to_string() },
        }
    }
}

#[queries(WithEmbedded)]
trait WithEmbeddedQuery {
    fn embedded(self, embedded: Filter<Embedded>) -> Self;
}

#[embedded_queries(Embedded)]
trait EmbeddedQuery {
    fn by_name(self, name: String) -> Self;
}

fn embedded_query() -> Result<(), StructsyError> {
    let structsy = Structsy::open("file.structsy")?;
    structsy.define::<WithEmbedded>()?;
    let mut tx = structsy.begin()?;
    tx.insert(&WithEmbedded::new("aaa"))?;
    tx.commit()?;
    let snapshot = structsy.snapshot()?;
    let embedded_filter = Filter::<Embedded>::new().by_name("aaa".to_string());
    let filter = Filter::<WithEmbedded>::new().embedded(embedded_filter);
    let count = snapshot.fetch(filter).count();
    assert_eq!(count, 1);
    Ok(())
}

source

pub fn query<T: Persistent + 'static>(&self) -> SnapshotQuery<T>

Query for a persistent struct in the snapshot

Example

use structsy::{ Structsy, StructsyTx, StructsyError};
use structsy_derive::{queries, Persistent};
#[derive(Persistent)]
struct Basic {
    name: String,
}
impl Basic {
    fn new(name: &str) -> Basic {
        Basic { name: name.to_string() }
    }
}

#[queries(Basic)]
trait BasicQuery {
     fn by_name(self, name: String) -> Self;
}

fn basic_query() -> Result<(), StructsyError> {
    let structsy = Structsy::open("file.structsy")?;
    structsy.define::<Basic>()?;
    let mut tx = structsy.begin()?;
    tx.insert(&Basic::new("aaa"))?;
    tx.commit()?;
    let snapshot = structsy.snapshot()?;
    let count = snapshot.query::<Basic>().by_name("aaa".to_string()).fetch().count();
    assert_eq!(count, 1);
    Ok(())
}