kitedb 0.2.6

High-performance embedded graph database
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

//! Stress/soak tests for SingleFileDB

use std::collections::HashSet;

use super::open::{close_single_file, open_single_file, SingleFileOpenOptions, SyncMode};
use super::SingleFileDB;

fn open_stress_db(path: &std::path::Path) -> SingleFileDB {
  open_single_file(
    path,
    SingleFileOpenOptions::new().sync_mode(SyncMode::Normal),
  )
  .unwrap()
}

fn open_soak_db(path: &std::path::Path) -> SingleFileDB {
  open_single_file(
    path,
    SingleFileOpenOptions::new()
      .sync_mode(SyncMode::Normal)
      .wal_size(64 * 1024 * 1024)
      .auto_checkpoint(true)
      .checkpoint_threshold(0.7)
      .background_checkpoint(false),
  )
  .unwrap()
}

#[test]
fn test_single_file_stress_checkpoint_reopen() {
  let temp_dir = tempfile::tempdir().unwrap();
  let db_path = temp_dir.path().join("stress-single-file.kitedb");

  let mut expected_keys: HashSet<String> = HashSet::new();
  let mut next_id = 0u64;

  for cycle in 0..8 {
    let db = open_stress_db(&db_path);

    for _batch in 0..4 {
      db.begin(false).unwrap();

      for _ in 0..25 {
        let key = format!("n{next_id}");
        let node_id = db.create_node(Some(&key)).unwrap();
        let _ = db.set_node_prop_by_name(
          node_id,
          "name",
          crate::types::PropValue::String(key.clone()),
        );
        expected_keys.insert(key);
        next_id += 1;
      }

      // Create a few edges per batch
      for i in 0..10 {
        let src_key = format!("n{}", next_id.saturating_sub(1 + i));
        let dst_key = format!("n{}", next_id.saturating_sub(1 + ((i + 1) % 10)));
        if let (Some(src), Some(dst)) = (db.get_node_by_key(&src_key), db.get_node_by_key(&dst_key))
        {
          let _ = db.add_edge_by_name(src, "FOLLOWS", dst);
        }
      }

      db.commit().unwrap();
    }

    if cycle % 3 == 2 {
      db.checkpoint().unwrap();
    }

    close_single_file(db).unwrap();

    // Reopen and validate a few invariants
    let db = open_stress_db(&db_path);
    for key in expected_keys.iter().take(20) {
      assert!(db.get_node_by_key(key).is_some());
    }
    close_single_file(db).unwrap();
  }
}

#[test]
#[ignore]
fn test_single_file_soak_long_run() {
  let temp_dir = tempfile::tempdir().unwrap();
  let db_path = temp_dir.path().join("soak-single-file.kitedb");

  let mut expected_keys: HashSet<String> = HashSet::new();
  let mut next_id = 0u64;

  for cycle in 0..50 {
    let db = open_soak_db(&db_path);

    for _batch in 0..10 {
      db.begin(false).unwrap();
      for _ in 0..50 {
        let key = format!("n{next_id}");
        let node_id = db.create_node(Some(&key)).unwrap();
        let _ = db.set_node_prop_by_name(
          node_id,
          "name",
          crate::types::PropValue::String(key.clone()),
        );
        expected_keys.insert(key);
        next_id += 1;
      }
      db.commit().unwrap();
    }

    if cycle % 5 == 4 {
      db.checkpoint().unwrap();
    }

    close_single_file(db).unwrap();
  }

  let db = open_soak_db(&db_path);
  assert_eq!(db.count_nodes() as usize, expected_keys.len());
  close_single_file(db).unwrap();
}