Struct Trace

pub struct Trace<T> {
    spine: Spine<T>,
    pub(crate) roundtrip_structure: bool,
}

An append-only collection of compactable update batches.

In an effort to keep our fork of Spine as close as possible to the original, we push as many changes as possible into this wrapper.

Fields

spine: Spine<T>

roundtrip_structure: bool

Implementations

impl<T: Timestamp + Lattice> Trace<T>

pub(crate) fn flatten(&self) -> FlatTrace<T>

pub(crate) fn unflatten(value: FlatTrace<T>) -> Result<Self, String>

impl<T> Trace<T>

pub fn since(&self) -> &Antichain<T>

pub fn upper(&self) -> &Antichain<T>

pub fn map_batches<'a, F: FnMut(&'a HollowBatch<T>)>(&'a self, f: F)

pub fn batches(&self) -> impl Iterator<Item = &HollowBatch<T>>

pub fn num_spine_batches(&self) -> usize

impl<T: Timestamp + Lattice> Trace<T>

pub fn downgrade_since(&mut self, since: &Antichain<T>)

pub fn push_batch(&mut self, batch: HollowBatch<T>) -> Vec<FueledMergeReq<T>>

pub fn claim_compaction(&mut self, id: SpineId, compaction: ActiveCompaction)

pub(crate) fn push_batch_no_merge_reqs(&mut self, batch: HollowBatch<T>)

The same as Self::push_batch but without the FueledMergeReqs, which account for a surprising amount of cpu in prod. database-issues#5411

pub fn exert(&mut self, fuel: usize) -> (Vec<FueledMergeReq<T>>, bool)

Apply some amount of effort to trace maintenance.

The units of effort are updates, and the method should be thought of as analogous to inserting as many empty updates, where the trace is permitted to perform proportionate work.

Returns true if this did work and false if it left the spine unchanged.

pub fn validate(&self) -> Result<(), String>

Validates invariants.

See Spine::validate for details.

pub(crate) fn fueled_merge_reqs_before_ms( &self, threshold_ms: u64, threshold_writer: Option<WriterKey>, ) -> impl Iterator<Item = FueledMergeReq<T>> + '_

Obtain all fueled merge reqs that either have no active compaction, or the previous compaction was started at or before the threshold time, in order from oldest to newest.

fn remove_redundant_merge_reqs( merge_reqs: Vec<FueledMergeReq<T>>, ) -> Vec<FueledMergeReq<T>>

pub fn spine_metrics(&self) -> SpineMetrics

impl<T: Timestamp + Lattice + Codec64> Trace<T>

pub fn apply_merge_res_checked<D: Codec64 + Semigroup + PartialEq>( &mut self, res: &FueledMergeRes<T>, metrics: &ColumnarMetrics, ) -> ApplyMergeResult

pub fn apply_merge_res_unchecked( &mut self, res: &FueledMergeRes<T>, ) -> ApplyMergeResult

pub fn apply_tombstone_merge( &mut self, res: &FueledMergeRes<T>, ) -> ApplyMergeResult

Trait Implementations

impl<T: Clone> Clone for Trace<T>

fn clone(&self) -> Trace<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Trace<T>

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

Formats the value using the given formatter.

impl<T: Timestamp + Lattice> Default for Trace<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T: PartialEq> PartialEq for Trace<T>

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

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

const 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<T: Timestamp + Lattice + Codec64> RustType<ProtoTrace> for Trace<T>

fn into_proto(&self) -> ProtoTrace

Convert a Self into a Proto value.

fn from_proto(proto: ProtoTrace) -> Result<Self, TryFromProtoError>

Consume and convert a Proto back into a Self value.

fn into_proto_owned(self) -> Proto

A zero clone version of Self::into_proto that types can optionally implement, otherwise, the default implementation delegates to Self::into_proto.