Struct Difference

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

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, L, R> Clone for Difference<T, L, R>

where T: Tuple + Clone, L: Expression<T> + Clone, R: Expression<T> + Clone,

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, L, R> Debug for Difference<T, L, R>

where T: Tuple + Debug, L: Expression<T> + Debug, R: Expression<T> + Debug,

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

Converts to this type from the input type.