[−][src]Trait differential_dataflow::trace::TraceReader

pub trait TraceReader {
    type Key;
    type Val;
    type Time;
    type R;
    type Batch: BatchReader<Self::Key, Self::Val, Self::Time, Self::R> + Clone + 'static;
    type Cursor: Cursor<Self::Key, Self::Val, Self::Time, Self::R>;
    fn cursor_through(
        &mut self, 
        upper: &[Self::Time]
    ) -> Option<(Self::Cursor, <Self::Cursor as Cursor<Self::Key, Self::Val, Self::Time, Self::R>>::Storage)>;

    fn advance_by(&mut self, frontier: &[Self::Time]);

    fn advance_frontier(&mut self) -> &[Self::Time];

    fn distinguish_since(&mut self, frontier: &[Self::Time]);

    fn distinguish_frontier(&mut self) -> &[Self::Time];

    fn map_batches<F: FnMut(&Self::Batch)>(&mut self, f: F);

    fn cursor(
        &mut self
    ) -> (Self::Cursor, <Self::Cursor as Cursor<Self::Key, Self::Val, Self::Time, Self::R>>::Storage) { ... }

    fn read_upper(&mut self, target: &mut Antichain<Self::Time>)
    where
        Self::Time: Timestamp,
    { ... }
}

A trace whose contents may be read.

This is a restricted interface to the more general Trace trait, which extends this trait with further methods to update the contents of the trace. These methods are used to examine the contents, and to update the reader's capabilities (which may release restrictions on the mutations to the underlying trace and cause work to happen).

Associated Types

type Key

Key by which updates are indexed.

type Val

Values associated with keys.

type Time

Timestamps associated with updates

type R

Associated update.

type Batch: BatchReader<Self::Key, Self::Val, Self::Time, Self::R> + Clone + 'static

The type of an immutable collection of updates.

type Cursor: Cursor<Self::Key, Self::Val, Self::Time, Self::R>

The type used to enumerate the collections contents.

Loading content...

Required methods

fn cursor_through(
    &mut self,
    upper: &[Self::Time]
) -> Option<(Self::Cursor, <Self::Cursor as Cursor<Self::Key, Self::Val, Self::Time, Self::R>>::Storage)>

Acquires a cursor to the restriction of the collection's contents to updates at times not greater or equal to an element of upper.

This method is expected to work if called with an upper that (i) was an observed bound in batches from the trace, and (ii) the trace has not been advanced beyond upper. Practically, the implementation should be expected to look for a "clean cut" using upper, and if it finds such a cut can return a cursor. This should allow upper such as &[] as used by self.cursor(), though it is difficult to imagine other uses.

fn advance_by(&mut self, frontier: &[Self::Time])

Advances the frontier of times the collection must be correctly accumulable through.

Practically, this allows the trace to advance times in updates it maintains as long as the advanced times still compare equivalently to any times greater or equal to some element of frontier. Times not greater or equal to some element of frontier may no longer correctly accumulate, so do not advance a trace unless you are quite sure you no longer require the distinction.

fn advance_frontier(&mut self) -> &[Self::Time]

Reports the frontier from which all time comparisions should be accurate.

Times that are not greater or equal to some element of the advance frontier may accumulate inaccurately as the trace may have lost the ability to distinguish between such times. Accumulations are only guaranteed to be accurate from the frontier onwards.

fn distinguish_since(&mut self, frontier: &[Self::Time])

Advances the frontier that may be used in cursor_through.

Practically, this allows the trace to merge batches whose upper frontier comes before frontier. The trace is likely to be annoyed or confused if you use a frontier other than one observed as an upper bound of an actual batch. This doesn't seem likely to be a problem, but get in touch if it is.

Calling distinguish_since(&[]) indicates that all batches may be merged at any point, which essentially disables the use of cursor_through with any parameter other than &[], which is the behavior of cursor.

fn distinguish_frontier(&mut self) -> &[Self::Time]

Reports the frontier from which the collection may be subsetted.

The semantics are less elegant here, but the underlying trace will not merge batches in advance of this frontier, which ensures that operators can extract the subset of the trace at batch boundaries from this frontier onward. These boundaries may be used in cursor_through, whereas boundaries not in advance of this frontier are not guaranteed to return a cursor.

fn map_batches<F: FnMut(&Self::Batch)>(&mut self, f: F)

Maps logic across the non-empty sequence of batches in the trace.

This is currently used only to extract historical data to prime late-starting operators who want to reproduce the stream of batches moving past the trace. It could also be a fine basis for a default implementation of the cursor methods, as they (by default) just move through batches accumulating cursors into a cursor list.

Loading content...

Provided methods

fn cursor(
    &mut self
) -> (Self::Cursor, <Self::Cursor as Cursor<Self::Key, Self::Val, Self::Time, Self::R>>::Storage)

Provides a cursor over updates contained in the trace.

fn read_upper(&mut self, target: &mut Antichain<Self::Time>) where
    Self::Time: Timestamp, 

Reads the upper frontier of committed times.

Loading content...

Implementors

