qdrant-edge 0.7.1

A lightweight, in-process vector search engine designed for embedded devices, autonomous systems, and mobile agents.
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

use std::path::Path;

use crate::common::counter::hardware_counter::HardwareCounterCell;
use rstest::rstest;

use super::PayloadStorage;
use super::mmap_payload_storage::MmapPayloadStorage;
use crate::segment::payload_json;

fn test_trait_impl<S: PayloadStorage>(open: impl Fn(&Path) -> S) {
    let dir = tempfile::tempdir().unwrap();
    let mut storage = open(dir.path());

    assert_eq!(storage.get_storage_size_bytes().unwrap(), 0);

    let payload = payload_json! {
        "a": "some text",
    };

    let hw_counter = HardwareCounterCell::new();

    // set
    storage.set(0, &payload, &hw_counter).unwrap();
    assert_eq!(storage.get(0, &hw_counter).unwrap(), payload);

    // set on existing
    let payload_to_merge = payload_json! {
        "zzz": "some other text",
    };

    storage.set(0, &payload_to_merge, &hw_counter).unwrap();

    let stored = storage.get(0, &hw_counter).unwrap();
    assert_eq!(
        stored,
        payload_json! {
            "a": "some text",
            "zzz": "some other text",
        },
    );

    // set_by_key
    let nested_payload = payload_json! {
        "layer2": true,
    };
    storage
        .set_by_key(
            0,
            &nested_payload,
            &"layer1".try_into().unwrap(),
            &hw_counter,
        )
        .unwrap();
    let stored = storage.get(0, &hw_counter).unwrap();

    assert_eq!(
        stored,
        payload_json! {
            "a": "some text",
            "zzz": "some other text",
            "layer1": {
                "layer2": true,
            }
        },
    );

    // delete key
    storage
        .delete(0, &"layer1".try_into().unwrap(), &hw_counter)
        .unwrap();
    let stored = storage.get(0, &hw_counter).unwrap();
    assert_eq!(
        stored,
        payload_json! {
            "a": "some text",
            "zzz": "some other text",
        },
    );

    // overwrite
    let new_payload = payload_json! {
        "new": "new text",
        "other_new": "other new text",
    };
    storage.overwrite(0, &new_payload, &hw_counter).unwrap();
    let stored = storage.get(0, &hw_counter).unwrap();
    assert_eq!(stored, new_payload);

    storage.clear(0, &hw_counter).unwrap();
    assert_eq!(storage.get(0, &hw_counter).unwrap(), payload_json! {});

    for i in 1..10 {
        storage.set(i, &payload, &hw_counter).unwrap();
    }

    let assert_payloads = |storage: &S| {
        storage
            .iter(
                |key, value| {
                    if key == 0 {
                        assert_eq!(value, &payload_json! {});
                        return Ok(true);
                    }
                    assert_eq!(value, &payload);
                    Ok(true)
                },
                &hw_counter,
            )
            .unwrap();
    };

    assert_payloads(&storage);
    eprintln!("storage is correct before drop");

    // flush, drop, and reopen
    storage.flusher()().unwrap();
    drop(storage);
    let storage = open(dir.path());

    // check if the data is still there
    assert_payloads(&storage);
    eprintln!("storage is correct after drop");

    assert!(storage.get_storage_size_bytes().unwrap() > 0);
}

#[rstest]
fn test_mmap_storage(#[values(false, true)] populate: bool) {
    test_trait_impl(|path| {
        MmapPayloadStorage::open_or_create(path.to_path_buf(), populate).unwrap()
    });
}