velesdb-core 5.1.0

High-performance vector database engine written in Rust
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

use super::*;

#[test]
fn test_clustered_index_basic() {
    let mut index = ClusteredIndex::new();

    index.insert(1, 10);
    index.insert(1, 20);
    index.insert(1, 30);

    assert_eq!(index.get_neighbors(1).len(), 3);
    assert!(index.contains(1, 10));
    assert!(index.contains(1, 20));
    assert!(index.contains(1, 30));
}

#[test]
fn test_clustered_index_multiple_nodes() {
    let mut index = ClusteredIndex::new();

    index.insert(1, 10);
    index.insert(1, 20);
    index.insert(2, 100);
    index.insert(2, 200);
    index.insert(3, 1000);

    assert_eq!(index.node_count(), 3);
    assert_eq!(index.edge_count(), 5);
    assert_eq!(index.neighbor_count(1), 2);
    assert_eq!(index.neighbor_count(2), 2);
    assert_eq!(index.neighbor_count(3), 1);
}

#[test]
fn test_clustered_index_no_duplicates() {
    let mut index = ClusteredIndex::new();

    index.insert(1, 10);
    index.insert(1, 10);
    index.insert(1, 10);

    assert_eq!(index.neighbor_count(1), 1);
}

#[test]
fn test_clustered_index_remove() {
    let mut index = ClusteredIndex::new();

    index.insert(1, 10);
    index.insert(1, 20);
    index.insert(1, 30);

    assert!(index.remove(1, 20));
    assert!(!index.contains(1, 20));
    assert_eq!(index.neighbor_count(1), 2);

    assert!(!index.remove(1, 99)); // Not present
}

#[test]
fn test_clustered_index_remove_node() {
    let mut index = ClusteredIndex::new();

    index.insert(1, 10);
    index.insert(1, 20);
    index.insert(2, 100);

    index.remove_node(1);

    assert_eq!(index.node_count(), 1);
    assert_eq!(index.neighbor_count(1), 0);
    assert_eq!(index.neighbor_count(2), 1);
}

#[test]
fn test_clustered_index_compaction() {
    let mut index = ClusteredIndex::new();

    // Create some data
    for i in 0..10 {
        for j in 0..5 {
            index.insert(i, j * 100);
        }
    }

    // Remove some to create fragmentation
    for i in 0..5 {
        index.remove_node(i);
    }

    let frag_before = index.fragmentation();
    assert!(frag_before > 0.0);

    index.compact();

    assert!(index.fragmentation().abs() < f64::EPSILON);
    assert_eq!(index.node_count(), 5);
}

#[test]
fn test_clustered_index_slot_reuse() {
    let mut index = ClusteredIndex::new();

    // Fill some data
    index.insert(1, 10);
    index.insert(1, 20);

    // Remove and add - should reuse slots
    index.remove_node(1);
    index.insert(2, 100);

    assert_eq!(index.node_count(), 1);
    assert!(index.contains(2, 100));
}