Struct mz_timely_util::order::Partitioned

pub struct Partitioned<P, T>(Product<Interval<P>, T>);

A partially ordered timestamp that is partitioned by an arbitrary number of partitions identified by P. The construction allows for efficient representation of frontiers with Antichains.

A Partitioned<P, T> timestamp is internally the product order of an Interval<P> and a bare timestamp T. An Interval<P> represents an inclusive range of values from the type P and its partial order corresponds to the subset order.

Effectively, the minimum Partitioned timestamp will start out with the maximum possible Interval<P> on one side and the minimum timestamp T on the other side. Users of this timestamp can selectively downgrade the timestamp by advancing T, shrinking the interval, or both.

Antichains of this type are efficient in storage. In the worst case, where all chosen partitions have gaps between them, the produced antichain has twice as many elements as partitions. This is because the “dead space” between the selected partitions must have a representative timestamp in order for that space to be useable in the future.

Tuple Fields

0: Product<Interval<P>, T>

Implementations

impl<P: Clone + PartialOrd, T> Partitioned<P, T>

pub fn new_singleton(partition: P, timestamp: T) -> Self

Constructs a new timestamp for a specific partition.

pub fn new_range(lower: P, upper: P, timestamp: T) -> Self

Constructs a new timestamp for a partition range.

pub fn interval(&self) -> &Interval<P>

Returns the interval component of this partitioned timestamp.

pub fn timestamp(&self) -> &T

Returns the timestamp component of this partitioned timestamp.

pub fn timestamp_mut(&mut self) -> &mut T

impl<P: Clone + PartialOrd + Step, T: Clone> Partitioned<P, T>

pub fn split(&self, point: &P) -> (Option<Self>, Option<Self>)

Returns up to two partitions that contain the interval before and/or after given partition point, neither of which contain the point.

Trait Implementations

impl<P: Clone, T: Clone> Clone for Partitioned<P, T>

fn clone(&self) -> Partitioned<P, T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<P: Copy, T: Copy> Columnation for Partitioned<P, T>

type InnerRegion = CopyRegion<Partitioned<P, T>>

The type of region capable of absorbing allocations owned by the Self type. Note: not allocations of Self, but of the things that it owns.

impl<P: Debug, T: Debug> Debug for Partitioned<P, T>

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

Formats the value using the given formatter.

impl<'de, P, T> Deserialize<'de> for Partitioned<P, T>

where P: Deserialize<'de>, T: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<P: Display, T: Display> Display for Partitioned<P, T>

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

Formats the value using the given formatter.

impl<P: Hash, T: Hash> Hash for Partitioned<P, T>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<P: Ord, T: Ord> Ord for Partitioned<P, T>

fn cmp(&self, other: &Partitioned<P, T>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl<P: PartialEq, T: PartialEq> PartialEq for Partitioned<P, T>

fn eq(&self, other: &Partitioned<P, T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<P: PartialOrd, T: PartialOrd> PartialOrd for Partitioned<P, T>

fn partial_cmp(&self, other: &Partitioned<P, T>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<P: Ord + Eq, T: PartialOrder> PartialOrder for Partitioned<P, T>

fn less_equal(&self, other: &Self) -> bool

Returns true iff one element is less than or equal to the other.

fn less_than(&self, other: &Rhs) -> bool

Returns true iff one element is strictly less than the other.

impl<P: Clone, T: Timestamp> PathSummary<Partitioned<P, T>> for ()

fn results_in(&self, src: &Partitioned<P, T>) -> Option<Partitioned<P, T>>

Advances a timestamp according to the timestamp actions on the path.

fn followed_by(&self, _other: &Self) -> Option<Self>

Composes this path summary with another path summary.

impl<P, T: Timestamp> Refines<()> for Partitioned<P, T>

where P: Extrema + Clone + Debug + ExchangeData + Hash + Ord,

fn to_inner(_other: ()) -> Self

Converts the outer timestamp to an inner timestamp.

fn to_outer(self)

Converts the inner timestamp to an outer timestamp.

fn summarize(_path: Self::Summary)

Summarizes an inner path summary as an outer path summary.

impl<P, T> Serialize for Partitioned<P, T>

where P: Serialize, T: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<P, T: Timestamp> Timestamp for Partitioned<P, T>

where P: Extrema + Clone + Debug + ExchangeData + Hash + Ord,

type Summary = ()

A type summarizing action on a timestamp along a dataflow path.

fn minimum() -> Self

A minimum value suitable as a default.

impl<P: Copy, T: Copy> Copy for Partitioned<P, T>

impl<P: Eq, T: Eq> Eq for Partitioned<P, T>

impl<P, T> StructuralPartialEq for Partitioned<P, T>