qdrant-client 1.17.0

Rust client for Qdrant Vector Search Engine
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

use std::error::Error;
use std::fmt;

use semver::Version;

pub fn parse(version: &str) -> Result<Version, VersionParseError> {
    if version.is_empty() {
        return Err(VersionParseError::EmptyVersion);
    }
    match Version::parse(version) {
        Ok(v) => Ok(v),
        Err(_) => Err(VersionParseError::InvalidFormat(version.to_string())),
    }
}

#[derive(Debug)]
pub enum VersionParseError {
    EmptyVersion,
    InvalidFormat(String),
}

impl fmt::Display for VersionParseError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            VersionParseError::EmptyVersion => write!(f, "Version is empty"),
            VersionParseError::InvalidFormat(version) => {
                write!(
                    f,
                    "Unable to parse version, expected format: x.y[.z], found: {version}"
                )
            }
        }
    }
}

impl Error for VersionParseError {}

pub fn is_compatible(client_version: Option<&str>, server_version: Option<&str>) -> bool {
    if client_version.is_none() || server_version.is_none() {
        println!(
            "Unable to compare versions, client_version: {client_version:?}, server_version: {server_version:?}"
        );
        return false;
    }

    let client_version = client_version.unwrap();
    let server_version = server_version.unwrap();

    if client_version == server_version {
        return true;
    }

    match (parse(client_version), parse(server_version)) {
        (Ok(client), Ok(server)) => {
            let major_dif = (client.major as i32 - server.major as i32).abs();
            if major_dif >= 1 {
                return false;
            }
            (client.minor as i32 - server.minor as i32).abs() <= 1
        }
        (Err(e), _) | (_, Err(e)) => {
            println!("Unable to compare versions: {e}");
            false
        }
    }
}

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

    #[test]
    fn test_is_compatible() {
        let test_cases = vec![
            (Some("1.9.3.dev0"), Some("2.8.1-dev12"), false),
            (Some("1.9"), Some("2.8"), false),
            (Some("1"), Some("2"), false),
            (Some("1.9.0"), Some("2.9.0"), false),
            (Some("1.1.0"), Some("1.2.9"), true),
            (Some("1.2.7"), Some("1.1.8-dev0"), true),
            (Some("1.2.1"), Some("1.2.29"), true),
            (Some("1.2.0"), Some("1.2.0"), true),
            (Some("1.2.0"), Some("1.4.0"), false),
            (Some("1.4.0"), Some("1.2.0"), false),
            (Some("1.9.0"), Some("3.7.0"), false),
            (Some("3.0.0"), Some("1.0.0"), false),
            (None, Some("1.0.0"), false),
            (Some("1.0.0"), None, false),
            (None, None, false),
        ];

        for (client_version, server_version, expected_result) in test_cases {
            let result = is_compatible(client_version, server_version);
            assert_eq!(
                result, expected_result,
                "Failed for client: {client_version:?}, server: {server_version:?}"
            );
        }
    }

    #[test]
    fn test_version_parse_errors() {
        let test_cases = vec![
            ("1", VersionParseError::InvalidFormat("1".to_string())),
            ("1.", VersionParseError::InvalidFormat("1.".to_string())),
            (".1", VersionParseError::InvalidFormat(".1".to_string())),
            (".1.", VersionParseError::InvalidFormat(".1.".to_string())),
            (
                "1.a.1",
                VersionParseError::InvalidFormat("1.a.1".to_string()),
            ),
            (
                "a.1.1",
                VersionParseError::InvalidFormat("a.1.1".to_string()),
            ),
            ("", VersionParseError::EmptyVersion),
        ];

        for (input, expected_error) in test_cases {
            let result = parse(input);
            assert!(result.is_err());
            assert_eq!(result.unwrap_err().to_string(), expected_error.to_string());
        }
    }
}