diskann-providers 0.58.0

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

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

use diskann::{ANNError, convert_error};
use diskann_utils::views;

use crate::utils::Bridge;

convert_error!(Bridge<diskann_quantization::views::ChunkOffsetError>);
convert_error!(Bridge<diskann_quantization::views::PartitionError>);
convert_error!(Bridge<diskann_quantization::views::PartitionIntoError>);
convert_error!(Bridge<diskann_quantization::views::ChunkViewError>);

impl<T: views::DenseData> From<Bridge<views::TryFromError<T>>> for ANNError {
    #[track_caller]
    fn from(value: Bridge<views::TryFromError<T>>) -> Self {
        ANNError::new(value.into_inner().as_static())
    }
}

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

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

    fn test_error<F, E>(f: F)
    where
        F: FnOnce() -> E,
        E: std::error::Error,
        ANNError: From<E>,
    {
        let err = f();
        let message = format!("{}", err);

        let ann = ANNError::from(err);
        let formatted = ann.to_string();
        assert!(formatted.contains(&message));
    }

    #[test]
    fn test_chunk_offsets_error() {
        // Offsets not monotonic.
        let offsets = [0, 1, 1, 5];
        test_error(|| {
            diskann_quantization::views::ChunkOffsetsView::new(&offsets)
                .bridge_err()
                .unwrap_err()
        });
    }

    #[test]
    fn test_chunk_view_error() {
        let offsets = [0, 1, 2, 5];
        // Data is too long.
        let data = vec![0; offsets.last().unwrap() + 1];

        test_error(|| {
            let offsets = diskann_quantization::views::ChunkOffsetsView::new(&offsets).unwrap();
            diskann_quantization::views::ChunkView::new(data.as_slice(), offsets)
                .bridge_err()
                .unwrap_err()
        });
    }

    #[test]
    fn test_try_from() {
        let ncols = 5;
        let nrows = 3;
        let data = vec![0; ncols * nrows];

        test_error(|| {
            views::MatrixView::try_from(&*data, nrows, ncols + 1)
                .bridge_err()
                .unwrap_err()
        });
    }
}