Struct Transaction 

pub struct Transaction { /* private fields */ }

A buffered, commit-or-rollback transaction over AmateRSClient.

All writes are staged locally in a Vec<TransactionOp> until commit() is called. commit() issues a single execute_batch RPC so the writes are applied atomically. rollback() discards the local buffer with no network call.

Reading inside a transaction

Transaction::get first inspects the local buffer using last-write-wins semantics (reverse scan). A buffered Delete for the queried key returns Ok(None). If the key has not been written in this transaction the call falls through to the server.

Drop behaviour

Dropping a transaction that is still Active and has un-committed operations emits a tracing::warn! message. The buffer is silently discarded (no rollback RPC is issued — rollback is always local).

Construction

Prefer the factory method AmateRSClient::transaction over constructing directly.

Implementations

impl Transaction

pub fn new(client: Arc<AmateRSClient>, collection: impl Into<String>) -> Self

Create a new transaction bound to collection.

Use AmateRSClient::transaction instead of calling this directly.

pub fn set(&mut self, key: Key, value: CipherBlob) -> Result<()>

Stage a SET operation into the local buffer.

The write is not applied to the server until Self::commit is called.

Errors

Returns SdkError::InvalidState if the transaction is no longer active (already committed or rolled back).

pub fn delete(&mut self, key: Key) -> Result<()>

Stage a DELETE operation into the local buffer.

The delete is not applied to the server until Self::commit is called.

Errors

Returns SdkError::InvalidState if the transaction is no longer active.

pub async fn get(&self, key: &Key) -> Result<Option<CipherBlob>>

Read a key, consulting the local buffer first (last-write-wins), then the server.

• A buffered SET returns the in-flight value without a server round-trip.
• A buffered DELETE returns Ok(None) without a server round-trip.
• If the key has not been touched in this transaction, the call falls through to client.get().

Errors

Returns SdkError::InvalidState if the transaction is no longer active, or any error returned by the server fall-through.

pub async fn commit(&mut self) -> Result<()>

Commit all buffered operations atomically via execute_batch.

On success the transaction transitions to the Committed state. If the batch RPC fails, the state remains Active so the caller can retry or roll back.

An empty transaction commits instantly without a network round-trip.

Errors

• SdkError::InvalidState — already committed or rolled back.
• Any SdkError returned by the underlying execute_batch RPC.

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

Rollback by discarding the local buffer — no network call is made.

Errors

Returns SdkError::InvalidState if the transaction is already committed or rolled back.

pub fn pending_ops(&self) -> usize

Number of operations currently staged in the local buffer.

pub fn is_active(&self) -> bool

Returns true if the transaction is still active (not yet committed or rolled back).

pub fn collection(&self) -> &str

Returns the collection name this transaction is bound to.

Trait Implementations

impl Drop for Transaction

fn drop(&mut self)

Executes the destructor for this type.