Struct codd::expression::View

pub struct View<T, E> where
    T: Tuple,
    E: Expression<T>,  { /* fields omitted */ }

Represents a view in the database.

Example:

use codd::{Database, expression::{Product, View}};

let mut db = Database::new();
let dividends = db.add_relation("dividends").unwrap();
let divisors = db.add_relation("divisors").unwrap();

db.insert(&dividends, vec![6, 12, 18].into()).unwrap();
db.insert(&divisors, vec![2, 3].into()).unwrap();

// divide all elements of `dividends` by all elements of `divisors`:
let quotients = Product::new(
    dividends.clone(),
    divisors.clone(),
    |&l, &r| l/r
);
let view = db.store_view(quotients.clone()).unwrap();

// `view` and `quotients` evaluate to the same result:
assert_eq!(vec![2, 3, 4, 6, 9], db.evaluate(&quotients).unwrap().into_tuples());
assert_eq!(vec![2, 3, 4, 6, 9], db.evaluate(&view).unwrap().into_tuples());

db.insert(&dividends, vec![24, 30].into());
db.insert(&divisors, vec![1].into());

// the view gets updated automatically:
assert_eq!(
   vec![2, 3, 4, 6, 8, 9, 10, 12, 15, 18, 24, 30],
   db.evaluate(&view).unwrap().into_tuples()
);

use codd::expression::Difference;
// incremental view update for `Difference` is currently not supported:
assert!(db.store_view(Difference::new(dividends, divisors)).is_err());

Trait Implementations

impl<T: Clone, E: Clone> Clone for View<T, E> where
    T: Tuple,
    E: Expression<T>, 

fn clone(&self) -> View<T, E>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug, E: Debug> Debug for View<T, E> where
    T: Tuple,
    E: Expression<T>, 

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

Formats the value using the given formatter.

impl<T: Eq, E: Eq> Eq for View<T, E> where
    T: Tuple,
    E: Expression<T>, 

impl<T, E> Expression<T> for View<T, E> where
    T: Tuple + 'static,
    E: Expression<T> + 'static, 

fn visit<V>(&self, visitor: &mut V) where
    V: Visitor, 

Visits this expression by a Visitor.

fn builder(&self) -> Builder<T, Self>

Returns an expression builder over this expression.

impl<T: Tuple> From<View<T, Mono<T>>> for Mono<T>

fn from(view: View<T, Mono<T>>) -> Self

Performs the conversion.

impl<T: PartialEq, E: PartialEq> PartialEq<View<T, E>> for View<T, E> where
    T: Tuple,
    E: Expression<T>, 

fn eq(&self, other: &View<T, E>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &View<T, E>) -> bool

This method tests for !=.

impl<T, E> StructuralEq for View<T, E> where
    T: Tuple,
    E: Expression<T>, 

impl<T, E> StructuralPartialEq for View<T, E> where
    T: Tuple,
    E: Expression<T>,