async-skipdb 0.2.1

An embedded, in-memory, zero-copy, atomicity, consistency, MVCC, almost lock-free and serializable snapshot isolation database engine.
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

use async_skipdb::serializable::TokioSerializableDb;

#[derive(Debug)]
struct Person {
  name: String,
  hobby: String,
  age: u8,
}

#[tokio::main]
async fn main() {
  let db: TokioSerializableDb<u64, Person> = TokioSerializableDb::new().await;

  {
    let alice = Person {
      name: "Alice".to_string(),
      hobby: "swim".to_string(),
      age: 20,
    };
    let bob = Person {
      name: "Bob".to_string(),
      hobby: "run".to_string(),
      age: 30,
    };

    let mut txn = db.serializable_write().await;
    txn.insert(1, alice).unwrap();
    txn.insert(2, bob).unwrap();

    {
      let alice = txn.get(&1).unwrap().unwrap();
      assert_eq!(alice.value().name, "Alice");
      assert_eq!(alice.value().age, 20);
      assert_eq!(alice.value().hobby, "swim");
    }

    {
      // output:
      // 1: Person { name: "Alice", hobby: "swim", age: 20 }
      // 2: Person { name: "Bob", hobby: "run", age: 30 }
      for ent in txn.iter().unwrap() {
        println!("{}: {:?}", ent.key(), ent.value());
      }

      // output:
      // 2: Person { name: "Bob", hobby: "run", age: 30 }
      // 1: Person { name: "Alice", hobby: "swim", age: 20 }
      for ent in txn.iter_rev().unwrap() {
        println!("{}: {:?}", ent.key(), ent.value());
      }

      // output:
      // 2: Person { name: "Bob", hobby: "run", age: 30 }
      for ent in txn.range(1..).unwrap() {
        println!("{}: {:?}", ent.key(), ent.value());
      }

      // output:
      // 1: Person { name: "Alice", hobby: "swim", age: 20 }
      for ent in txn.range_rev(..2).unwrap() {
        println!("{}: {:?}", ent.key(), ent.value());
      }
    }

    txn.commit().await.unwrap();
  }

  {
    let txn = db.read().await;
    let alice = txn.get(&1).unwrap();
    assert_eq!(alice.value().name, "Alice");
    assert_eq!(alice.value().age, 20);
    assert_eq!(alice.value().hobby, "swim");

    let bob = txn.get(&2).unwrap();
    assert_eq!(bob.value().name, "Bob");
    assert_eq!(bob.value().age, 30);
    assert_eq!(bob.value().hobby, "run");

    // output:
    // 1: Person { name: "Alice", hobby: "swim", age: 20 }
    // 2: Person { name: "Bob", hobby: "run", age: 30 }
    for ent in txn.iter() {
      println!("{}: {:?}", ent.key(), ent.value());
    }

    // output:
    // 2: Person { name: "Bob", hobby: "run", age: 30 }
    // 1: Person { name: "Alice", hobby: "swim", age: 20 }
    for ent in txn.iter_rev() {
      println!("{}: {:?}", ent.key(), ent.value());
    }

    // output:
    // 2: Person { name: "Bob", hobby: "run", age: 30 }
    for ent in txn.range(1..) {
      println!("{}: {:?}", ent.key(), ent.value());
    }

    // output:
    // 1: Person { name: "Alice", hobby: "swim", age: 20 }
    for ent in txn.range(..2) {
      println!("{}: {:?}", ent.key(), ent.value());
    }
  }
}