Struct BatchWriteTransaction 

pub struct BatchWriteTransaction { /* private fields */ }

A transaction for executing batch writes.

Batch writes are not guaranteed to be atomic across mutation groups. All mutations within a group are applied atomically.

Implementations

impl BatchWriteTransaction

pub async fn execute_streaming<I>( self, groups: I, ) -> Result<BatchWriteResponseStream>

where I: IntoIterator<Item = MutationGroup>,

Executes the batch write and returns a stream of responses.

Example

let client = Spanner::builder().build().await?;
let db = client.database_client("projects/p/instances/i/databases/d").build().await?;

let mutation = Mutation::new_insert_builder("Users")
    .set("UserId").to(&1)
    .build();
let group = MutationGroup::new(vec![mutation]);

let tx = db.batch_write_transaction().build();
let mut stream = tx.execute_streaming(vec![group]).await?;

while let Some(response) = stream.next().await {
    let response = response?;
    if let Some(status) = response.status.as_ref().filter(|s| s.code != Code::Ok as i32) {
        eprintln!("Error applying groups {:?}: {}", response.indexes, status.message);
    } else {
        println!("Applied groups: {:?}", response.indexes);
    }
}

This method sends the mutation groups to Spanner and returns the responses as a stream. Each response includes a status code that indicates whether the mutation groups that it references were applied successfully.

The method does not handle any errors, including retryable errors like Aborted. The caller is responsible for handling any errors and for retrying the transaction in case it is aborted by Spanner.