noxu-txn 4.1.0

Transaction management and locking for Noxu DB
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

//! Lock grant result type.
//!

/// Result of a lock attempt.
///
/// Indicates whether a lock was granted immediately, must wait, was promoted,
/// or denied for non-blocking requests.
///
///
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum LockGrantType {
    /// New lock granted immediately.
    New,

    /// Must wait for new lock (another locker holds a conflicting lock).
    WaitNew,

    /// Lock promoted from read to write (or other upgrade).
    Promotion,

    /// Must wait for promotion (other lockers hold conflicting locks).
    WaitPromotion,

    /// Lock already held at requested level, no action needed.
    Existing,

    /// Non-blocking request denied (would have required waiting).
    Denied,

    /// Must restart due to range conflict (RangeRestartException).
    WaitRestart,

    /// No lock needed (NONE type requested for dirty reads).
    NoneNeeded,
}

impl LockGrantType {
    /// Returns true if the lock was granted immediately (no waiting).
    #[inline]
    pub fn is_granted(self) -> bool {
        matches!(
            self,
            LockGrantType::New
                | LockGrantType::Promotion
                | LockGrantType::Existing
        )
    }

    /// Returns true if the locker must wait.
    #[inline]
    pub fn must_wait(self) -> bool {
        matches!(
            self,
            LockGrantType::WaitNew
                | LockGrantType::WaitPromotion
                | LockGrantType::WaitRestart
        )
    }

    /// Returns true if this is a promotion (upgrade of existing lock).
    #[inline]
    pub fn is_promotion(self) -> bool {
        matches!(self, LockGrantType::Promotion | LockGrantType::WaitPromotion)
    }

    /// Returns true if the request was denied.
    #[inline]
    pub fn is_denied(self) -> bool {
        self == LockGrantType::Denied
    }

    /// Returns true if a restart is required.
    #[inline]
    pub fn is_restart(self) -> bool {
        self == LockGrantType::WaitRestart
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_is_granted() {
        assert!(LockGrantType::New.is_granted());
        assert!(LockGrantType::Promotion.is_granted());
        assert!(LockGrantType::Existing.is_granted());
        assert!(!LockGrantType::WaitNew.is_granted());
        assert!(!LockGrantType::WaitPromotion.is_granted());
        assert!(!LockGrantType::Denied.is_granted());
        assert!(!LockGrantType::WaitRestart.is_granted());
        assert!(!LockGrantType::NoneNeeded.is_granted());
    }

    #[test]
    fn test_must_wait() {
        assert!(LockGrantType::WaitNew.must_wait());
        assert!(LockGrantType::WaitPromotion.must_wait());
        assert!(LockGrantType::WaitRestart.must_wait());
        assert!(!LockGrantType::New.must_wait());
        assert!(!LockGrantType::Promotion.must_wait());
        assert!(!LockGrantType::Existing.must_wait());
        assert!(!LockGrantType::Denied.must_wait());
        assert!(!LockGrantType::NoneNeeded.must_wait());
    }

    #[test]
    fn test_is_promotion() {
        assert!(LockGrantType::Promotion.is_promotion());
        assert!(LockGrantType::WaitPromotion.is_promotion());
        assert!(!LockGrantType::New.is_promotion());
        assert!(!LockGrantType::WaitNew.is_promotion());
        assert!(!LockGrantType::Existing.is_promotion());
    }

    #[test]
    fn test_is_denied() {
        assert!(LockGrantType::Denied.is_denied());
        assert!(!LockGrantType::New.is_denied());
        assert!(!LockGrantType::WaitNew.is_denied());
        assert!(!LockGrantType::Existing.is_denied());
    }

    #[test]
    fn test_is_restart() {
        assert!(LockGrantType::WaitRestart.is_restart());
        assert!(!LockGrantType::WaitNew.is_restart());
        assert!(!LockGrantType::WaitPromotion.is_restart());
        assert!(!LockGrantType::New.is_restart());
    }
}