Struct OwnedProllyTransaction 

pub struct OwnedProllyTransaction<S>
where
    S: Store + ManifestStore + TransactionalStore,
{ /* private fields */ }

A strict optimistic transaction that owns a cloned store handle.

This is useful for FFI bindings, where a transaction object needs to live independently from a borrowed Rust stack frame. Normal Rust callers should prefer Prolly::begin_transaction or Prolly::transaction.

Implementations

impl<S> OwnedProllyTransaction<S>

where S: Store + ManifestStore + TransactionalStore + Clone,

pub fn create(&self) -> Tree

Create an empty tree using the base manager’s config.

pub fn get(&self, tree: &Tree, key: &[u8]) -> Result<Option<Vec<u8>>, Error>

Get a value from a tree, including nodes staged in this transaction.

pub fn put( &self, tree: &Tree, key: Vec<u8>, value: Vec<u8>, ) -> Result<Tree, Error>

Insert or update a key/value pair, staging rewritten nodes.

pub fn delete(&self, tree: &Tree, key: &[u8]) -> Result<Tree, Error>

Delete a key, staging rewritten nodes.

pub fn batch( &self, tree: &Tree, mutations: Vec<Mutation>, ) -> Result<Tree, Error>

Apply a batch of logical map mutations inside the transaction.

pub fn load_named_root(&self, name: &[u8]) -> Result<Option<Tree>, Error>

Load a named root and add it to the transaction read set.

pub fn publish_named_root(&self, name: &[u8], tree: &Tree) -> Result<(), Error>

Stage an unconditional named-root publish.

pub fn delete_named_root(&self, name: &[u8]) -> Result<(), Error>

Stage an unconditional named-root delete.

pub fn compare_and_swap_named_root( &self, name: &[u8], expected: Option<&Tree>, new: Option<&Tree>, ) -> Result<NamedRootUpdate, Error>

Stage a named-root CAS update.

pub fn rollback(self)

Discard all staged writes. Dropping an uncommitted transaction has the same effect; this method is useful when callers want to be explicit.

pub fn commit(self) -> Result<TransactionUpdate, Error>

Commit staged node and named-root writes atomically.

Trait Implementations

impl<S> Drop for OwnedProllyTransaction<S>

where S: Store + ManifestStore + TransactionalStore,

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.