diskann-benchmark-runner 0.57.0

DiskANN3 is a composable library for bringing scalable, accurate and cost-effective vector indexing to multiple databases.
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

/*
 * Copyright (c) Microsoft Corporation.
 * Licensed under the MIT license.
 */

use crate::Features;

// Visibility of an item.
#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
pub(crate) enum Visibility<'a> {
    /// Item is available.
    Available,
    /// Item is unavailable and gated behind `features`.
    Gated { features: &'a Features },
}

impl Visibility<'_> {
    #[must_use = "this has no side-effects"]
    pub(crate) fn is_available(&self) -> bool {
        matches!(self, Self::Available)
    }
}

/// A [`Visibility`] filter.
#[derive(Debug, Clone, Copy)]
pub(crate) enum Filter {
    /// Match all possible visibilities.
    All,
    /// Only match [`Visibility::Available`].
    OnlyAvailable,
}

impl Filter {
    #[must_use = "this has no side-effects"]
    pub(crate) fn matches(self, vis: &Visibility<'_>) -> bool {
        match self {
            Self::All => true,
            Self::OnlyAvailable => matches!(vis, Visibility::Available),
        }
    }
}

///////////
// Tests //
///////////

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_is_available() {
        let features = Features::new("some-feature");
        assert!(Visibility::Available.is_available());
        assert!(!Visibility::Gated {
            features: &features
        }
        .is_available());
    }

    #[test]
    fn test_filter_matches() {
        let features = Features::new("some-feature");
        let available = Visibility::Available;
        let gated = Visibility::Gated {
            features: &features,
        };

        // `All` matches everything.
        assert!(Filter::All.matches(&available));
        assert!(Filter::All.matches(&gated));

        // `OnlyAvailable` matches available items exclusively.
        assert!(Filter::OnlyAvailable.matches(&available));
        assert!(!Filter::OnlyAvailable.matches(&gated));
    }

    // The listing sort relies on `Available` ordering before `Gated`, so lock in that
    // contract here.
    #[test]
    fn test_ordering() {
        let features = Features::new("some-feature");
        let available = Visibility::Available;
        let gated = Visibility::Gated {
            features: &features,
        };

        assert!(available < gated);
    }
}