Struct dataflow::source::timestamp::TimestampBindingRc

pub struct TimestampBindingRc {
    pub wrapper: Rc<RefCell<TimestampBindingBox>>,
    compaction_frontier: Antichain<Timestamp>,
}

A wrapper that allows multiple source instances to share a TimestampBindingBox and hold back its compaction.

Fields

wrapper: Rc<RefCell<TimestampBindingBox>>

The wrapped shared state.

compaction_frontier: Antichain<Timestamp>

Implementations

impl TimestampBindingRc

pub fn new(timestamp_update_interval: u64, now: NowFn) -> Self

Create a new instance of TimestampBindingRc.

pub fn set_compaction_frontier(
    &mut self,
    new_frontier: AntichainRef<'_, Timestamp>
)

Set the compaction frontier to new_frontier and compact all timestamp bindings at timestamps less than the compaction frontier.

Note that new_frontier must be in advance of the current compaction frontier. The source can be correctly replayed from any as_of in advance of the compaction frontier after this operation.

pub fn set_durability_frontier(&self, new_frontier: AntichainRef<'_, Timestamp>)

Sets the durability frontier, aka, the frontier before which all updates can be replayed across restarts.

pub fn add_binding(
    &self,
    partition: PartitionId,
    timestamp: Timestamp,
    offset: MzOffset
)

Add a new mapping from (partition, offset) -> timestamp.

Note that the timestamp has to be greater than the largest previously bound timestamp for that partition, and offset has to be greater than or equal to the largest previously bound offset for that partition. If proposed is true, the binding is treated as tentative and may be overwritten by other, overlapping bindings

pub fn add_partition(
    &self,
    partition: PartitionId,
    restored_offset: Option<MzOffset>
)

Tell timestamping machinery to look out for partition

The optional restored_offset can be used to give an explicit offset that should be used when starting to read from the given partition.

pub fn get_or_propose_binding(
    &self,
    partition: &PartitionId,
    offset: MzOffset
) -> Timestamp

Get the timestamp assignment for (partition, offset) if it is known.

This function returns the timestamp and the maximum offset for which it is valid.

pub fn upper(&self) -> Timestamp

Get the timestamp that all messages beyond the minted bindings will be assigned to. This is equal to the proposer’s current timestamp

pub fn read_upper(&self, target: &mut Antichain<Timestamp>)

Returns the frontier of timestamps that have not been bound to any incoming data, or in other words, all data has been assigned timestamps less than some element in the returned frontier.

All subsequent updates will either be at or in advance of this frontier.

pub fn downgrade(
    &self,
    cap: &mut Capability<Timestamp>,
    cursors: &HashMap<PartitionId, MzOffset>
)

Attempt to downgrade the given capability by consulting the currently known bindings and the per partition cursors of the caller.

pub fn partitions(&self) -> Vec<(PartitionId, Option<MzOffset>)>

Returns the list of partitions this source knows about.

TODO(rkhaitan): this function feels like a hack, both in the API of having the source instances ask for the list of known partitions and in allocating a vector to answer that question.

pub fn update_timestamp(&self)

Instructs RT sources to try and move forward to the next timestamp if possible

pub fn get_bindings_in_range(
    &self,
    lower: AntichainRef<'_, Timestamp>,
    upper: AntichainRef<'_, Timestamp>
) -> Vec<(PartitionId, Timestamp, MzOffset)>

Return all timestamp bindings at or in advance of lower and not at or in advance of upper

pub fn durability_frontier(&self) -> Antichain<Timestamp>

Returns the current durability frontier

Trait Implementations

impl Clone for TimestampBindingRc

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for TimestampBindingRc

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Drop for TimestampBindingRc

fn drop(&mut self)

Executes the destructor for this type.