uqa-storage-sqlite 0.4.7

SQLite catalog, indexes, compressed storage, graph and key/value providers
Documentation
//
// Unified Query Algebra
//
// Copyright (c) 2023-2026 Cognica, Inc.
//

use super::{
    invalid, DiskANNIndexParams, DiskANNReadLimits, DocId, RetainedDiskANNIndex,
    RetainedSQLiteDiskANNCanonical, SQLiteDiskANNHandle, StorageBackendResult, StorageReadControl,
};
use uqa_storage::diskann_index::{
    build::DiskANNTemporaryBudget, DiskANNIndexOptions, DiskANNPersistentOwner, DiskANNQueryRead,
};

impl DiskANNPersistentOwner for SQLiteDiskANNHandle {
    type Snapshot = RetainedDiskANNIndex<RetainedSQLiteDiskANNCanonical>;
    fn dimensions(&self) -> u32 {
        self.canonical.index.dimensions
    }
    fn parameters(&self) -> DiskANNIndexParams {
        self.parameters
    }
    fn read_limits(&self) -> DiskANNReadLimits {
        self.limits
    }
    fn control(&self) -> &StorageReadControl {
        &self.control
    }
    fn query_metadata(
        &self,
    ) -> StorageBackendResult<uqa_storage::diskann_index::DiskANNQueryMetadata> {
        let canonical = self.retain_current()?;
        let source = canonical
            .selected_source(&*self.resolver, &self.control)?
            .ok_or_else(|| invalid("live native index has no published generation"))?;
        uqa_storage::diskann_index::DiskANNQueryMetadata::capture(
            &canonical,
            &*source,
            self.parameters,
            self.limits,
            &self.control,
        )
    }
    fn snapshot(&self) -> StorageBackendResult<Self::Snapshot> {
        Self::snapshot(self)
    }
    fn count(&self) -> StorageBackendResult<usize> {
        self.metadata()?.vector_count(&self.control)
    }
    fn contains_document(&self, document: DocId) -> StorageBackendResult<bool> {
        self.metadata()?.contains_vectors(document, &self.control)
    }
    fn replace(&self, document: DocId, vectors: &[Vec<f32>]) -> StorageBackendResult<()> {
        Self::replace(self, document, vectors).map(|_| ())
    }
    fn rebuild(
        &self,
        options: DiskANNIndexOptions,
        temporary: &DiskANNTemporaryBudget,
        clear: bool,
    ) -> StorageBackendResult<()> {
        let source = self
            .canonical
            .retain_for_index(&self.index, &self.control)?;
        self.validate(
            &source.index_scope(&*self.resolver, &self.control)?,
            options.parameters,
        )?;
        if clear {
            self.canonical.clear_index(
                &source,
                &self.index,
                &*self.resolver,
                options,
                temporary,
                &self.control,
            )
        } else {
            self.canonical.rebuild_source(
                source,
                &*self.resolver,
                options,
                temporary,
                &self.control,
            )
        }
    }
}

impl SQLiteDiskANNHandle {
    fn metadata(&self) -> StorageBackendResult<RetainedSQLiteDiskANNCanonical> {
        let source = self.retain_current()?;
        source
            .selected_source(&*self.resolver, &self.control)?
            .ok_or_else(|| invalid("live native index has no published generation"))?;
        Ok(source)
    }
}