Struct WriteHandle

pub struct WriteHandle {
    txn_id: TxnId,
    tx: Sender,
    txn_state: TxnState,
}

WriteHandle writes its data into a table in a transactional way.

First, it needs to call begin() and then write chunks by calling write_chunk().

Finally call end() to commit the transaction or rollback() to rollback the transaction.

If the WriteHandle is dropped with a Begin transaction state, it will automatically rollback the transaction.

Fields

txn_id: TxnId

tx: Sender

txn_state: TxnState

Implementations

impl WriteHandle

pub fn new(txn_id: TxnId, tx: Sender) -> Self

pub fn begin(&mut self) -> Result<()>

pub async fn write_chunk(&self, chunk: StreamChunk) -> Result<()>

pub async fn end(self) -> Result<()>

pub async fn end_returning_epoch(self) -> Result<Epoch>

pub fn rollback(self) -> Result<Receiver<usize>>

fn rollback_inner(&mut self) -> Result<Receiver<usize>>

async fn write_txn_data_msg(&self, txn_msg: TxnMsg) -> Result<Receiver<usize>>

Asynchronously write txn messages into table. Changes written here will be simply passed to the associated streaming task via channel, and then be materialized to storage there.

Returns an oneshot channel which will be notified when the chunk is taken by some reader, and the usize represents the cardinality of this chunk.

fn write_txn_control_msg(&self, txn_msg: TxnMsg) -> Result<Receiver<usize>>

Same as the write_txn_data_msg, but it is not an async function and send control message without permit acquiring.

fn write_txn_control_msg_returning_epoch( &self, txn_msg: TxnMsg, ) -> Result<Receiver<usize>>

Trait Implementations

impl Drop for WriteHandle

fn drop(&mut self)

Executes the destructor for this type.