uqa-storage 0.5.0

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

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

use crate::mvcc::StorageTransactionId;
use crate::StorageBackendResult;

/// Persistent data identities supplied by the storage owner; independent of paths and transaction-history restoration.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct DiskANNGeneration {
    pub(super) database: [u8; 16],
    pub(super) table: u64,
    pub(super) index: u64,
    pub(super) generation: u64,
}

impl DiskANNGeneration {
    pub fn new(
        database: [u8; 16],
        table: u64,
        index: u64,
        generation: u64,
    ) -> StorageBackendResult<Self> {
        if database == [0; 16] || table == 0 || index == 0 || generation == 0 {
            return Err(super::invalid(
                "data incarnations and generation must be nonzero",
            ));
        }
        Ok(Self {
            database,
            table,
            index,
            generation,
        })
    }

    pub fn database(self) -> [u8; 16] {
        self.database
    }
    pub fn table(self) -> u64 {
        self.table
    }
    pub fn index(self) -> u64 {
        self.index
    }
    pub fn generation(self) -> u64 {
        self.generation
    }
}

/// Logical vector origin, retained as data after its writer receipt is reclaimed. Revisions are allocated by the vector mutation owner, not inferred from commit time.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct DiskANNVectorVersion {
    pub(super) writer: StorageTransactionId,
    pub(super) revision: u64,
}

impl DiskANNVectorVersion {
    pub fn new(writer: StorageTransactionId, revision: u64) -> StorageBackendResult<Self> {
        if revision == 0 {
            return Err(super::invalid("vector origin revision must be nonzero"));
        }
        Ok(Self { writer, revision })
    }

    pub fn writer(self) -> StorageTransactionId {
        self.writer
    }
    pub fn revision(self) -> u64 {
        self.revision
    }
}