impl<K, V, T, R, B> TraceReader for Spine<K, V, T, R, B> where
    K: Ord + Clone,
    V: Ord + Clone,
    T: Lattice + Ord + Clone + Debug + Default,
    R: Monoid,
    B: Batch<K, V, T, R> + Clone + 'static, [src]

type Key = K

type Val = V

type Time = T

type R = R

type Batch = B

type Cursor = CursorList<K, V, T, R, <B as BatchReader<K, V, T, R>>::Cursor>

impl<Tr> TraceReader for TraceAgent<Tr> where
    Tr: TraceReader,
    Tr::Time: Lattice + Ord + Clone + 'static, [src]

type Key = Tr::Key

type Val = Tr::Val

type Time = Tr::Time

type R = Tr::R

type Batch = Tr::Batch

type Cursor = Tr::Cursor

impl<Tr> TraceReader for TraceRc<Tr> where
    Tr::Time: Lattice + Ord + Clone + 'static,
    Tr: TraceReader, [src]

type Key = Tr::Key

type Val = Tr::Val

type Time = Tr::Time

type R = Tr::R

type Batch = Tr::Batch

type Cursor = Tr::Cursor

fn advance_by(&mut self, frontier: &[Tr::Time])[src]

Sets frontier to now be elements in frontier.

This change may not have immediately observable effects. It informs the shared trace that this handle no longer requires access to times other than those in the future of frontier, but if there are other handles to the same trace, it may not yet be able to compact.

fn distinguish_since(&mut self, frontier: &[Tr::Time])[src]

Allows the trace to compact batches of times before frontier.

fn cursor_through(
    &mut self,
    frontier: &[Tr::Time]
) -> Option<(Tr::Cursor, <Tr::Cursor as Cursor<Tr::Key, Tr::Val, Tr::Time, Tr::R>>::Storage)>[src]

Creates a new cursor over the wrapped trace.

impl<Tr, F> TraceReader for TraceFilter<Tr, F> where
    Tr: TraceReader,
    Tr::Batch: Clone,
    Tr::Key: 'static,
    Tr::Val: 'static,
    Tr::Time: Timestamp,
    Tr::R: 'static,
    F: Fn(&Tr::Key, &Tr::Val) -> bool + 'static, [src]

type Key = Tr::Key

type Val = Tr::Val

type Time = Tr::Time

type R = Tr::R

type Batch = BatchFilter<Tr::Key, Tr::Val, Tr::Time, Tr::R, Tr::Batch, F>

type Cursor = CursorFilter<Tr::Key, Tr::Val, Tr::Time, Tr::R, Tr::Cursor, F>

impl<Tr, F> TraceReader for TraceFreeze<Tr, F> where
    Tr: TraceReader,
    Tr::Batch: Clone,
    Tr::Key: 'static,
    Tr::Val: 'static,
    Tr::Time: Lattice + Clone + Default + 'static,
    Tr::R: 'static,
    F: Fn(&Tr::Time) -> Option<Tr::Time> + 'static, [src]

type Key = Tr::Key

type Val = Tr::Val

type Time = Tr::Time

type R = Tr::R

type Batch = BatchFreeze<Tr::Key, Tr::Val, Tr::Time, Tr::R, Tr::Batch, F>

type Cursor = CursorFreeze<Tr::Key, Tr::Val, Tr::Time, Tr::R, Tr::Cursor, F>

impl<Tr, TInner> TraceReader for differential_dataflow::trace::wrappers::enter::TraceEnter<Tr, TInner> where
    Tr: TraceReader,
    Tr::Batch: Clone,
    Tr::Key: 'static,
    Tr::Val: 'static,
    Tr::Time: Timestamp,
    Tr::R: 'static,
    TInner: Refines<Tr::Time> + Lattice, [src]

type Key = Tr::Key

type Val = Tr::Val

type Time = TInner

type R = Tr::R

type Batch = BatchEnter<Tr::Key, Tr::Val, Tr::Time, Tr::R, Tr::Batch, TInner>

type Cursor = CursorEnter<Tr::Key, Tr::Val, Tr::Time, Tr::R, Tr::Cursor, TInner>

impl<Tr, TInner, F> TraceReader for differential_dataflow::trace::wrappers::enter_at::TraceEnter<Tr, TInner, F> where
    Tr: TraceReader,
    Tr::Batch: Clone,
    Tr::Key: 'static,
    Tr::Val: 'static,
    Tr::Time: Timestamp,
    TInner: Refines<Tr::Time> + Lattice,
    Tr::R: 'static,
    F: 'static,
    F: Fn(&Tr::Key, &Tr::Val, &Tr::Time) -> TInner, [src]

type Key = Tr::Key

type Val = Tr::Val

type Time = TInner

type R = Tr::R

type Batch = BatchEnter<Tr::Key, Tr::Val, Tr::Time, Tr::R, Tr::Batch, TInner, F>

type Cursor = CursorEnter<Tr::Key, Tr::Val, Tr::Time, Tr::R, Tr::Cursor, TInner, F>

Loading content...