Struct mz_compute::render::join::mz_join_core::Deferred

struct Deferred<T, C1, C2, D>
where
    T: Timestamp,
    C1: Cursor<Time = T, Diff = Diff>,
    C2: for<'a> Cursor<Key<'a> = C1::Key<'a>, Time = T, Diff = Diff>,
{
    cursor1: C1,
    storage1: C1::Storage,
    cursor2: C2,
    storage2: C2::Storage,
    capability: Capability<T>,
    done: bool,
    temp: Vec<(D, T, Diff)>,
}

Deferred join computation.

The structure wraps cursors which allow us to play out join computation at whatever rate we like. This allows us to avoid producing and buffering massive amounts of data, without giving the timely dataflow system a chance to run operators that can consume and aggregate the data.

Fields

cursor1: C1

storage1: C1::Storage

cursor2: C2

storage2: C2::Storage

capability: Capability<T>

done: bool

temp: Vec<(D, T, Diff)>

Implementations

impl<T, C1, C2, D> Deferred<T, C1, C2, D>

where T: Timestamp + Lattice, C1: Cursor<Time = T, Diff = Diff>, C2: for<'a> Cursor<Key<'a> = C1::Key<'a>, Time = T, Diff = Diff>, D: Data,

fn new( cursor1: C1, storage1: C1::Storage, cursor2: C2, storage2: C2::Storage, capability: Capability<T>, ) -> Self

fn work_remains(&self) -> bool

fn work<L, I, YFn, C>( &mut self, output: &mut OutputHandleCore<'_, T, CapacityContainerBuilder<C>, Tee<T, C>>, logic: L, yield_fn: YFn, work: &mut usize, )

where I: IntoIterator<Item = D>, L: FnMut(C1::Key<'_>, C1::Val<'_>, C2::Val<'_>) -> I, YFn: Fn(usize) -> bool, C: SizableContainer + PushInto<(D, T, Diff)> + Data,

Process keys until at least fuel output tuples produced, or the work is exhausted.