Struct structsy::Filter

pub struct Filter<T> { /* private fields */ }

Generic filter for any Persistent structures

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 main() -> Result<(), StructsyError> {
    let structsy = Structsy::memory()?;
    structsy.define::<WithEmbedded>()?;
    let mut tx = structsy.begin()?;
    tx.insert(&WithEmbedded::new("aaa"))?;
    tx.commit()?;
    let embedded_filter = Filter::<Embedded>::new().by_name("aaa".to_string());
    let query = Filter::<WithEmbedded>::new().embedded(embedded_filter);
    assert_eq!(structsy.fetch(query).count(), 1);
    Ok(())
}

Implementations

impl<T> Filter<T>

pub fn new() -> Self

impl<T: Persistent> Filter<T>

pub fn projection<P: Projection<T>>(self) -> ProjectionResult<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 =
    Filter::<Person>::new().by_name("a_name").projection::<NameProjection>();
    assert_eq!(structsy.fetch(query).next().unwrap().name, "a_name");
    Ok(())
}

Trait Implementations

impl<T> Default for Filter<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T: EmbeddedDescription + 'static> EmbeddedQuery<T> for Filter<T>

fn filter_builder(&mut self) -> &mut FilterBuilder<T>

fn add_group(&mut self, filter: Filter<T>)

impl<T: Persistent + 'static> Fetch<(Ref<T>, T)> for Filter<T>

fn into(self, structsy: &Structsy) -> StructsyIter<'_, (Ref<T>, T)>

👎Deprecated

fn into_tx(self, tx: &mut OwnedSytx) -> StructsyIter<'_, (Ref<T>, T)>

👎Deprecated

fn fetch(self, structsy: &Structsy) -> StructsyIter<'_, (Ref<T>, T)>

fn fetch_tx(self, tx: &mut OwnedSytx) -> StructsyIter<'_, (Ref<T>, T)>

fn fetch_snapshot(self, snapshot: &Snapshot) -> StructsyIter<'_, (Ref<T>, T)>

impl<T: Persistent + 'static> Query<T> for Filter<T>

fn filter_builder(&mut self) -> &mut FilterBuilder<T>

fn add_group(&mut self, filter: Filter<T>)

impl<T, V> QueryAction<Filter<V>> for (Field<T, Option<Ref<V>>>, &mut FilterBuilder<T>)where T: 'static, V: Persistent + 'static,

fn query(self, value: Filter<V>)

impl<T, V> QueryAction<Filter<V>> for (Field<T, Ref<V>>, &mut FilterBuilder<T>)where T: 'static, V: Persistent + 'static,

fn query(self, value: Filter<V>)

impl<T, V> QueryAction<Filter<V>> for (Field<T, V>, &mut FilterBuilder<T>)where T: 'static, V: EmbeddedDescription + 'static,

fn query(self, value: Filter<V>)

impl<T, V> QueryAction<Filter<V>> for (Field<T, Vec<Ref<V>>>, &mut FilterBuilder<T>)where T: 'static, V: Persistent + 'static,

fn query(self, value: Filter<V>)

impl<T: Persistent + 'static> IntoResult<(Ref<T>, T)> for Filter<T>