Struct codd::expression::Join

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

Represents the join of its left and right sub-expressions.

Example:

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

let mut db = Database::new();
let fruit = db.add_relation::<(i32, String)>("R").unwrap();
let numbers = db.add_relation::<i32>("S").unwrap();

db.insert(&fruit, vec![
   (0, "Apple".to_string()),
   (1, "Banana".to_string()),
   (2, "Cherry".to_string())
].into());
db.insert(&numbers, vec![0, 2].into());

let join = Join::new(
    &fruit,
    &numbers,
    |t| t.0,  // first element of tuples in `r` is the key for join
    |&t| t,   // the values in `s` are keys for join
    // make resulting values from key `k`, left value `l` and right value `r`:
    |k, l, r| format!("{}{}", l.1, k + r)
);

assert_eq!(vec!["Apple0", "Cherry4"], db.evaluate(&join).unwrap().into_tuples());

Implementations

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

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

Creates a new Join expression over left and right where left_key and right_key are closures that return the join key for tuples of left and right respectively. The closure mapper computes the tuples of the resulting expression from the join key and the 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.

Trait Implementations

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

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<K, L, R, Left, Right, T> Debug for Join<K, L, R, Left, Right, T> where
    K: Tuple,
    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<K, L, R, Left, Right, T> Expression<T> for Join<K, L, R, Left, Right, T> where
    K: Tuple,
    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<Join<T, T, T, Mono<T>, Mono<T>, T>> for Mono<T>

fn from(join: Join<T, T, T, Mono<T>, Mono<T>, T>) -> Self

Performs the conversion.