Enum LockMode 

pub enum LockMode {
    Default,
    ReadUncommitted,
    ReadCommitted,
    Rmw,
}

Lock mode for read operations.

Specifies the locking behavior for a read operation. Controls isolation level and whether locks are acquired.

Variants

Default

Use the default isolation level for the cursor or transaction.

For transactional operations, this is typically read-committed. For non-transactional operations, this is read-uncommitted.

ReadUncommitted

Read without acquiring locks (dirty reads).

Reads may return data that is currently being modified by another transaction and may be rolled back. Provides maximum concurrency but minimal isolation.

ReadCommitted

Read with read-committed isolation.

A read lock is acquired but released when the cursor moves or the read operation completes. Prevents dirty reads but allows non-repeatable reads.

Rmw

Read-modify-write: acquire write lock on read.

Acquires a write lock immediately, even though the operation is a read. Use this when you intend to modify the record after reading it, to avoid deadlocks caused by lock upgrades.

Implementations

impl LockMode

pub fn allows_dirty_reads(&self) -> bool

Returns whether this mode allows dirty reads.

pub fn acquires_write_lock(&self) -> bool

Returns whether this mode acquires a write lock.

pub fn is_read_committed(&self) -> bool

Returns whether this mode provides read-committed isolation.

Trait Implementations

impl Clone for LockMode

fn clone(&self) -> LockMode

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for LockMode

impl Debug for LockMode

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

Formats the value using the given formatter.

impl Default for LockMode

fn default() -> LockMode

Returns the “default value” for a type.

impl Eq for LockMode

impl Hash for LockMode

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 PartialEq for LockMode

fn eq(&self, other: &LockMode) -> 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 StructuralPartialEq for LockMode