Struct WatermarkPacing 

pub struct WatermarkPacing {
    pub min_buckets: u64,
    pub emit_held_at_end: bool,
}

How often an evaluator emits the progress watermarks it computes.

A watermark is emitted once min_buckets of scan work have been done since the last emission; until then it is held, replacing any older held one. The scan’s first output is never held. Items and stops pass through unchanged.

Scan work is counted in bucket rows: the rows charged to the budget (BitmapScanMetrics::buckets_evaluated), plus, for every gap catch-up step that reopened at least one leaf scan, the evaluation’s SkipPolicy::drain_probe_rows. A reopen is a new backend read, and the skip policy reopens exactly when it judges that cheaper than draining that many dead rows, so it is priced at them. Leaves reopened in the same step count once, because the stream evaluator reopens them concurrently.

An emission is an emitted watermark or an item with a match inside the scan range; such an item also discards the held watermark. Items are whole buckets, so when the range starts or ends mid-bucket (e.g. a page resuming from a cursor) an edge item can hold only matches outside it. That item sends the client nothing and is not an emission.

The held watermark is discarded at every stop: a ScanStop::ScanLimit carries a frontier further along, and after a ScanStop::Fault or ScanStop::Cancelled the consumer is left with the last emitted watermark. At a clean end it is emitted only with emit_held_at_end.

Fields

min_buckets: u64

Scan work, in bucket rows, between emissions. With 0 nothing is held.

emit_held_at_end: bool

Emit the held watermark at a clean end instead of discarding it.

Trait Implementations

impl Clone for WatermarkPacing

fn clone(&self) -> WatermarkPacing

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for WatermarkPacing

impl Debug for WatermarkPacing

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

Formats the value using the given formatter.

impl Eq for WatermarkPacing

impl PartialEq for WatermarkPacing

fn eq(&self, other: &WatermarkPacing) -> 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 StructuralPartialEq for WatermarkPacing