Struct View

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

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, E> Clone for View<T, E>

where T: Tuple + Clone, E: Expression<T> + Clone,

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, E> Debug for View<T, E>

where T: Tuple + Debug, E: Expression<T> + Debug,

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

Formats the value using the given formatter.

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

Converts to this type from the input type.

impl<T, E> PartialEq for View<T, E>

where T: Tuple + PartialEq, E: Expression<T> + PartialEq,

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

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T, E> Eq for View<T, E>

where T: Tuple + Eq, E: Expression<T> + Eq,

impl<T, E> StructuralPartialEq for View<T, E>

where T: Tuple, E: Expression<T>,