Struct Union

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

Evaluates to the union of the tuples in its left and right sub-expressions.

Example:

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

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

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

Implementations

impl<T, L, R> Union<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 Union 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 Union<T, L, R>

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

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

fn from(union: Union<T, Mono<T>, Mono<T>>) -> Self

Converts to this type from the input type.