Struct codd::expression::Intersect

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

Evaluates to all tuples that are in its both left and right sub-expressions.

Example:

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

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 intersect = Intersect::new(&r, &s);

assert_eq!(vec![2], db.evaluate(&intersect).unwrap().into_tuples());

Implementations

impl<T, L, R> Intersect<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 Intersect for 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 Intersect<T, L, R> where
    T: Tuple,
    L: Expression<T>,
    R: Expression<T>, 

fn clone(&self) -> Intersect<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 Intersect<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 Intersect<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<Intersect<T, Mono<T>, Mono<T>>> for Mono<T>

fn from(intersect: Intersect<T, Mono<T>, Mono<T>>) -> Self

Performs the conversion.