Struct google_cloud_spanner::retry::TransactionRetrySetting

pub struct TransactionRetrySetting {
    pub inner: RetrySetting,
}

Fields

inner: RetrySetting

Implementations

impl TransactionRetrySetting

pub fn new(codes: Vec<Code>) -> Self

Examples found in repository

src/retry.rs (line 118)

    fn default() -> Self {
        TransactionRetrySetting::new(vec![Code::Aborted])
    }

src/client.rs (line 338)

    pub async fn partitioned_update_with_option(
        &self,
        stmt: Statement,
        options: PartitionedUpdateOption,
    ) -> Result<i64, TxError> {
        let ro = TransactionRetrySetting::new(vec![Code::Aborted, Code::Internal]);
        let session = Some(self.get_session().await?);

        // reuse session
        invoke_fn(
            options.begin_options.cancel.clone(),
            Some(ro),
            |session| async {
                let mut tx =
                    match ReadWriteTransaction::begin_partitioned_dml(session.unwrap(), options.begin_options.clone())
                        .await
                    {
                        Ok(tx) => tx,
                        Err(e) => return Err((TxError::GRPC(e.status), Some(e.session))),
                    };
                let qo = match options.query_options.clone() {
                    Some(o) => o,
                    None => QueryOptions::default(),
                };
                tx.update_with_option(stmt.clone(), qo)
                    .await
                    .map_err(|e| (TxError::GRPC(e), tx.take_session()))
            },
            session,
        )
        .await
    }

Trait Implementations

impl Clone for TransactionRetrySetting

fn clone(&self) -> TransactionRetrySetting

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for TransactionRetrySetting

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for TransactionRetrySetting

fn default() -> Self

Returns the “default value” for a type.

impl<E> Retry<E, TransactionCondition<E>> for TransactionRetrySettingwhere
    E: TryAs<Status>,

fn strategy(&self) -> Take<ExponentialBackoff>

fn condition(&self) -> TransactionCondition<E>