lock-db 0.2.0

Lock manager and deadlock detection for Rust databases - row/range locks, multiple granularities, and wait-for cycle detection.
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

//! The shortest end-to-end use of the lock manager.
//!
//! Run with: `cargo run --example quick_start`

use lock_db::prelude::*;

fn main() {
    let lm = LockManager::new();
    let row = ResourceId::new(1);
    let writer = TxnId::new(1);
    let reader = TxnId::new(2);

    // The writer takes the row exclusively.
    lm.try_acquire(writer, row, LockMode::Exclusive)
        .expect("row is free");
    println!("txn {} holds row {} exclusively", writer.get(), row.get());

    // A concurrent reader is refused while the write lock is held.
    match lm.try_acquire(reader, row, LockMode::Shared) {
        Err(LockError::Conflict) => {
            println!("txn {} was refused: row is write-locked", reader.get());
        }
        other => panic!("expected a conflict, got {other:?}"),
    }

    // Once the writer releases, the reader gets in.
    lm.release(writer, row).expect("writer holds the row");
    lm.try_acquire(reader, row, LockMode::Shared)
        .expect("row is free for reading");
    println!("txn {} now holds row {} shared", reader.get(), row.get());

    lm.release(reader, row).expect("reader holds the row");
    assert_eq!(lm.holder_count(row), 0);
    println!("row {} is free", row.get());
}