Struct mz_compute::arrangement::manager::PaddedTrace

pub struct PaddedTrace<Tr>
where
    Tr: TraceReader<Time = Timestamp>,
{
    trace: Tr,
    padded_since: Option<Antichain<Timestamp>>,
}

Handle to a trace that can be padded.

A padded trace contains empty data for all times greater than or equal to its padded_since and less than the logical compaction frontier of the inner trace.

This type is intentionally limited to only work with mz_repr::Timestamp times, because that is all that’s required by TraceManager. It can be made to be more generic, at the cost of more complicated reasoning about the correct management of the involved frontiers.

Fields

trace: Tr

The wrapped trace.

padded_since: Option<Antichain<Timestamp>>

The frontier from which the trace is padded, or None if it is not padded.

Invariant: The contained frontier is less than the logical compaction frontier of trace.

All methods of PaddedTrace are written to uphold this invariant. In particular, set_logical_compaction_frontier sets the padded_since to None if the new compaction frontier is >= the previous compaction frontier of trace.

Implementations

impl<Tr> PaddedTrace<Tr>

where Tr: TraceReader<Time = Timestamp>,

fn into_padded(self) -> Self

Turns this trace into a padded version that reports empty data for all times less than the trace’s current logical compaction frontier.

impl<Tr> PaddedTrace<TraceAgent<Tr>>

where Tr: TraceReader<Time = Timestamp> + 'static,

pub fn import_frontier_core<G>( &mut self, scope: &G, name: &str, since: Antichain<Tr::Time>, until: Antichain<Tr::Time>, ) -> (Arranged<G, TraceFrontier<TraceAgent<Tr>>>, ShutdownButton<CapabilitySet<Tr::Time>>)

where G: Scope<Timestamp = Tr::Time>,

Import a trace restricted to a specific time interval [since, until).

Trait Implementations

impl<Tr> Clone for PaddedTrace<Tr>

where Tr: TraceReader<Time = Timestamp> + Clone,

fn clone(&self) -> PaddedTrace<Tr>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Tr> From<Tr> for PaddedTrace<Tr>

where Tr: TraceReader<Time = Timestamp>,

fn from(trace: Tr) -> Self

Converts to this type from the input type.

impl<Tr> TraceReader for PaddedTrace<Tr>

where Tr: TraceReader<Time = Timestamp>,

type Key<'a> = <Tr as TraceReader>::Key<'a>

Key by which updates are indexed.

type Val<'a> = <Tr as TraceReader>::Val<'a>

Values associated with keys.

type Time = <Tr as TraceReader>::Time

Timestamps associated with updates

type TimeGat<'a> = <Tr as TraceReader>::TimeGat<'a>

Borrowed form of timestamp.

type Diff = <Tr as TraceReader>::Diff

Owned form of update difference.

type DiffGat<'a> = <Tr as TraceReader>::DiffGat<'a>

Borrowed form of update difference.

type Batch = <Tr as TraceReader>::Batch

The type of an immutable collection of updates.

type Storage = <Tr as TraceReader>::Storage

Storage type for Self::Cursor. Likely related to Self::Batch.

type Cursor = <Tr as TraceReader>::Cursor

The type used to enumerate the collections contents.

fn cursor_through( &mut self, upper: AntichainRef<'_, Self::Time>, ) -> Option<(Self::Cursor, Self::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.

fn set_logical_compaction(&mut self, frontier: AntichainRef<'_, Self::Time>)

Advances the frontier that constrains logical compaction.

fn get_logical_compaction(&mut self) -> AntichainRef<'_, Self::Time>

Reports the logical compaction frontier.

fn set_physical_compaction(&mut self, frontier: AntichainRef<'_, Self::Time>)

Advances the frontier that constrains physical compaction.

fn get_physical_compaction(&mut self) -> AntichainRef<'_, Self::Time>

Reports the physical compaction frontier.

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

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

fn cursor(&mut self) -> (Self::Cursor, Self::Storage)

Provides a cursor over updates contained in the trace.

fn advance_by(&mut self, frontier: AntichainRef<'_, Self::Time>)

👎Deprecated since 0.11: please use set_logical_compaction

Deprecated form of set_logical_compaction.

fn advance_frontier(&mut self) -> AntichainRef<'_, Self::Time>

👎Deprecated since 0.11: please use get_logical_compaction

Deprecated form of get_logical_compaction.

fn distinguish_since(&mut self, frontier: AntichainRef<'_, Self::Time>)

👎Deprecated since 0.11: please use set_physical_compaction

Deprecated form of set_physical_compaction.

fn distinguish_frontier(&mut self) -> AntichainRef<'_, Self::Time>

👎Deprecated since 0.11: please use get_physical_compaction

Deprecated form of get_physical_compaction.

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

Reads the upper frontier of committed times.

fn advance_upper(&mut self, upper: &mut Antichain<Self::Time>)

Advances upper by any empty batches.