Enum DirtyMarker 

pub enum DirtyMarker {
    MarkDirty {
        collection_id: CollectionUuid,
        log_position: u64,
        num_records: u64,
        reinsert_count: u64,
        initial_insertion_epoch_us: u64,
    },
    Purge {
        collection_id: CollectionUuid,
    },
    Cleared,
}

Markers for tracking collection compaction state changes.

DirtyMarker represents state transitions in the compaction lifecycle of collections. The enum is designed for forwards/backwards compatibility - new variants can be added and handled independently while maintaining compatibility with older code.

Variants

MarkDirty

Marks a collection as needing compaction due to new records.

Fields

collection_id: CollectionUuid

The collection requiring compaction.

log_position: u64

The position in the write-ahead log where this marker was created.

num_records: u64

The total number of records in the collection.

reinsert_count: u64

The number of times this collection has been reinserted into the heap.

initial_insertion_epoch_us: u64

The epoch time in microseconds when this collection was first marked dirty.

Purge

Removes all compaction scheduling for a collection.

Fields

collection_id: CollectionUuid

The collection to purge from the compaction heap.

Cleared

A no-op marker used for log compaction.

When a log contains mark-dirty markers that have been purged, those entries can be replaced with Cleared markers to allow log truncation.

Implementations

impl DirtyMarker

pub fn collection_id(&self) -> CollectionUuid

The collection ID for a given dirty marker.

pub fn reinsert(&mut self)

Increment any reinsert counter on the variant.

Trait Implementations

impl Clone for DirtyMarker

fn clone(&self) -> DirtyMarker

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DirtyMarker

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for DirtyMarker

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for DirtyMarker

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

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for DirtyMarker

impl StructuralPartialEq for DirtyMarker