Struct codd::expression::Difference

pub struct Difference<T, L, R> where
    T: Tuple,
    L: Expression<T>,
    R: Expression<T>,  { /* fields omitted */ }

Evaluates to the tuples that are in its left but not in its right sub-expressions (left - right).

Example:

use codd::{Database, expression::Difference};

let mut db = Database::new();
let r = db.add_relation::<i32>("R").unwrap();
let s = db.add_relation::<i32>("S").unwrap();

db.insert(&r, vec![0, 1, 2].into());
db.insert(&s, vec![2, 4].into());

let r_s = Difference::new(&r, &s);
let s_r = Difference::new(&s, &r);

assert_eq!(vec![0, 1], db.evaluate(&r_s).unwrap().into_tuples());
assert_eq!(vec![4], db.evaluate(&s_r).unwrap().into_tuples());

Implementations

impl<T, L, R> Difference<T, L, R> where
    T: Tuple,
    L: Expression<T>,
    R: Expression<T>, 

pub fn new<IL, IR>(left: IL, right: IR) -> Self where
    IL: IntoExpression<T, L>,
    IR: IntoExpression<T, R>, 

Creates a new instance of Difference corresponding to left - right.

pub fn left(&self) -> &L

Returns a reference to the left sub-expression.

pub fn right(&self) -> &R

Returns a reference to the right sub-expression.

Trait Implementations

impl<T: Clone, L: Clone, R: Clone> Clone for Difference<T, L, R> where
    T: Tuple,
    L: Expression<T>,
    R: Expression<T>, 

fn clone(&self) -> Difference<T, L, R>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug, L: Debug, R: Debug> Debug for Difference<T, L, R> where
    T: Tuple,
    L: Expression<T>,
    R: Expression<T>, 

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

Formats the value using the given formatter.

impl<T, L, R> Expression<T> for Difference<T, L, R> where
    T: Tuple,
    L: Expression<T>,
    R: Expression<T>, 

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<Difference<T, Mono<T>, Mono<T>>> for Mono<T>

fn from(difference: Difference<T, Mono<T>, Mono<T>>) -> Self

Performs the conversion.