Enum LockType 

pub enum LockType {
    Read,
    Write,
    RangeRead,
    RangeWrite,
    RangeInsert,
    None,
    Restart,
}

Lock types used in the transaction system.

Noxu DB uses hierarchical locking with five primary lock types. The conflict and upgrade matrices define how locks interact.

Variants

Read

Basic read lock on a record.

Allows multiple concurrent readers but blocks writers.

Write

Write lock on a record (exclusive).

Blocks all other lockers from reading or writing this record.

RangeRead

Range read lock - locks a range to prevent phantom inserts.

Similar to Read but also prevents inserts into the range.

RangeWrite

Range write lock - combines range and write locking.

Blocks all access and prevents inserts into the range.

RangeInsert

Range insert lock - used when inserting into a range.

Conflicts with range locks to trigger restart on phantom detection.

None

No lock requested (dirty read).

Special type indicating no locking should be performed.

Restart

Restart marker - not a real lock type.

Used internally to indicate a range restart is needed.

Implementations

impl LockType

pub fn is_write_lock(self) -> bool

Returns true if this is a write lock that modifies data.

Note: Per implementation, RangeInsert is NOT considered a write lock for the purposes of transaction commit/abort. Only Write and RangeWrite require undo information.

pub fn causes_restart(self) -> bool

Returns true if this lock type causes a restart when upgraded.

RangeRead and RangeWrite cause restarts in certain upgrade scenarios.

pub fn get_conflict(self, requested: LockType) -> LockConflict

Returns the conflict status between a held lock and a requested lock.

This implements the 5x5 conflict matrix from the:

             READ    WRITE   RANGE_R  RANGE_W  RANGE_I
READ        ALLOW   BLOCK   ALLOW    BLOCK    ALLOW
WRITE       BLOCK   BLOCK   BLOCK    BLOCK    ALLOW
RANGE_READ  ALLOW   BLOCK   ALLOW    BLOCK    BLOCK
RANGE_WRITE BLOCK   BLOCK   BLOCK    BLOCK    BLOCK
RANGE_INS   ALLOW   ALLOW   RESTART  RESTART  ALLOW

pub fn get_upgrade(self, requested: LockType) -> LockUpgrade

Returns the upgrade result when a locker holds this lock and requests another.

This implements the 5x5 upgrade matrix from the:

             READ           WRITE              RANGE_R            RANGE_W              RANGE_I
READ        EXISTING       WRITE_PROMOTE      RANGE_READ_IMMED   RANGE_WRITE_PROMOTE  ILLEGAL
WRITE       EXISTING       EXISTING           RANGE_WRITE_IMMED  RANGE_WRITE_IMMED    ILLEGAL
RANGE_READ  EXISTING       RANGE_WRITE_PROM   EXISTING           RANGE_WRITE_PROMOTE  ILLEGAL
RANGE_WRITE EXISTING       EXISTING           EXISTING           EXISTING             ILLEGAL
RANGE_INS   ILLEGAL        ILLEGAL            ILLEGAL            ILLEGAL              EXISTING

pub fn index(self) -> usize

Returns the array index for this lock type (0-4 for the 5 main types).

Used for indexing into statistics arrays.

Trait Implementations

impl Clone for LockType

fn clone(&self) -> LockType

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for LockType

impl Debug for LockType

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

Formats the value using the given formatter.

impl Eq for LockType

impl Hash for LockType

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 LockType

fn cmp(&self, other: &LockType) -> 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,

Restrict a value to a certain interval.

impl PartialEq for LockType

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

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

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

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl StructuralPartialEq for LockType