Struct rerun::external::re_chunk_store::ChunkStoreDiff

pub struct ChunkStoreDiff {
    pub kind: ChunkStoreDiffKind,
    pub chunk: Arc<Chunk>,
    pub compacted: Option<(BTreeMap<ChunkId, Arc<Chunk>>, ChunkId)>,
}

Describes an atomic change in the Rerun ChunkStore: a chunk has been added or deleted.

From a query model standpoint, the ChunkStore always operates one chunk at a time:

• The contents of a chunk (i.e. its columns) are immutable past insertion, by virtue of ChunkIds being unique and non-reusable.
• Similarly, garbage collection always removes all the data associated with a chunk in one go: there cannot be orphaned columns. When a chunk is gone, all data associated with it is gone too.

Refer to field-level documentation for more information.

Fields

kind: ChunkStoreDiffKind

Addition or deletion?

The store’s internals are opaque and don’t necessarily reflect the query model (e.g. there might be data in the store that cannot by reached by any query).

A ChunkStoreDiff answers a logical question: “does there exist a query path which can return data from that chunk?”.

An event of kind deletion only tells you that, from this point on, no query can return data from that chunk. That doesn’t necessarily mean that the data is actually gone, i.e. don’t make assumptions of e.g. the size in bytes of the store based on these events. They are in “query-model space” and are not an accurate representation of what happens in storage space.

chunk: Arc<Chunk>

The chunk that was added or removed.

If the addition of a chunk to the store triggered a compaction, that chunk pre-compaction is what will be exposed here. This allows subscribers to only process data that is new, as opposed to having to reprocess old rows that appear to have been removed and then reinserted due to compaction.

To keep track of what chunks were merged with what chunks, use the ChunkStoreDiff::compacted field below.

compacted: Option<(BTreeMap<ChunkId, Arc<Chunk>>, ChunkId)>

Reports which Chunks were merged into a new ChunkId (srcs, dst) during a compaction.

This is only specified if an addition to the store triggered a compaction. When that happens, it is guaranteed that ChunkStoreDiff::chunk will be present in the set of source chunks below, since it was compacted on arrival.

A corollary to that is that the destination ChunkId must have never been seen before.

Implementations

impl ChunkStoreDiff

pub fn addition( chunk: Arc<Chunk>, compacted: Option<(BTreeMap<ChunkId, Arc<Chunk>>, ChunkId)> ) -> ChunkStoreDiff

pub fn deletion(chunk: Arc<Chunk>) -> ChunkStoreDiff

pub fn is_static(&self) -> bool

pub fn delta(&self) -> i64

-1 for deletions, +1 for additions.

pub fn num_components(&self) -> usize

Trait Implementations

impl Clone for ChunkStoreDiff

fn clone(&self) -> ChunkStoreDiff

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ChunkStoreDiff

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

Formats the value using the given formatter.

impl PartialEq for ChunkStoreDiff

fn eq(&self, rhs: &ChunkStoreDiff) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Eq for ChunkStoreDiff