Struct RegionWriteCtx 

pub(crate) struct RegionWriteCtx {

    region_id: RegionId,
    version: Arc<Version>,
    version_control: Arc<VersionControl>,
    next_sequence: SequenceNumber,
    next_entry_id: EntryId,
    wal_entry: WalEntry,
    provider: Provider,
    notifiers: Vec<WriteNotify>,
    bulk_notifiers: Vec<WriteNotify>,
    pub(crate) bulk_parts: Vec<BulkPart>,
    failed: bool,
    pub(crate) put_num: usize,
    pub(crate) delete_num: usize,
    pub(crate) written_bytes: Option<Arc<AtomicU64>>,
}

Context to keep region metadata and buffer write requests.

Fields

region_id: RegionId

Id of region to write.

version: Arc<Version>

Version of the region while creating the context.

version_control: Arc<VersionControl>

VersionControl of the region.

next_sequence: SequenceNumber

Next sequence number to write.

The context assigns a unique sequence number for each row.

next_entry_id: EntryId

Next entry id of WAL to write.

wal_entry: WalEntry

Valid WAL entry to write.

We keep [WalEntry] instead of mutations to avoid taking mutations out of the context to construct the wal entry when we write to the wal.

provider: Provider

Wal options of the region being written to.

notifiers: Vec<WriteNotify>

Notifiers to send write results to waiters.

The i-th notify is for i-th mutation.

bulk_notifiers: Vec<WriteNotify>

Notifiers for bulk requests.

bulk_parts: Vec<BulkPart>

Pending bulk write requests

failed: bool

The write operation is failed and we should not write to the mutable memtable.

put_num: usize

Rows to put.

delete_num: usize

Rows to delete.

written_bytes: Option<Arc<AtomicU64>>

The total bytes written to the region.

Implementations

impl RegionWriteCtx

pub(crate) fn new( region_id: RegionId, version_control: &Arc<VersionControl>, provider: Provider, written_bytes: Option<Arc<AtomicU64>>, ) -> RegionWriteCtx

Returns an empty context.

pub(crate) fn push_mutation( &mut self, op_type: i32, rows: Option<Rows>, write_hint: Option<WriteHint>, tx: OptionOutputTx, sequence: Option<SequenceNumber>, )

Push mutation to the context. This method adopts the sequence number in parameters if present.

pub(crate) fn add_wal_entry<S: LogStore>( &mut self, wal_writer: &mut WalWriter<S>, ) -> Result<()>

Encode and add WAL entry to the writer.

pub(crate) fn version(&self) -> &Arc<Version>

pub(crate) fn set_error(&mut self, err: Arc<Error>)

Sets error and marks all write operations are failed.

pub(crate) fn set_next_entry_id(&mut self, next_entry_id: EntryId)

Updates next entry id.

pub(crate) async fn write_memtable(&mut self)

Consumes mutations and writes them into mutable memtable.

pub(crate) fn push_bulk( &mut self, sender: OptionOutputTx, bulk: BulkPart, sequence: Option<SequenceNumber>, ) -> bool

pub(crate) async fn write_bulk(&mut self)