Struct BackendFrontier 

pub struct BackendFrontier<B, T> { /* private fields */ }

A backend whose inputs are read as of since: every time the inner backend draws is advanced by it, and what then coincides is consolidated.

Only reads are translated. Outputs are the inner backend’s, at the operator’s times, which are beyond since once its inputs are. An empty since reads the inputs as they are.

Implementations

impl<B, T> BackendFrontier<B, T>

pub fn new(inner: B, since: Antichain<T>) -> Self

Read inner‘s inputs as of since, which must be beyond every frontier the inputs’ traces have compacted by (see the module documentation).

pub fn since(&self) -> &Antichain<T>

The frontier the inputs are read as of.

pub fn inner(&self) -> &B

The wrapped backend.

pub fn inner_mut(&mut self) -> &mut B

The wrapped backend, mutably: a wrapper implementing a backend trait defined outside this crate, such as dogs3’s half-join backend, drives the inner backend through this.

Trait Implementations

impl<T, B0, B1, B> ProxyJoinBackend<T, B0, B1> for BackendFrontier<B, T>

where T: Timestamp + Lattice, B: ProxyJoinBackend<T, B0, B1>,

type Key = <B as ProxyJoinBackend<T, B0, B1>>::Key

Independent groups, common to both inputs.

type V0 = <B as ProxyJoinBackend<T, B0, B1>>::V0

First input value proxies, valid throughout a block.

type V1 = <B as ProxyJoinBackend<T, B0, B1>>::V1

Second input value proxies, valid throughout a block.

type R0 = <B as ProxyJoinBackend<T, B0, B1>>::R0

Diff type of the first input.

type R1 = <B as ProxyJoinBackend<T, B0, B1>>::R1

Diff type of the second input.

type ROut = <B as ProxyJoinBackend<T, B0, B1>>::ROut

Diff type of matched records (R0 * R1), computed by the harness.

type Output = <B as ProxyJoinBackend<T, B0, B1>>::Output

The output container built from matched value ids.

fn advance( &mut self, instance: &JoinInstance<T, B0, B1>, from: &mut KeyPosition<Self::Key>, bridge0: &mut ProxyBridge<T, Self::R0, Self::Key, Self::V0>, bridge1: &mut ProxyBridge<T, Self::R1, Self::Key, Self::V1>, )

Populates the two bridges with all updates for all keys that match in a returned range.

fn cross( &mut self, instance: &JoinInstance<T, B0, B1>, matches: &mut JoinMatches<T, Self::ROut, Self::Key, Self::V0, Self::V1>, output: &mut Vec<Self::Output>, )

Interpret matches derived from the immediately preceding Self::advance call and place them in output. The iterator calls cross before another advance, so a backend may keep block-local interpretation state between the two calls. cross may be skipped when the block produced no matches, in which case the next advance may overwrite that state.

impl<T, B1, B2, B> ProxyReduceBackend<T, B1, B2> for BackendFrontier<B, T>

where T: Timestamp + Lattice, B: ProxyReduceBackend<T, B1, B2>,

type Key = <B as ProxyReduceBackend<T, B1, B2>>::Key

Independent groups, with identities stable across retires.

type VIn = <B as ProxyReduceBackend<T, B1, B2>>::VIn

Input value proxies, valid throughout a window.

type VOut = <B as ProxyReduceBackend<T, B1, B2>>::VOut

Output value proxies, including newly produced values, valid throughout a window.

type RIn = <B as ProxyReduceBackend<T, B1, B2>>::RIn

Diff type presented for the input.

type ROut = <B as ProxyReduceBackend<T, B1, B2>>::ROut

Diff type of the output.

fn begin(&mut self, description: Description<T>)

Initiate a session to create batches for these descriptions, which span [lower, upper).

fn next_window( &mut self, instance: &ReduceInstance<'_, T, B1, B2>, changed: &[Self::Key], from: &mut KeyPosition<Self::Key>, window: &mut ReduceWindow<T, Self::RIn, Self::ROut, Self::Key, Self::VIn, Self::VOut>, )

Present the next window of the key space, and advance from past it.

fn reduce_corrections( &mut self, keys: &[Self::Key], in_ends: &[usize], input: &[(Self::VIn, Self::RIn)], out_ends: &[usize], output: &[(Self::VOut, Self::ROut)], ) -> (Vec<(Self::VOut, Self::ROut)>, Vec<usize>)

A wave of input-output reconciliation, in which the backend supplies necessary edits.

fn emit(&mut self, records: &[((Self::Key, Self::VOut), T, Self::ROut)])

Commit a collection of updates to the batch in progress.

fn finish(&mut self) -> Option<B2>

Complete the session matching begin, yielding the batch it described, or None when the span it described carries no updates.