Struct PartRef

struct PartRef<'a, T: Timestamp, D> {
    next_kvt: Reverse<Option<((ArrayIdx<'a>, Option<ArrayIdx<'a>>), T, D)>>,
    part_index: usize,
    row_index: &'a mut PartIndices,
    last_in_run: bool,
    _phantom: PhantomData<D>,
}

This is used as a max-heap entry: the ordering of the fields is important!

Fields

next_kvt: Reverse<Option<((ArrayIdx<'a>, Option<ArrayIdx<'a>>), T, D)>>

The smallest KVT that might be emitted from this run in the future. This is reverse-sorted: Nones will sort largest (and be popped first on the heap) and smaller keys will be popped before larger keys.

part_index: usize

The index of the corresponding part within the ConsolidatingIter’s list of parts.

row_index: &'a mut PartIndices

The index of the next row within that part. This is a mutable pointer to long-lived state; we must only advance this index once we’ve rolled any rows before this index into our state.

last_in_run: bool

Whether / not the iterator for the part is the last in its run, or whether there may be iterators for the same part in the future.

_phantom: PhantomData<D>

Implementations

impl<'a, T: Timestamp + Codec64 + Lattice, D: Codec64 + Semigroup> PartRef<'a, T, D>

fn update_peek( &mut self, part: &'a StructuredUpdates, filter: &FetchBatchFilter<T>, )

fn pop( &mut self, from: &[&'a StructuredUpdates], filter: &FetchBatchFilter<T>, ) -> Option<((usize, usize), (ArrayIdx<'a>, Option<ArrayIdx<'a>>), T, D)>

Trait Implementations

impl<'a, T: Debug + Timestamp, D: Debug> Debug for PartRef<'a, T, D>

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

Formats the value using the given formatter.

impl<'a, T: Ord + Timestamp, D: Ord> Ord for PartRef<'a, T, D>

fn cmp(&self, other: &PartRef<'a, T, D>) -> 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,

Restrict a value to a certain interval.

impl<'a, T: PartialEq + Timestamp, D: PartialEq> PartialEq for PartRef<'a, T, D>

fn eq(&self, other: &PartRef<'a, T, D>) -> 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<'a, T: PartialOrd + Timestamp, D: PartialOrd> PartialOrd for PartRef<'a, T, D>

fn partial_cmp(&self, other: &PartRef<'a, T, D>) -> 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<'a, T: Eq + Timestamp, D: Eq> Eq for PartRef<'a, T, D>

impl<'a, T: Timestamp, D> StructuralPartialEq for PartRef<'a, T, D>