Struct structsy::StructsyQueryTx

source ·

pub struct StructsyQueryTx<'a, T: Persistent + 'static> { /* private fields */ }

Expand description

Query for a persistent struct considering in transaction changes.

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"))?;
    let count = tx.query::<Basic>().by_name("aaa".to_string()).fetch().count();
    assert_eq!(count, 1);
    tx.commit()?;
    Ok(())
}

Implementations§

source §

impl<'a, T: Persistent> StructsyQueryTx<'a, T>

source

pub fn projection<P: Projection<T>>(self) -> ProjectionQueryTx<'a, P, T>

Make a projection from filtered structs.

Example

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

#[derive(Persistent)]
struct Person {
    name:String,
    surname:String,
}

impl Person {
    fn new(name:&str, surname:&str) -> Self {
        Person {
            name: name.to_string(),
            surname: surname.to_string(),
        }
    }
}

#[queries(Person)]
trait PersonQuery {
    fn by_name(self, name:&str) -> Self;
}

#[derive(Projection)]
#[projection = "Person" ]
struct NameProjection {
    name:String,
}


fn main() -> Result<(), StructsyError> {
    let structsy = Structsy::memory()?;
    structsy.define::<Person>()?;
    let mut tx = structsy.begin()?;
    tx.insert(&Person::new("a_name", "a_surname"))?;
    tx.commit()?;
    let query = structsy.query::<Person>().by_name("a_name").projection::<NameProjection>();
    assert_eq!(query.fetch().next().unwrap().name, "a_name");
    Ok(())
}