Struct LockJoinQuery 

pub struct LockJoinQuery<'a, L, R, LL, LR>
where
    LL: LockValue<L> + 'a,
    LR: LockValue<R> + 'a,
{ /* private fields */ }

A join query builder for locked data structures.

Enables joining two collections of locked values.

Implementations

impl<'a, L, R, LL, LR> LockJoinQuery<'a, L, R, LL, LR>

where L: 'static, R: 'static, LL: LockValue<L> + 'a, LR: LockValue<R> + 'a,

pub fn new( left: Vec<&'a LL>, right: Vec<&'a LR>, ) -> LockJoinQuery<'a, L, R, LL, LR>

Create a new join query from two collections of locks.

pub fn inner_join<LK, RK, M, Out>( &self, left_key: KeyPaths<L, LK>, right_key: KeyPaths<R, RK>, mapper: M, ) -> Vec<Out>

where LK: Eq + Clone + 'static + PartialEq<RK>, RK: Eq + Clone + 'static, M: Fn(&L, &R) -> Out, L: Clone, R: Clone,

Perform an INNER JOIN.

Returns only pairs where keys match.

Example

let results = LockJoinQuery::new(&users, &orders)
    .inner_join(
        User::id(),
        Order::user_id(),
        |user, order| (user.name.clone(), order.total)
    );

pub fn left_join<LK, RK, M, Out>( &self, left_key: KeyPaths<L, LK>, right_key: KeyPaths<R, RK>, mapper: M, ) -> Vec<Out>

where LK: Eq + Clone + 'static + PartialEq<RK>, RK: Eq + Clone + 'static, M: Fn(&L, Option<&R>) -> Out, L: Clone, R: Clone,

Perform a LEFT JOIN.

Returns all left items with optional right matches.

Example

let results = LockJoinQuery::new(&users, &orders)
    .left_join(
        User::id(),
        Order::user_id(),
        |user, order_opt| match order_opt {
            Some(order) => format!("{} has order {}", user.name, order.id),
            None => format!("{} has no orders", user.name),
        }
    );

pub fn right_join<LK, RK, M, Out>( &self, left_key: KeyPaths<L, LK>, right_key: KeyPaths<R, RK>, mapper: M, ) -> Vec<Out>

where LK: Eq + Clone + 'static + PartialEq<RK>, RK: Eq + Clone + 'static, M: Fn(Option<&L>, &R) -> Out, L: Clone, R: Clone,

Perform a RIGHT JOIN.

Returns all right items with optional left matches.

pub fn cross_join<M, Out>(&self, mapper: M) -> Vec<Out>

where M: Fn(&L, &R) -> Out, L: Clone, R: Clone,

Perform a CROSS JOIN (Cartesian product).

Returns all combinations of left and right items.