qdrant-edge 0.8.0

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

mod lifecycle;
mod live_reload;
mod payload_storage_read;

use crate::blobstore::BlobstoreReader;
use crate::common::universal_io::UniversalRead;

use crate::segment::types::Payload;

/// Read-only counterpart to [`super::mmap_payload_storage::MmapPayloadStorage`].
///
/// Backed by a [`BlobstoreReader`] over generic [`UniversalRead`] instead of a
/// writable [`blobstore::Blobstore`]. Unlike the read-only field indexes there
/// is no in-memory index to rebuild: [`Payload`] values are read straight from
/// the reader, so [`PayloadStorageRead`](super::PayloadStorageRead) forwards
/// directly to it. Opened via [`Self::open`] (see [`lifecycle`]); provides no
/// mutation surface.
pub struct ReadOnlyPayloadStorage<S: UniversalRead> {
    storage: BlobstoreReader<Payload, S>,
}

#[cfg(test)]
mod tests {
    use crate::common::counter::hardware_counter::HardwareCounterCell;
    use crate::common::universal_io::{MmapFile, Populate, ReadOnly, UniversalRead, UniversalReadFileOps};
    use rstest::rstest;
    use tempfile::TempDir;

    use super::ReadOnlyPayloadStorage;
    use crate::segment::payload_json;
    use crate::segment::payload_storage::payload_storage_impl::PayloadStorageImpl;
    use crate::segment::payload_storage::{PayloadStorage, PayloadStorageRead};

    /// Write payloads through the writable mmap storage, then reopen the same
    /// files read-only through the write-enforced `ReadOnly<MmapFile>` backend
    /// and assert the reader returns what was written.
    #[rstest]
    fn read_only_payload_storage_round_trip(
        #[values(Populate::No, Populate::PreferBackground)] populate: Populate,
    ) {
        let dir = TempDir::with_prefix("read_only_payload").unwrap();
        let hw_counter = HardwareCounterCell::new();

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

        {
            let mut storage: PayloadStorageImpl =
                PayloadStorageImpl::open_or_create(dir.path().to_path_buf(), false).unwrap();
            for i in 0..5 {
                storage.set(i, &payload, &hw_counter).unwrap();
            }
            // Flush so the reader observes the data on disk.
            storage.flusher()().unwrap();
        }

        // `S = ReadOnly<MmapFile>` → the write-enforced backend (every open
        // asserted non-writable), usable because the gridstore reader opens
        // read-only.
        type RoFs = <ReadOnly<MmapFile> as UniversalRead>::Fs;
        let fs = RoFs::from_context(Default::default()).unwrap();
        let storage: ReadOnlyPayloadStorage<ReadOnly<MmapFile>> =
            ReadOnlyPayloadStorage::open(&fs, dir.path().to_path_buf(), populate).unwrap();

        assert_eq!(storage.is_on_disk(), !populate.to_bool::<MmapFile>());
        for i in 0..5 {
            assert_eq!(storage.get(i, &hw_counter).unwrap(), payload);
        }
        // An unwritten point reads back as an empty payload.
        assert_eq!(storage.get(99, &hw_counter).unwrap(), payload_json! {});
    }
}