Enum mz_compute::render::context::ArrangementFlavor

pub enum ArrangementFlavor<S: Scope, T = Timestamp>
where
    T: Timestamp + Lattice + Columnation,
    S::Timestamp: Lattice + Refines<T> + Columnation,
{
    Local(MzArrangement<S>, Arranged<S, TraceAgent<Spine<Rc<OrdKeyBatch<MzStack<((DataflowError, ()), <S as ScopeParent>::Timestamp, Diff)>>>>>>),
    Trace(GlobalId, MzArrangementImport<S, T>, Arranged<S, TraceEnter<TraceFrontier<TraceAgent<Spine<Rc<OrdKeyBatch<MzStack<((DataflowError, ()), T, Diff)>>>>>>, <S as ScopeParent>::Timestamp>>),
}

Describes flavor of arrangement: local or imported trace.

Variants

Local(MzArrangement<S>, Arranged<S, TraceAgent<Spine<Rc<OrdKeyBatch<MzStack<((DataflowError, ()), <S as ScopeParent>::Timestamp, Diff)>>>>>>)

A dataflow-local arrangement.

Trace(GlobalId, MzArrangementImport<S, T>, Arranged<S, TraceEnter<TraceFrontier<TraceAgent<Spine<Rc<OrdKeyBatch<MzStack<((DataflowError, ()), T, Diff)>>>>>>, <S as ScopeParent>::Timestamp>>)

An imported trace from outside the dataflow.

The GlobalId identifier exists so that exports of this same trace can refer back to and depend on the original instance.

Implementations

impl<S: Scope, T> ArrangementFlavor<S, T>

where T: Timestamp + Lattice + Columnation, S::Timestamp: Lattice + Refines<T> + Columnation,

pub fn as_collection( &self, ) -> (Collection<S, Row, Diff>, Collection<S, DataflowError, Diff>)

Presents self as a stream of updates.

This method presents the contents as they are, without further computation. If you have logic that could be applied to each record, consider using the flat_map methods which allows this and can reduce the work done.

pub fn flat_map<D, I, C, L>( &self, key: Option<Row>, constructor: C, ) -> (Stream<S, I::Item>, Collection<S, DataflowError, Diff>)

where I: IntoIterator<Item = (D, S::Timestamp, Diff)>, D: Data, C: FnOnce() -> L, L: for<'a, 'b> FnMut(&'a mut DatumVecBorrow<'b>, &'a S::Timestamp, &'a Diff) -> I + 'static,

Constructs and applies logic to elements of self and returns the results.

constructor takes a permutation and produces the logic to apply on elements. The logic conceptually receives (&Row, &Row) pairs in the form of a slice. Only after borrowing the elements and applying the permutation the datums will be in the expected order.

If key is set, this is a promise that logic will produce no results on records for which the key does not evaluate to the value. This is used to leap directly to exactly those records.

impl<S: Scope, T> ArrangementFlavor<S, T>

where T: Timestamp + Lattice + Columnation, S::Timestamp: Lattice + Refines<T> + Columnation,

pub fn scope(&self) -> S

The scope containing the collection bundle.

pub fn enter_region<'a>( &self, region: &Child<'a, S, S::Timestamp>, ) -> ArrangementFlavor<Child<'a, S, S::Timestamp>, T>

Brings the arrangement flavor into a region.

impl<'a, S: Scope, T> ArrangementFlavor<Child<'a, S, S::Timestamp>, T>

where T: Timestamp + Lattice + Columnation, S::Timestamp: Lattice + Refines<T> + Columnation,

pub fn leave_region(&self) -> ArrangementFlavor<S, T>

Extracts the arrangement flavor from a region.

Trait Implementations

impl<S: Clone + Scope, T> Clone for ArrangementFlavor<S, T>

where T: Timestamp + Lattice + Columnation + Clone, S::Timestamp: Lattice + Refines<T> + Columnation,

fn clone(&self) -> ArrangementFlavor<S, T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.