Struct mz_compute::render::top_k::topk_agg::TopKBatch

pub struct TopKBatch<T> {
    updates: SmallVec<[(T, i64); 16]>,
    clean: usize,
    limit: i64,
}

Fields

updates: SmallVec<[(T, i64); 16]>

clean: usize

limit: i64

Implementations

impl<T: Ord> TopKBatch<T>

pub fn new(limit: i64) -> Self

pub fn update(&mut self, item: T, value: i64)

Adds a new update, for item with value.

This could be optimized to perform compaction when the number of “dirty” elements exceeds half the length of the list, which would keep the total footprint within reasonable bounds even under an arbitrary number of updates. This has a cost, and it isn’t clear whether it is worth paying without some experimentation.

pub fn compact(&mut self)

Compact the internal representation.

This method sort self.updates and consolidates elements with equal item, discarding any whose accumulation is zero. It is optimized to only do this if the number of dirty elements is non-zero.

fn maintain_bounds(&mut self)

Maintain the bounds of pending (non-compacted) updates versus clean (compacted) data. This function tries to minimize work by only compacting if enough work has accumulated.

Trait Implementations

impl<T: Ord> IntoIterator for TopKBatch<T>

type Item = (T, i64)

The type of the elements being iterated over.

type IntoIter = IntoIter<[(T, i64); 16]>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.