uqa-storage 0.4.8

Document store, inverted index, IVF/HNSW vectors, B-tree, R*Tree, catalog
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

//
// Unified Query Algebra
//
// Copyright (c) 2023-2026 Cognica, Inc.
//

use std::collections::BTreeMap;

use super::{invalid, DiskANNAlpha, DiskANNIndexParams};
use crate::vector_index::config::parsing::{
    find_parameter, read_positive_usize, read_u64, reject_unknown_parameters,
};
use crate::StorageBackendResult;

const PARAMETERS: &[&str] = &[
    "max_degree",
    "build_list_size",
    "search_list_size",
    "alpha",
    "beam_width",
    "pq_bytes",
    "seed",
    "format_revision",
    "algorithm_revision",
];

pub(super) fn decode(
    dimensions: u32,
    parameters: &BTreeMap<String, String>,
) -> StorageBackendResult<DiskANNIndexParams> {
    reject_unknown_parameters(parameters, PARAMETERS, "DiskANN")?;
    for name in PARAMETERS {
        if find_parameter(parameters, &[*name], "DiskANN")?.is_none() {
            return Err(invalid(name, "is missing from the persisted configuration"));
        }
    }
    let size = |name| read_positive_usize(parameters, &[name], 0, "DiskANN");
    let revision = |name| {
        u32::try_from(read_u64(parameters, &[name], 0, "DiskANN")?)
            .map_err(|_| invalid(name, "exceeds the revision range"))
    };
    let (_, alpha) = find_parameter(parameters, &["alpha"], "DiskANN")?
        .ok_or_else(|| invalid("alpha", "is missing from the persisted configuration"))?;
    DiskANNIndexParams {
        max_degree: size("max_degree")?,
        build_list_size: size("build_list_size")?,
        search_list_size: size("search_list_size")?,
        alpha: DiskANNAlpha::new(
            alpha
                .parse()
                .map_err(|_| invalid("alpha", "must be a real number"))?,
        )?,
        beam_width: size("beam_width")?,
        pq_bytes: size("pq_bytes")?,
        seed: read_u64(parameters, &["seed"], 0, "DiskANN")?,
        format_revision: revision("format_revision")?,
        algorithm_revision: revision("algorithm_revision")?,
    }
    .validate(dimensions)
}

pub(super) fn encode(parameters: DiskANNIndexParams) -> BTreeMap<String, String> {
    BTreeMap::from([
        ("max_degree".into(), parameters.max_degree.to_string()),
        (
            "build_list_size".into(),
            parameters.build_list_size.to_string(),
        ),
        (
            "search_list_size".into(),
            parameters.search_list_size.to_string(),
        ),
        ("alpha".into(), parameters.alpha.get().to_string()),
        ("beam_width".into(), parameters.beam_width.to_string()),
        ("pq_bytes".into(), parameters.pq_bytes.to_string()),
        ("seed".into(), parameters.seed.to_string()),
        (
            "format_revision".into(),
            parameters.format_revision.to_string(),
        ),
        (
            "algorithm_revision".into(),
            parameters.algorithm_revision.to_string(),
        ),
    ])
}