Struct codd::expression::Product

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

Corresponds to the cartesian product of two expression.

Example:

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

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 prod = Product::new(&r, &s, |l, r| l*r);

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

Implementations

impl<L, R, Left, Right, T> Product<L, R, Left, Right, T> where
    L: Tuple,
    R: Tuple,
    T: Tuple,
    Left: Expression<L>,
    Right: Expression<R>, 

pub fn new<IL, IR>(
    left: IL,
    right: IR,
    project: impl FnMut(&L, &R) -> T + 'static
) -> Self where
    IL: IntoExpression<L, Left>,
    IR: IntoExpression<R, Right>, 

Creates a Product expression over left and right with mapper as the closure that produces the tuples of the resulting expression from tuples of left and right.

pub fn left(&self) -> &Left

Returns a reference to the left sub-expression.

pub fn right(&self) -> &Right

Returns a reference to the right sub-expression.

pub fn mapper_mut(&self) -> RefMut<'_, dyn FnMut(&L, &R) -> T>

Returns a mutable reference (of type std::cell::RefMut) to the mapping closure.

Trait Implementations

impl<L: Clone, R: Clone, Left: Clone, Right: Clone, T: Clone> Clone for Product<L, R, Left, Right, T> where
    L: Tuple,
    R: Tuple,
    T: Tuple,
    Left: Expression<L>,
    Right: Expression<R>, 

fn clone(&self) -> Product<L, R, Left, Right, T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<L, R, Left, Right, T> Debug for Product<L, R, Left, Right, T> where
    L: Tuple,
    R: Tuple,
    T: Tuple,
    Left: Expression<L>,
    Right: Expression<R>, 

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

Formats the value using the given formatter.

impl<L, R, Left, Right, T> Expression<T> for Product<L, R, Left, Right, T> where
    L: Tuple,
    R: Tuple,
    T: Tuple,
    Left: Expression<L>,
    Right: Expression<R>, 

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

fn from(product: Product<T, T, Mono<T>, Mono<T>, T>) -> Self

Performs the conversion.