feoxdb 0.5.0

Iron-oxide fast embedded database - nanosecond-level key-value storage
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

use crate::core::store::FeoxStore;
use std::sync::Arc;
use std::thread;

#[test]
fn test_concurrent_inserts() {
    let store = Arc::new(FeoxStore::new(None).unwrap());
    let mut handles = vec![];

    for i in 0..10 {
        let store_clone = Arc::clone(&store);
        handles.push(thread::spawn(move || {
            for j in 0..100 {
                let key = format!("thread{}:key{}", i, j);
                let value = format!("value_{}_{}", i, j);
                store_clone
                    .insert(key.as_bytes(), value.as_bytes())
                    .unwrap();
            }
        }));
    }

    for handle in handles {
        handle.join().unwrap();
    }

    assert_eq!(store.len(), 1000);
}

#[test]
fn test_concurrent_mixed_operations() {
    let store = Arc::new(FeoxStore::new(None).unwrap());

    // Pre-populate
    for i in 0..100 {
        let key = format!("key_{}", i);
        store.insert(key.as_bytes(), b"initial").unwrap();
    }

    let mut handles = vec![];

    // Readers
    for _ in 0..5 {
        let store_clone = Arc::clone(&store);
        handles.push(thread::spawn(move || {
            for i in 0..100 {
                let key = format!("key_{}", i);
                let _ = store_clone.get(key.as_bytes());
            }
        }));
    }

    // Writers
    for t in 0..5 {
        let store_clone = Arc::clone(&store);
        handles.push(thread::spawn(move || {
            for i in 0..100 {
                let key = format!("key_{}", i);
                let value = format!("updated_by_{}", t);
                let _ = store_clone.insert(key.as_bytes(), value.as_bytes());
            }
        }));
    }

    // Deleters
    for _ in 0..2 {
        let store_clone = Arc::clone(&store);
        handles.push(thread::spawn(move || {
            for i in 90..100 {
                let key = format!("key_{}", i);
                let _ = store_clone.delete(key.as_bytes());
            }
        }));
    }

    for handle in handles {
        handle.join().unwrap();
    }
}

#[test]
fn test_concurrent_atomic_increments() {
    let store = Arc::new(FeoxStore::new(None).unwrap());

    let key = b"shared_counter";
    let zero: i64 = 0;
    store.insert(key, &zero.to_le_bytes()).unwrap();

    let mut handles = vec![];

    for _ in 0..10 {
        let store_clone = Arc::clone(&store);
        handles.push(thread::spawn(move || {
            for _ in 0..100 {
                store_clone.atomic_increment(key, 1).unwrap();
            }
        }));
    }

    for handle in handles {
        handle.join().unwrap();
    }

    // Should have exactly 1000 increments
    let final_value = store.atomic_increment(key, 0).unwrap();
    assert_eq!(final_value, 1000);
}