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
75
76
77
78
79
80
81
82
83
84
85
86
87

use std::marker::PhantomData;
use std::path::{Path, PathBuf};

use crate::blobstore::Blob;
use crate::common::bitvec::BitSlice;
use crate::common::universal_io::{CachedReadFs, UniversalRead, UniversalReadFs};

use super::super::Encodable;
use super::super::storage::read_only::ReadOnlyNumericIndexInner;
use super::ReadOnlyNumericIndex;
use crate::segment::common::operation_error::OperationResult;
use crate::segment::index::field_index::numeric_point::Numericable;
use crate::segment::index::field_index::on_disk_point_to_values::StoredValue;
use crate::segment::index::payload_config::IndexMutability;

impl<T: Encodable + Numericable + StoredValue + Send + Sync + Default, P, S: UniversalRead>
    ReadOnlyNumericIndex<T, P, S>
where
    Vec<T>: Blob,
{
    /// Schedule background prefetch for the appendable (Gridstore) format,
    /// forwarding to [`ReadOnlyNumericIndexInner::preopen_appendable`].
    pub fn preopen_appendable(
        fs: &impl CachedReadFs<File = S>,
        dir: PathBuf,
    ) -> OperationResult<bool> {
        ReadOnlyNumericIndexInner::preopen_appendable(fs, dir)
    }

    /// Schedule background prefetch for the immutable (mmap) format, forwarding
    /// to [`ReadOnlyNumericIndexInner::preopen_immutable`].
    pub fn preopen_immutable(
        fs: &impl CachedReadFs<File = S>,
        path: &Path,
        is_on_disk: bool,
    ) -> OperationResult<bool> {
        ReadOnlyNumericIndexInner::preopen_immutable(fs, path, is_on_disk)
    }

    /// Read-only mirror of [`NumericIndex::new_gridstore`][1]: forwards to
    /// [`ReadOnlyNumericIndexInner::open_appendable`] and wraps the inner with
    /// the typed payload-value phantom `P`.
    ///
    /// [1]: super::super::NumericIndex::new_gridstore
    pub fn open_appendable(
        fs: &impl UniversalReadFs<File = S>,
        dir: PathBuf,
    ) -> OperationResult<Option<Self>> {
        Ok(
            ReadOnlyNumericIndexInner::open_appendable(fs, dir)?.map(|inner| Self {
                inner,
                _phantom: PhantomData,
            }),
        )
    }

    /// Read-only mirror of [`NumericIndex::new_mmap`][1]: forwards to
    /// [`ReadOnlyNumericIndexInner::open_immutable`] and wraps the inner with
    /// the typed payload-value phantom `P`. `Ok(None)` propagates from the
    /// inner when the on-disk index doesn't exist.
    ///
    /// [1]: super::super::NumericIndex::new_mmap
    pub fn open_immutable(
        fs: &impl UniversalReadFs<File = S>,
        path: &Path,
        is_on_disk: bool,
        deleted_points: &BitSlice,
    ) -> OperationResult<Option<Self>> {
        Ok(
            ReadOnlyNumericIndexInner::open_immutable(fs, path, is_on_disk, deleted_points)?.map(
                |inner| Self {
                    inner,
                    _phantom: PhantomData,
                },
            ),
        )
    }

    /// Reports the on-disk format's mutability, forwarding to
    /// [`ReadOnlyNumericIndexInner::get_mutability_type`]. Mirrors the
    /// writable [`NumericIndex::get_mutability_type`][1].
    ///
    /// [1]: super::super::NumericIndex::get_mutability_type
    pub fn get_mutability_type(&self) -> IndexMutability {
        self.inner.get_mutability_type()
    }
}