Enum google_api_proto::google::spanner::v1::read_request::LockHint

#[repr(i32)]
pub enum LockHint {
    Unspecified = 0,
    Shared = 1,
    Exclusive = 2,
}

A lock hint mechanism for reads done within a transaction.

Variants

Unspecified = 0

Default value.

LOCK_HINT_UNSPECIFIED is equivalent to LOCK_HINT_SHARED.

Shared = 1

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 = 2

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 should not be considered equivalent to a mutex. In other words, you should not 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.

Implementations

impl LockHint

pub fn is_valid(value: i32) -> bool

Returns true if value is a variant of LockHint.

pub fn from_i32(value: i32) -> Option<LockHint>

👎Deprecated: Use the TryFrom<i32> implementation instead

Converts an i32 to a LockHint, or None if value is not a valid variant.

impl LockHint

pub fn as_str_name(&self) -> &'static str

String value of the enum field names used in the ProtoBuf definition.

The values are not transformed in any way and thus are considered stable (if the ProtoBuf definition does not change) and safe for programmatic use.

pub fn from_str_name(value: &str) -> Option<Self>

Creates an enum from field names used in the ProtoBuf definition.

Trait Implementations

impl Clone for LockHint

fn clone(&self) -> LockHint

Returns a copy 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() -> LockHint

Returns the “default value” for a type.

impl From<LockHint> for i32

fn from(value: LockHint) -> i32

Converts to this type from the input type.

impl Hash for LockHint

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for LockHint

fn cmp(&self, other: &LockHint) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl PartialEq for LockHint

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialOrd for LockHint

fn partial_cmp(&self, other: &LockHint) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl TryFrom<i32> for LockHint

type Error = UnknownEnumValue

The type returned in the event of a conversion error.

fn try_from(value: i32) -> Result<LockHint, UnknownEnumValue>

Performs the conversion.

impl Copy for LockHint

impl Eq for LockHint

impl StructuralPartialEq for LockHint