dynomite-vec 0.0.2

Vector storage + HNSW ANN index engine for the Dynomite Rust port
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

//! Integration tests for [`dynvec::storage::VectorStore`].

use std::collections::HashMap;
use std::sync::Arc;

use dynvec::distance::Distance;
use dynvec::encoding::Codec;
use dynvec::index::HnswParams;
use dynvec::storage::{IndexAlgorithm, MemoryBackend, StoreError, TableSchema, VectorStore};

fn schema(name: &str, dim: u16, codec: Codec, distance: Distance) -> TableSchema {
    TableSchema {
        name: name.to_string(),
        dim,
        codec,
        distance,
        hnsw: HnswParams::default(),
        algorithm: IndexAlgorithm::Hnsw,
    }
}

#[test]
fn put_get_delete_round_trips() {
    let store = VectorStore::in_memory();
    store
        .create_table(schema("rt", 4, Codec::Int8Quantized, Distance::Euclidean))
        .unwrap();
    let mut md = HashMap::new();
    md.insert("k".to_string(), serde_json::json!("v"));
    store
        .upsert("rt", b"alpha".to_vec(), &[0.1, 0.2, 0.3, 0.4], md.clone())
        .unwrap();
    let fetched = store.get("rt", b"alpha").unwrap().unwrap();
    assert_eq!(fetched.key, b"alpha");
    assert_eq!(fetched.metadata.get("k").unwrap(), &serde_json::json!("v"));
    assert!(store.delete("rt", b"alpha").unwrap());
    assert!(store.get("rt", b"alpha").unwrap().is_none());
}

#[test]
fn upsert_replaces_metadata_and_vector() {
    let store = VectorStore::in_memory();
    store
        .create_table(schema("u", 2, Codec::Fp16, Distance::Cosine))
        .unwrap();
    store
        .upsert("u", b"x".to_vec(), &[1.0, 0.0], HashMap::new())
        .unwrap();
    let mut md = HashMap::new();
    md.insert("v".to_string(), serde_json::json!(42));
    store.upsert("u", b"x".to_vec(), &[0.0, 1.0], md).unwrap();
    let fetched = store.get("u", b"x").unwrap().unwrap();
    assert_eq!(fetched.metadata.get("v").unwrap(), &serde_json::json!(42));
    // Search for [0,1] should return x first.
    let hits = store.search("u", &[0.0, 1.0], 1, None).unwrap();
    assert_eq!(hits[0].0.key, b"x");
}

#[test]
fn search_uses_distance_metric() {
    let store = VectorStore::in_memory();
    store
        .create_table(schema("d", 2, Codec::Fp16, Distance::DotProduct))
        .unwrap();
    store
        .upsert("d", b"p".to_vec(), &[10.0, 0.0], HashMap::new())
        .unwrap();
    store
        .upsert("d", b"q".to_vec(), &[0.0, 1.0], HashMap::new())
        .unwrap();
    let hits = store.search("d", &[5.0, 0.0], 1, None).unwrap();
    assert_eq!(hits[0].0.key, b"p");
}

#[test]
fn unknown_table_rejected() {
    let store = VectorStore::in_memory();
    assert!(matches!(
        store.upsert("missing", b"k".to_vec(), &[0.0], HashMap::new()),
        Err(StoreError::UnknownTable(_))
    ));
}

#[test]
fn dimension_mismatch_on_search() {
    let store = VectorStore::in_memory();
    store
        .create_table(schema("dm", 4, Codec::Int8Quantized, Distance::Euclidean))
        .unwrap();
    assert!(matches!(
        store.search("dm", &[0.0, 0.0], 1, None),
        Err(StoreError::DimensionMismatch { .. })
    ));
}

#[test]
fn rehydration_preserves_data() {
    let backend = Arc::new(MemoryBackend::new());
    {
        let store = VectorStore::open(backend.clone()).unwrap();
        store
            .create_table(schema("r", 3, Codec::Int8Quantized, Distance::Cosine))
            .unwrap();
        for i in 0..20_u8 {
            store
                .upsert(
                    "r",
                    format!("k{i}").into_bytes(),
                    &[f32::from(i), f32::from(i) * 0.5, f32::from(i) * 0.25],
                    HashMap::new(),
                )
                .unwrap();
        }
    }
    let reopened = VectorStore::open(backend).unwrap();
    let stats = reopened.stats("r").unwrap();
    assert_eq!(stats.live_rows, 20);
    assert_eq!(stats.dim, 3);
    let row = reopened.get("r", b"k7").unwrap().unwrap();
    assert_eq!(row.key, b"k7");
}

#[test]
fn delete_idempotent() {
    let store = VectorStore::in_memory();
    store
        .create_table(schema("idem", 2, Codec::Fp16, Distance::Cosine))
        .unwrap();
    store
        .upsert("idem", b"a".to_vec(), &[1.0, 2.0], HashMap::new())
        .unwrap();
    assert!(store.delete("idem", b"a").unwrap());
    assert!(!store.delete("idem", b"a").unwrap());
    assert!(!store.delete("idem", b"never").unwrap());
}