Struct Candidate 

struct Candidate {
    num_files: usize,
    total_size: usize,
    largest_file_size: usize,
    overlap_participants: usize,
    l0_rows: usize,
    l1_rows: usize,
    has_l0: bool,
    has_l1: bool,
    has_unknown_rows: bool,
}

Metrics of a candidate compaction input, accumulated incrementally as the candidate interval expands one file at a time.

Fields

num_files: usize

Number of files in the interval.

total_size: usize

Total input bytes of the interval.

largest_file_size: usize

Size of the largest single file in the interval.

overlap_participants: usize

Files in the interval that overlap another interval file from a different sorted run. Resolving these overlaps is what reduces sorted runs.

l0_rows: usize

Number of rows contributed by uncompacted files.

l1_rows: usize

Number of rows contributed by compacted files.

has_l0: bool

has_l1: bool

has_unknown_rows: bool

Whether at least one file uses 0 to represent an unknown row count.

Implementations

impl Candidate

fn absorb( &mut self, file: &OrderedFile<'_>, preceding: &[OrderedFile<'_>], participations: &mut Vec<bool>, )

Absorbs file into the candidate. preceding holds the interval files added before it and participations tracks which of them already participate in an intra-interval overlap; both exist only for overlap accounting.

fn absorb_level_rows(&mut self, file: &FileHandle)

fn predicted_output_files(&self, max_output_file_size: Option<u64>) -> usize

Predicted number of output files after compacting this candidate. Compaction output holds at most the input bytes, so a split threshold of max_output_file_size yields at most ceil(total_size / threshold) files. Without a threshold the output is a single file.

fn file_reduction(&self, max_output_file_size: Option<u64>) -> usize

Net file count reduction compacting this candidate would achieve, i.e. how many fewer physical SSTs the window holds afterwards. Zero when the output would be split back into at least as many files as the input.

fn is_balanced(&self) -> bool

A large historical file is only rewritten once its peers contribute at least the same amount of data, so every rewrite moves it into a larger size tier.

fn has_balanced_level_rows(&self) -> bool

Bounds rewrite amplification for mixed L0/L1 candidates. Legacy files with unknown row counts retain the byte-balance behavior above.

fn has_mixed_levels(&self) -> bool

fn makes_progress(&self, max_output_file_size: Option<u64>) -> bool

A candidate is worth compacting only if it makes progress on at least one axis: it reduces the physical file count, or it resolves at least one overlap (merging sorted runs and reducing read amplification). A pure rewrite that achieves neither only burns I/O.

fn score(&self, max_output_file_size: Option<u64>) -> CandidateScore

Trait Implementations

impl Debug for Candidate

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

Formats the value using the given formatter.

impl Default for Candidate

fn default() -> Candidate

Returns the “default value” for a type.