Trait differential_dataflow::operators::join::JoinArranged

pub trait JoinArranged<G: Scope, K: Data, V: Data> where
    G::Timestamp: Lattice, {
    fn join<T2, R, RF>(
        &self, 
        stream2: &Arranged<G, T2>, 
        result: RF
    ) -> Collection<G, R>
    where
        T2: Trace<Key = K, Index = G::Timestamp> + 'static,
        R: Data,
        RF: Fn(&K, &V, &T2::Value) -> R + 'static,
        &'a T2: TraceRef<'a, T2::Key, T2::Index, T2::Value>;
}

Matches the elements of two arranged traces.

This method is used by the various join implementations, but it can also be used directly in the event that one has a handle to an Arranged<G,T>, perhaps because the arrangement is available for re-use, or from the output of a group operator.

Required Methods

fn join<T2, R, RF>(
    &self,
    stream2: &Arranged<G, T2>,
    result: RF
) -> Collection<G, R> where
    T2: Trace<Key = K, Index = G::Timestamp> + 'static,
    R: Data,
    RF: Fn(&K, &V, &T2::Value) -> R + 'static,
    &'a T2: TraceRef<'a, T2::Key, T2::Index, T2::Value>, 

Joins two arranged collections with the same key type.

Each matching pair of records (key, val1) and (key, val2) are subjected to the result function, producing a corresponding output record.

This trait is implemented for arrangements (Arranged<G, T>) rather than collections. The Join trait contains the implementations for collections.

Implementors

• impl<TS: Timestamp, G: Scope<Timestamp = TS>, T: Trace<Index = TS> + 'static> JoinArranged<G, T::Key, T::Value> for Arranged<G, T> where
    G::Timestamp: Lattice,
    &'a T: TraceRef<'a, T::Key, T::Index, T::Value>,