Struct Joiner

struct Joiner<'a, C1, C2, D, L>
where
    C1: Cursor,
    C2: Cursor,
{
    result_fn: Rc<RefCell<L>>,
    output: Rc<RefCell<Vec<(D, C1::Time, Diff)>>>,
    produced: Rc<Cell<usize>>,
    meet: C1::Time,
    history1: ValueHistory<'a, C1>,
    history2: ValueHistory<'a, C2>,
}

Type that knows how to perform the core join logic.

The joiner implements two join strategies:

• The “simple” strategy produces a match for each combination of (val1, time1, val2, time2) found in the inputs. If there are multiple times in the input, it may produce matches for times in which one of the values wasn’t present. These matches cancel each other out, so the result ends up correct.
• The “linear scan over times” strategy sorts the input data by time and then steps through the input histories, producing matches for a pair of values only if both values where present at the same time.

The linear scan strategy avoids redundant work and is much more efficient than the simple strategy when many distinct times are present in the inputs. However, sorting the input data incurs some overhead, so we still prefer the simple variant when the input data is small.

Fields

result_fn: Rc<RefCell<L>>

A function that transforms raw join matches into join results.

output: Rc<RefCell<Vec<(D, C1::Time, Diff)>>>

A buffer holding the join results.

produced: Rc<Cell<usize>>

The number of join results produced.

meet: C1::Time

A time to which all join results should be advanced.

history1: ValueHistory<'a, C1>

Buffer for edit histories from the first input.

history2: ValueHistory<'a, C2>

Buffer for edit histories from the second input.

Implementations

impl<'a, C1, C2, D, L, I> Joiner<'a, C1, C2, D, L>

where C1: Cursor<Diff = Diff>, C2: Cursor<Key<'a> = C1::Key<'a>, Time = C1::Time, Diff = Diff>, D: Data, L: FnMut(C1::Key<'_>, C1::Val<'_>, C2::Val<'_>) -> I + 'static, I: IntoIterator<Item = D> + 'static,

fn new( result_fn: Rc<RefCell<L>>, output: Rc<RefCell<Vec<(D, C1::Time, Diff)>>>, produced: Rc<Cell<usize>>, meet: C1::Time, ) -> Self

async fn join_key( &mut self, key: C1::Key<'_>, cursor1: &mut C1, storage1: &'a C1::Storage, cursor2: &mut C2, storage2: &'a C2::Storage, )

Produce matches for the values of a single key.

fn join_key_simple(&self, key: C1::Key<'_>)

Produce matches for the values of a single key, using the simple strategy.

This strategy is only meant to be used for small inputs, so we don’t bother including yield points or optimizations.

async fn join_key_linear_time_scan(&mut self, key: C1::Key<'_>)

Produce matches for the values of a single key, using a linear scan through times.