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>,
    failed: bool,
    pub(crate) put_num: usize,
    pub(crate) delete_num: usize,
}

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.

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.

Implementations

impl RegionWriteCtx

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

Returns an empty context.

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

Push mutation to the context.

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.