Struct CompactTask

pub struct CompactTask {

    pub input_ssts: Vec<InputLevel>,
    pub splits: Vec<KeyRange>,
    pub sorted_output_ssts: Vec<SstableInfo>,
    pub task_id: u64,
    pub target_level: u32,
    pub gc_delete_keys: bool,
    pub base_level: u32,
    pub task_status: i32,
    pub compaction_group_id: u64,
    pub existing_table_ids: Vec<u32>,
    pub compression_algorithm: u32,
    pub target_file_size: u64,
    pub compaction_filter_mask: u32,
    pub table_options: BTreeMap<u32, TableOption>,
    pub current_epoch_time: u64,
    pub target_sub_level_id: u64,
    pub task_type: i32,
    pub split_by_state_table: bool,
    pub split_weight_by_vnode: u32,
    pub table_vnode_partition: BTreeMap<u32, u32>,
    pub table_watermarks: BTreeMap<u32, TableWatermarks>,
    pub table_schemas: BTreeMap<u32, TableSchema>,
    pub max_sub_compaction: u32,
    pub compaction_group_version_id: u64,
}

Fields

input_ssts: Vec<InputLevel>

SSTs to be compacted, which will be removed from LSM after compaction

splits: Vec<KeyRange>

In ideal case, the compaction will generate splits.len() tables which have key range corresponding to that in [splits], respectively

sorted_output_ssts: Vec<SstableInfo>

compaction output, which will be added to [target_level] of LSM after compaction

task_id: u64

task id assigned by hummock storage service

target_level: u32

compaction output will be added to [target_level] of LSM after compaction

gc_delete_keys: bool

base_level: u32

Lbase in LSM

task_status: i32

compaction_group_id: u64

compaction group the task belongs to

existing_table_ids: Vec<u32>

existing_table_ids for compaction drop key

compression_algorithm: u32

target_file_size: u64

compaction_filter_mask: u32

table_options: BTreeMap<u32, TableOption>

current_epoch_time: u64

target_sub_level_id: u64

task_type: i32

Identifies whether the task is space_reclaim, if the compact_task_type increases, it will be refactored to enum

split_by_state_table: bool

👎Deprecated

Deprecated. use table_vnode_partition instead;

split_weight_by_vnode: u32

Compaction needs to cut the state table every time 1/weight of vnodes in the table have been processed. Deprecated. use table_vnode_partition instead;

table_vnode_partition: BTreeMap<u32, u32>

table_watermarks: BTreeMap<u32, TableWatermarks>

The table watermark of any table id. In compaction we only use the table watermarks on safe epoch, so we only need to include the table watermarks on safe epoch to reduce the size of metadata.

table_schemas: BTreeMap<u32, TableSchema>

The table schemas that are at least as new as the one used to create input_ssts.

max_sub_compaction: u32

Max sub compaction task numbers

compaction_group_version_id: u64

The compaction group id when the compaction task is created.

Implementations

impl CompactTask

pub fn task_status(&self) -> TaskStatus

Returns the enum value of task_status, or the default if the field is set to an invalid enum value.

pub fn set_task_status(&mut self, value: TaskStatus)

Sets task_status to the provided enum value.

pub fn task_type(&self) -> TaskType

Returns the enum value of task_type, or the default if the field is set to an invalid enum value.

pub fn set_task_type(&mut self, value: TaskType)

Sets task_type to the provided enum value.

impl CompactTask

pub fn get_input_ssts(&self) -> &Vec<InputLevel>

pub fn get_splits(&self) -> &Vec<KeyRange>

pub fn get_sorted_output_ssts(&self) -> &Vec<SstableInfo>

pub fn get_task_id(&self) -> u64

pub fn get_target_level(&self) -> u32

pub fn get_gc_delete_keys(&self) -> bool

pub fn get_base_level(&self) -> u32

pub fn get_task_status(&self) -> Result<TaskStatus, PbFieldNotFound>

pub fn get_compaction_group_id(&self) -> u64

pub fn get_existing_table_ids(&self) -> &Vec<u32>

pub fn get_compression_algorithm(&self) -> u32

pub fn get_target_file_size(&self) -> u64

pub fn get_compaction_filter_mask(&self) -> u32

pub fn get_table_options(&self) -> &BTreeMap<u32, TableOption>

pub fn get_current_epoch_time(&self) -> u64

pub fn get_target_sub_level_id(&self) -> u64

pub fn get_task_type(&self) -> Result<TaskType, PbFieldNotFound>

pub fn get_split_by_state_table(&self) -> bool

👎Deprecated

pub fn get_split_weight_by_vnode(&self) -> u32

pub fn get_table_vnode_partition(&self) -> &BTreeMap<u32, u32>

pub fn get_table_watermarks(&self) -> &BTreeMap<u32, TableWatermarks>

pub fn get_table_schemas(&self) -> &BTreeMap<u32, TableSchema>

pub fn get_max_sub_compaction(&self) -> u32

pub fn get_compaction_group_version_id(&self) -> u64

Trait Implementations

impl Clone for CompactTask

fn clone(&self) -> CompactTask

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for CompactTask

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

Formats the value using the given formatter.

impl Default for CompactTask

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for CompactTask

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Message for CompactTask

fn encoded_len(&self) -> usize

Returns the encoded length of the message without a length delimiter.

fn clear(&mut self)

Clears the message, resetting all fields to their default.

fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>

where Self: Sized,

Encodes the message to a buffer.

fn encode_to_vec(&self) -> Vec<u8>

where Self: Sized,

Encodes the message to a newly allocated buffer.

fn encode_length_delimited( &self, buf: &mut impl BufMut, ) -> Result<(), EncodeError>

where Self: Sized,

Encodes the message with a length-delimiter to a buffer.

fn encode_length_delimited_to_vec(&self) -> Vec<u8>

where Self: Sized,

Encodes the message with a length-delimiter to a newly allocated buffer.

fn decode(buf: impl Buf) -> Result<Self, DecodeError>

where Self: Default,

Decodes an instance of the message from a buffer.

fn decode_length_delimited(buf: impl Buf) -> Result<Self, DecodeError>

where Self: Default,

Decodes a length-delimited instance of the message from the buffer.

fn merge(&mut self, buf: impl Buf) -> Result<(), DecodeError>

where Self: Sized,

Decodes an instance of the message from a buffer, and merges it into self.

fn merge_length_delimited(&mut self, buf: impl Buf) -> Result<(), DecodeError>

where Self: Sized,

Decodes a length-delimited instance of the message from buffer, and merges it into self.

impl PartialEq for CompactTask

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

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 CompactTask

impl StructuralPartialEq for CompactTask