Trait differential_dataflow::trace::Trace

pub trait Trace: TraceReader where
    Self::Batch: Batch<Self::Key, Self::Val, Self::Time, Self::R>, {
    fn new(
        info: OperatorInfo, 
        logging: Option<Logger>, 
        activator: Option<Activator>
    ) -> Self;
    fn exert(&mut self, effort: &mut isize);
    fn insert(&mut self, batch: Self::Batch);
    fn close(&mut self);
}

An append-only collection of (key, val, time, diff) tuples.

The trace must pretend to look like a collection of (Key, Val, Time, isize) tuples, but is permitted to introduce new types KeyRef, ValRef, and TimeRef which can be dereference to the types above.

The trace must be constructable from, and navigable by the Key, Val, Time types, but does not need to return them.

Required methods

fn new(
    info: OperatorInfo,
    logging: Option<Logger>,
    activator: Option<Activator>
) -> Self

Allocates a new empty trace.

fn exert(&mut self, effort: &mut isize)

Exert merge effort, even without updates.

fn insert(&mut self, batch: Self::Batch)

Introduces a batch of updates to the trace.

Batches describe the time intervals they contain, and they should be added to the trace in contiguous intervals. If a batch arrives with a lower bound that does not equal the upper bound of the most recent addition, the trace will add an empty batch. It is an error to then try to populate that region of time.

This restriction could be relaxed, especially if we discover ways in which batch interval order could commute. For now, the trace should complain, to the extent that it cares about contiguous intervals.

fn close(&mut self)

Introduces an empty batch concluding the trace.

This method should be logically equivalent to introducing an empty batch whose lower frontier equals the upper frontier of the most recently introduced batch, and whose upper frontier is empty.

Loading content...

Implementors

impl<K, V, T, R, B> Trace for Spine<K, V, T, R, B> where
    K: Ord + Clone,
    V: Ord + Clone,
    T: Lattice + Timestamp + Ord + Clone + Debug,
    R: Semigroup,
    B: Batch<K, V, T, R> + Clone + 'static, 

fn new(
    info: OperatorInfo,
    logging: Option<Logger>,
    activator: Option<Activator>
) -> Self

fn exert(&mut self, effort: &mut isize)

Apply some amount of effort to trace maintenance.

The units of effort are updates, and the method should be thought of as analogous to inserting as many empty updates, where the trace is permitted to perform proportionate work.

fn insert(&mut self, batch: Self::Batch)

fn close(&mut self)

Completes the trace with a final empty batch.

Loading content...