uqa-storage-sqlite 0.3.8

SQLite catalog, indexes, compressed storage, graph and key/value providers
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

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

//! Revision-aware immutable graph cache publication.

use std::sync::Arc;

use super::{CachedGraph, SQLiteHNSWIndex};
use uqa_storage::hnsw_index::HNSWIndex;
use uqa_storage::{StorageBackendError, StorageBackendResult};

impl SQLiteHNSWIndex {
    pub(super) fn cached_graph_for_revision(
        &self,
        revision: u64,
    ) -> StorageBackendResult<Arc<HNSWIndex>> {
        self.cached_graph_state_for_revision(revision)
            .map(|cached| cached.graph)
    }

    pub(super) fn cached_graph_state(&self) -> StorageBackendResult<CachedGraph> {
        let revision = self.persisted_revision()?.ok_or_else(|| {
            StorageBackendError::Other(format!(
                "missing persisted HNSW metadata for {}.{}",
                self.persistent.table, self.persistent.field
            ))
        })?;
        self.cached_graph_state_for_revision(revision)
    }

    fn cached_graph_state_for_revision(&self, revision: u64) -> StorageBackendResult<CachedGraph> {
        if let Some(cached) = self.graph.read().as_ref() {
            if cached.revision == revision {
                return Ok(cached.clone());
            }
        }
        let (loaded_revision, loaded_graph) = self.load_graph()?;
        let loaded = CachedGraph {
            revision: loaded_revision,
            graph: Arc::new(loaded_graph),
        };
        if self.persisted_revision()? != Some(loaded_revision) {
            return Ok(loaded);
        }
        let mut graph = self.graph.write();
        if let Some(existing) = graph.as_ref() {
            if existing.revision == loaded_revision {
                return Ok(existing.clone());
            }
        }
        *graph = Some(loaded.clone());
        Ok(loaded)
    }

    pub(super) fn publish_graph(&self, graph: HNSWIndex, revision: u64) {
        *self.graph.write() = Some(CachedGraph {
            revision,
            graph: Arc::new(graph),
        });
    }

    pub(super) fn persisted_revision(&self) -> StorageBackendResult<Option<u64>> {
        Ok(self.load_meta()?.map(|(_, _, _, revision)| revision))
    }
}