Enum LockHint 

#[non_exhaustive]
pub enum LockHint {
    Unspecified,
    Shared,
    Exclusive,
    UnknownValue(UnknownValue),
}

A lock hint mechanism for reads done within a transaction.

Working with unknown values

This enum is defined as #[non_exhaustive] because Google Cloud may add additional enum variants at any time. Adding new variants is not considered a breaking change. Applications should write their code in anticipation of:

• New values appearing in future releases of the client library, and
• New values received dynamically, without application changes.

Please consult the Working with enums section in the user guide for some guidelines.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Unspecified

Default value.

LOCK_HINT_UNSPECIFIED is equivalent to LOCK_HINT_SHARED.

Shared

Acquire shared locks.

By default when you perform a read as part of a read-write transaction, Spanner acquires shared read locks, which allows other reads to still access the data until your transaction is ready to commit. When your transaction is committing and writes are being applied, the transaction attempts to upgrade to an exclusive lock for any data you are writing. For more information about locks, see Lock modes.

Exclusive

Acquire exclusive locks.

Requesting exclusive locks is beneficial if you observe high write contention, which means you notice that multiple transactions are concurrently trying to read and write to the same data, resulting in a large number of aborts. This problem occurs when two transactions initially acquire shared locks and then both try to upgrade to exclusive locks at the same time. In this situation both transactions are waiting for the other to give up their lock, resulting in a deadlocked situation. Spanner is able to detect this occurring and force one of the transactions to abort. However, this is a slow and expensive operation and results in lower performance. In this case it makes sense to acquire exclusive locks at the start of the transaction because then when multiple transactions try to act on the same data, they automatically get serialized. Each transaction waits its turn to acquire the lock and avoids getting into deadlock situations.

Because the exclusive lock hint is just a hint, it shouldn’t be considered equivalent to a mutex. In other words, you shouldn’t use Spanner exclusive locks as a mutual exclusion mechanism for the execution of code outside of Spanner.

Note: Request exclusive locks judiciously because they block others from reading that data for the entire transaction, rather than just when the writes are being performed. Unless you observe high write contention, you should use the default of shared read locks so you don’t prematurely block other clients from reading the data that you’re writing to.

UnknownValue(UnknownValue)

If set, the enum was initialized with an unknown value.

Applications can examine the value using LockHint::value or LockHint::name.

Implementations

impl LockHint

pub fn value(&self) -> Option<i32>

Gets the enum value.

Returns None if the enum contains an unknown value deserialized from the string representation of enums.

pub fn name(&self) -> Option<&str>

Gets the enum value as a string.

Returns None if the enum contains an unknown value deserialized from the integer representation of enums.

Trait Implementations

impl Clone for LockHint

fn clone(&self) -> LockHint

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LockHint

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

Formats the value using the given formatter.

impl Default for LockHint

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for LockHint

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for LockHint

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

Formats the value using the given formatter.

impl From<&str> for LockHint

fn from(value: &str) -> Self

Converts to this type from the input type.

impl From<i32> for LockHint

fn from(value: i32) -> Self

Converts to this type from the input type.

impl PartialEq for LockHint

fn eq(&self, other: &LockHint) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for LockHint

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for LockHint