sqry-db 10.0.2

Salsa-style incremental computation engine for sqry semantic code search
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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

//! Integration tests for `ShardedCache` and `CachedResult` validation.

use smallvec::SmallVec;
use sqry_core::graph::unified::file::id::FileId;
use sqry_db::cache::{CachedResult, ShardedCache};
use sqry_db::dependency::FileDep;
use sqry_db::input::{FileInput, FileInputStore};
use sqry_db::query::QueryKey;

#[test]
fn cache_insert_and_retrieve_across_shards() {
    let cache = ShardedCache::new(64);

    // Insert into different shards
    for shard in 0..64 {
        let key = QueryKey::from_raw(shard as u64, 0);
        let result = CachedResult::new(format!("shard_{shard}"), SmallVec::new(), None, None);
        cache.insert(shard, key, result);
    }

    assert_eq!(cache.total_entries(), 64);

    // Retrieve from each shard
    for shard in 0..64 {
        let key = QueryKey::from_raw(shard as u64, 0);
        let val: Option<String> = cache.get_if_valid(shard, &key, |_| true);
        assert_eq!(val, Some(format!("shard_{shard}")));
    }
}

#[test]
fn cache_file_dep_invalidation_flow() {
    let cache = ShardedCache::new(4);
    let mut store = FileInputStore::new();
    store.insert(FileId::new(1), FileInput::new(Default::default()));
    store.insert(FileId::new(2), FileInput::new(Default::default()));

    // Insert with deps pointing to file 1 and 2 at revision 1
    let mut deps: SmallVec<[FileDep; 8]> = SmallVec::new();
    deps.push((FileId::new(1), 1));
    deps.push((FileId::new(2), 1));

    let key = QueryKey::from_raw(100, 0);
    let result = CachedResult::new(42u32, deps, None, None);
    cache.insert(0, key.clone(), result);

    // Should be valid
    let val: Option<u32> = cache.get_if_valid(0, &key, |c| c.validate_file_deps(&store));
    assert_eq!(val, Some(42));

    // Bump file 1 revision
    store
        .get_mut(FileId::new(1))
        .unwrap()
        .update(Default::default());

    // Should now be invalid
    let val: Option<u32> = cache.get_if_valid(0, &key, |c| c.validate_file_deps(&store));
    assert!(
        val.is_none(),
        "cache should be invalidated after file revision bump"
    );
}

#[test]
fn cache_edge_revision_invalidation() {
    let cache = ShardedCache::new(4);

    let key = QueryKey::from_raw(200, 0);
    let result = CachedResult::new(vec![1u32, 2, 3], SmallVec::new(), Some(5), None);
    cache.insert(0, key.clone(), result);

    // Valid when edge revision matches
    let current_edge_rev = 5u64;
    let val: Option<Vec<u32>> =
        cache.get_if_valid(0, &key, |c| c.edge_revision() == Some(current_edge_rev));
    assert_eq!(val, Some(vec![1, 2, 3]));

    // Invalid when edge revision advances
    let current_edge_rev = 6u64;
    let val: Option<Vec<u32>> =
        cache.get_if_valid(0, &key, |c| c.edge_revision() == Some(current_edge_rev));
    assert!(val.is_none());
}

#[test]
fn cache_metadata_revision_invalidation() {
    let cache = ShardedCache::new(4);

    let key = QueryKey::from_raw(300, 0);
    let result = CachedResult::new("unused_nodes".to_string(), SmallVec::new(), None, Some(3));
    cache.insert(0, key.clone(), result);

    // Valid when metadata revision matches
    let val: Option<String> = cache.get_if_valid(0, &key, |c| c.metadata_revision() == Some(3));
    assert_eq!(val, Some("unused_nodes".to_string()));

    // Invalid when metadata revision advances
    let val: Option<String> = cache.get_if_valid(0, &key, |c| c.metadata_revision() == Some(4));
    assert!(val.is_none());
}

#[test]
fn cache_concurrent_read_write() {
    use std::sync::Arc;
    use std::thread;

    let cache = Arc::new(ShardedCache::new(64));

    // Spawn writers
    let mut handles = vec![];
    for i in 0u64..8 {
        let cache = Arc::clone(&cache);
        handles.push(thread::spawn(move || {
            for j in 0u64..100 {
                let shard = ((i * 100 + j) % 64) as usize;
                let key = QueryKey::from_raw(i * 1000 + j, 0);
                let result = CachedResult::new((i, j), SmallVec::new(), None, None);
                cache.insert(shard, key, result);
            }
        }));
    }

    // Spawn readers
    for _ in 0..4 {
        let cache = Arc::clone(&cache);
        handles.push(thread::spawn(move || {
            for _ in 0..200 {
                let _ = cache.total_entries();
                let _ = cache.shard_entry_counts();
            }
        }));
    }

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

    // All writes should have succeeded
    assert!(cache.total_entries() > 0);
}