a3s-vec 0.1.8

Native Rust in-process vector database with zvec-compatible capabilities
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

//! Atomic storage for the optional derived-index cache.

use super::derived_file;
use crate::error::Result;
use std::path::{Path, PathBuf};

pub(super) fn read(root: &Path, max_index_cache_file_bytes: u64) -> Result<Option<Vec<u8>>> {
    derived_file::read(
        root,
        &relative_path(),
        max_index_cache_file_bytes,
        "derived index cache",
    )
}

pub(super) fn write(
    root: &Path,
    bytes: &[u8],
    sync: bool,
    max_index_cache_file_bytes: u64,
) -> Result<()> {
    derived_file::write(
        root,
        &relative_path(),
        bytes,
        max_index_cache_file_bytes,
        "derived index cache",
        sync,
    )
}

fn relative_path() -> PathBuf {
    Path::new("indexes").join("index-cache.bin")
}

#[cfg(test)]
mod tests {
    use super::{read, write};
    use crate::storage_ceilings::StorageCeilings;
    use tempfile::tempdir;

    #[test]
    fn cache_bytes_are_atomically_replaced() {
        let temporary = tempdir().expect("temporary directory must be available");
        let max = StorageCeilings::default().max_index_cache_file_bytes();
        assert!(read(temporary.path(), max)
            .expect("missing cache must be readable")
            .is_none());
        write(temporary.path(), b"first", false, max).expect("cache must write");
        assert_eq!(
            read(temporary.path(), max).expect("cache must read"),
            Some(b"first".to_vec())
        );
        write(temporary.path(), b"second", false, max).expect("cache must replace");
        assert_eq!(
            read(temporary.path(), max).expect("cache must read"),
            Some(b"second".to_vec())
        );
    }
}