qdrant-edge 0.7.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
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

use std::fmt::{Debug, Write};
use std::hash::Hash;
use std::panic::{AssertUnwindSafe, catch_unwind};

use rand::RngExt;
use rand::distr::StandardUniform;
use rand::rngs::StdRng;
use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};

use crate::common::persisted_hashmap::Key;

pub trait TestKey: Key + Ord + PartialEq<Self::Owned> {
    type Owned: Clone + Ord + Hash + Debug;
    fn gen_key(rng: &mut StdRng, large: bool) -> Self::Owned;
    fn as_ref(owned: &Self::Owned) -> &Self;
    fn from_ref(this: &Self) -> Self::Owned;
}

impl TestKey for str {
    type Owned = String;
    fn gen_key(rng: &mut StdRng, large: bool) -> Self::Owned {
        let range = if large { 5_000..=10_000 } else { 5..=32 };
        (0..rng.random_range(range))
            .map(|_| rng.random_range(b'a'..=b'z') as char)
            .collect()
    }
    fn as_ref(owned: &Self::Owned) -> &Self {
        owned.as_str()
    }
    fn from_ref(this: &Self) -> Self::Owned {
        this.to_owned()
    }
}

impl TestKey for i64 {
    type Owned = i64;
    fn gen_key(rng: &mut StdRng, large: bool) -> Self::Owned {
        assert!(!large);
        rng.random()
    }
    fn as_ref(owned: &Self::Owned) -> &Self {
        owned
    }
    fn from_ref(this: &Self) -> Self::Owned {
        *this
    }
}

impl TestKey for u128 {
    type Owned = u128;
    fn gen_key(rng: &mut StdRng, large: bool) -> Self::Owned {
        assert!(!large);
        rng.random()
    }
    fn as_ref(owned: &Self::Owned) -> &Self {
        owned
    }
    fn from_ref(this: &Self) -> Self::Owned {
        *this
    }
}

pub trait TestValue:
    Copy + Ord + Debug + FromBytes + IntoBytes + Immutable + KnownLayout + Sized
{
    fn gen_value(rng: &mut StdRng) -> Self;
}
impl<T> TestValue for T
where
    T: Copy + Ord + Debug + FromBytes + IntoBytes + Immutable + KnownLayout,
    StandardUniform: rand::distr::Distribution<T>,
{
    fn gen_value(rng: &mut StdRng) -> T {
        rng.random()
    }
}

pub struct TestReport {
    success: bool,
    log: String,
}

pub struct Group<'a> {
    path: String,
    report: &'a mut TestReport,
}

impl TestReport {
    #[expect(clippy::new_without_default)]
    pub fn new() -> Self {
        Self {
            success: true,
            log: String::new(),
        }
    }

    pub fn group(&mut self, name: &str) -> Group<'_> {
        Group {
            path: name.to_string(),
            report: self,
        }
    }
}

impl Drop for TestReport {
    fn drop(&mut self) {
        eprintln!("{}", self.log);
        assert!(self.success, "Some checks failed");
    }
}

impl Group<'_> {
    pub fn group(&mut self, name: &str) -> Group<'_> {
        Group {
            path: format!("{}:{name}", self.path),
            report: self.report,
        }
    }

    pub fn check(&mut self, name: &str, f: impl FnOnce()) {
        let ok = catch_unwind(AssertUnwindSafe(f)).is_ok();
        let tag = if ok { "[ OK ]" } else { "[FAIL]" };
        self.report.success &= ok;
        writeln!(self.report.log, "{tag} {}:{name}", self.path).unwrap();
    }
}