Struct TxWrite 

pub struct TxWrite<I: DatabaseIdentifier>(/* private fields */);

A read-write database transaction handle.

Obtained from DbWrite::begin. Exposes the same operations as DbWrite and DbRead, but every operation runs on a single connection inside a real SQL transaction. Call TxWrite::commit to persist the changes, TxWrite::rollback to discard them, or drop without committing to roll back.

Implementations

impl<I: DatabaseIdentifier> TxWrite<I>

pub fn identifier(&self) -> &I

Get a reference to the database identifier.

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

Commit the transaction, persisting all changes.

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

Roll back the transaction, discarding all changes.

impl TxWrite<Conductor>

pub async fn set_conductor_tag(&mut self, tag: &str) -> Result<()>

Set the conductor tag.

pub async fn put_app_interface( &mut self, port: i64, id: &str, model: &AppInterfaceModel, ) -> Result<()>

Insert or update an app interface.

pub async fn put_signal_subscription( &mut self, interface_port: i64, interface_id: &str, app_id: &str, filters_blob: &[u8], ) -> Result<()>

Save a signal subscription for an app interface.

pub async fn delete_signal_subscriptions( &mut self, interface_port: i64, interface_id: &str, ) -> Result<()>

Delete all signal subscriptions for an app interface.

pub async fn delete_app_interface(&mut self, port: i64, id: &str) -> Result<()>

Delete an app interface.

pub async fn put_installed_app( &mut self, app_id: &str, app: &InstalledAppCommon, status: &AppStatus, ) -> Result<()>

Insert or update an installed app.

pub async fn delete_installed_app(&mut self, app_id: &str) -> Result<()>

Delete an installed app.

pub async fn witness_nonce( &mut self, agent: AgentPubKey, nonce: Nonce256Bits, now: Timestamp, expires: Timestamp, ) -> Result<WitnessNonceResult, Error>

Witness a nonce (check if it’s fresh and record it).

pub async fn block(&mut self, input: Block) -> Result<(), Error>

Append a block to the database.

impl TxWrite<Dht>

pub async fn insert_action( &mut self, action: &SignedActionHashed, record_validity: Option<RecordValidity>, ) -> Result<()>

Insert an Action row, storing its signature and pre-computed hash.

impl TxWrite<Dht>

pub async fn insert_cap_claim( &mut self, author: &AgentPubKey, tag: &str, grantor: &AgentPubKey, secret: &[u8], ) -> Result<()>

impl TxWrite<Dht>

pub async fn insert_cap_grant( &mut self, action_hash: &ActionHash, cap_access: i64, tag: Option<&str>, ) -> Result<()>

impl TxWrite<Dht>

pub async fn acquire_chain_lock( &mut self, author: &AgentPubKey, subject: &[u8], expires_at: Timestamp, now: Timestamp, ) -> Result<bool>

Try to acquire the chain lock for author. See the inner chain_lock::acquire_chain_lock for the full rule set. Returns true when the caller now holds the lock.

pub async fn release_chain_lock(&mut self, author: &AgentPubKey) -> Result<()>

pub async fn prune_expired_chain_locks(&mut self, now: Timestamp) -> Result<()>

impl TxWrite<Dht>

pub async fn insert_chain_op(&mut self, op: InsertChainOp<'_>) -> Result<()>

impl TxWrite<Dht>

pub async fn insert_chain_op_publish( &mut self, op_hash: &DhtOpHash, last_publish_time: Option<Timestamp>, receipts_complete: Option<bool>, ) -> Result<()>

impl TxWrite<Dht>

pub async fn insert_deleted_link_index( &mut self, action_hash: &ActionHash, create_link_hash: &ActionHash, ) -> Result<()>

impl TxWrite<Dht>

pub async fn insert_deleted_record_index( &mut self, action_hash: &ActionHash, deletes_action_hash: &ActionHash, deletes_entry_hash: &EntryHash, ) -> Result<()>

impl TxWrite<Dht>

pub async fn insert_entry( &mut self, hash: &EntryHash, entry: &Entry, ) -> Result<()>

pub async fn insert_private_entry( &mut self, hash: &EntryHash, author: &AgentPubKey, entry: &Entry, ) -> Result<()>

impl TxWrite<Dht>

pub async fn insert_limbo_chain_op( &mut self, op: InsertLimboChainOp<'_>, ) -> Result<()>

pub async fn delete_limbo_chain_op(&mut self, hash: DhtOpHash) -> Result<()>

impl TxWrite<Dht>

pub async fn insert_limbo_warrant( &mut self, w: InsertLimboWarrant<'_>, ) -> Result<()>

pub async fn delete_limbo_warrant(&mut self, hash: DhtOpHash) -> Result<()>

impl TxWrite<Dht>

pub async fn insert_link_index( &mut self, action_hash: &ActionHash, base_hash: &AnyLinkableHash, zome_index: u8, link_type: u8, tag: Option<&[u8]>, ) -> Result<()>

impl TxWrite<Dht>

pub async fn insert_updated_record_index( &mut self, action_hash: &ActionHash, original_action_hash: &ActionHash, original_entry_hash: &EntryHash, ) -> Result<()>

impl TxWrite<Dht>

pub async fn insert_validation_receipt( &mut self, hash: &DhtOpHash, op_hash: &DhtOpHash, validators: &[u8], signature: &[u8], when_received: Timestamp, ) -> Result<()>

impl TxWrite<Dht>

pub async fn insert_warrant(&mut self, w: InsertWarrant<'_>) -> Result<()>

impl TxWrite<Dht>

pub async fn insert_warrant_publish( &mut self, warrant_hash: &DhtOpHash, last_publish_time: Option<Timestamp>, ) -> Result<()>

impl TxWrite<PeerMetaStore>

pub async fn put( &mut self, peer_url: &str, meta_key: &str, meta_value: &[u8], expires_at_secs: Option<i64>, ) -> Result<()>

Insert or replace a peer metadata entry.

expires_at is seconds since the Unix epoch.

pub async fn delete(&mut self, peer_url: &str, meta_key: &str) -> Result<()>

Delete a specific peer metadata entry.

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

Delete all expired entries. Returns the number of rows removed.

impl TxWrite<Wasm>

pub async fn put_wasm(&mut self, wasm: DnaWasmHashed) -> Result<()>

Store WASM bytecode.

pub async fn put_dna_def( &mut self, agent: &AgentPubKey, dna_def: &DnaDef, ) -> Result<()>

Store a DNA definition and its associated zomes.

Within a TxWrite, this runs as a SAVEPOINT nested inside the outer transaction — it is atomic with the rest of the transaction.

pub async fn put_entry_def( &mut self, key: Vec<u8>, entry_def: &EntryDef, ) -> Result<()>

Store an entry definition.

Trait Implementations

impl<I: DatabaseIdentifier> AsMut<TxRead<I>> for TxWrite<I>

Mutably borrow a TxRead from a TxWrite.

Read operations on a transaction require &mut self (the transaction owns its connection), so reading through a TxWrite goes through AsMut rather than AsRef.

fn as_mut(&mut self) -> &mut TxRead<I>

Converts this type into a mutable reference of the (usually inferred) input type.

impl<I: DatabaseIdentifier> AsRef<TxRead<I>> for TxWrite<I>

Borrow a TxRead from a TxWrite.

fn as_ref(&self) -> &TxRead<I>

Converts this type into a shared reference of the (usually inferred) input type.

impl<I: DatabaseIdentifier> From<TxWrite<I>> for TxRead<I>

Conversion from TxWrite to TxRead.

fn from(write: TxWrite<I>) -> Self

Converts to this type from the input type.