Struct SqliteStore 

pub struct SqliteStore { /* private fields */ }

The SQLite SBOL store. Cloneable; all clones share one connection pool.

Implementations

impl SqliteStore

pub fn new(pool: SqlitePool) -> Self

pub fn pool(&self) -> &SqlitePool

pub async fn ping(&self) -> Result<(), DomainError>

pub fn triple_source(&self) -> Arc<dyn TripleSource>

pub fn triple_writer(&self) -> Arc<dyn TripleWriter>

pub async fn import_document( &self, input: ImportInput, ) -> Result<ImportReport, DomainError>

pub async fn import_documents( &self, inputs: Vec<ImportInput>, ) -> Result<Vec<ImportReport>, DomainError>

pub async fn graph_store_write( &self, graph: &str, body: &str, format: SerializationFormat, mode: GraphWriteMode, ) -> Result<usize, DomainError>

pub async fn graph_store_clear(&self, graph: &str) -> Result<usize, DomainError>

pub async fn graph_store_read( &self, graph: &str, ) -> Result<Vec<Triple>, DomainError>

pub async fn graph_store_read_page( &self, graph: &str, after: Option<&str>, limit: usize, ) -> Result<TripleScanPage, DomainError>

Trait Implementations

impl AclStore for SqliteStore

fn owned_graphs<'life0, 'life1, 'async_trait>( &'life0 self, owner_iri: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<String>, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Named graphs whose contents carry <subject> sbh:ownedBy <owner_iri>, i.e. the graphs owner_iri owns and may read. Distinct, order unspecified.

fn viewable_objects<'life0, 'life1, 'async_trait>( &'life0 self, owner_iri: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<String>, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Objects shared with owner_iri through <owner_iri> sbh:canView <object>. Distinct, order unspecified.

impl Clone for SqliteStore

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl CorpusStatsStore for SqliteStore

fn catalog_stats<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<CorpusStats, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

impl GraphStore for SqliteStore

fn get_graph<'life0, 'async_trait>( &'life0 self, id: GraphId, ) -> Pin<Box<dyn Future<Output = Result<Option<GraphRecord>, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn list_graphs<'life0, 'life1, 'async_trait>( &'life0 self, filter: &'life1 ListGraphsFilter, ) -> Pin<Box<dyn Future<Output = Result<Vec<GraphRecord>, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn delete_graph<'life0, 'async_trait>( &'life0 self, id: GraphId, ) -> Pin<Box<dyn Future<Output = Result<bool, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn graph_exists_by_hash<'life0, 'life1, 'async_trait>( &'life0 self, hash: &'life1 [u8], ) -> Pin<Box<dyn Future<Output = Result<bool, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn graph_id_by_document_iri<'life0, 'life1, 'async_trait>( &'life0 self, document_iri: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<GraphId>, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Resolve a document graph’s surrogate id from its document IRI, for delete-by-IRI. Returns None when no sbol3-kind graph carries it.

impl LabStore for SqliteStore

fn corpus_counts<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<CorpusCounts, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn recent_graphs<'life0, 'async_trait>( &'life0 self, limit: i64, ) -> Pin<Box<dyn Future<Output = Result<Vec<GraphOverview>, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn top_classes<'life0, 'async_trait>( &'life0 self, limit: i64, ) -> Pin<Box<dyn Future<Output = Result<Vec<ClassCount>, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn count_graphs<'life0, 'life1, 'async_trait>( &'life0 self, kind: Option<&'life1 str>, ) -> Pin<Box<dyn Future<Output = Result<i64, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn list_graph_overviews<'life0, 'life1, 'async_trait>( &'life0 self, kind: Option<&'life1 str>, limit: i64, offset: i64, ) -> Pin<Box<dyn Future<Output = Result<Vec<GraphOverview>, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn get_graph_overview<'life0, 'async_trait>( &'life0 self, id: GraphId, ) -> Pin<Box<dyn Future<Output = Result<Option<GraphOverview>, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn graph_triples<'life0, 'async_trait>( &'life0 self, id: GraphId, limit: i64, offset: i64, ) -> Pin<Box<dyn Future<Output = Result<Option<GraphTriplesPage>, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

One graph’s triples (paginated) plus the total, or None if the graph does not exist.

impl NamedGraphCatalogStore for SqliteStore

fn catalog_graph<'life0, 'async_trait>( &'life0 self, id: GraphId, ) -> Pin<Box<dyn Future<Output = Result<Option<NamedGraphRecord>, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn catalog_graphs<'life0, 'life1, 'async_trait>( &'life0 self, query: &'life1 NamedGraphQuery, ) -> Pin<Box<dyn Future<Output = Result<CursorPage<NamedGraphRecord>, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn catalog_graph_triples<'life0, 'life1, 'async_trait>( &'life0 self, id: GraphId, query: &'life1 TriplePageQuery, ) -> Pin<Box<dyn Future<Output = Result<Option<CursorPage<Triple>>, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl NeighborhoodStore for SqliteStore

fn walk<'life0, 'life1, 'async_trait>( &'life0 self, query: &'life1 NeighborhoodQuery, ) -> Pin<Box<dyn Future<Output = Result<NeighborhoodResult, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl ObjectStore for SqliteStore

fn get_object_by_iri<'life0, 'life1, 'async_trait>( &'life0 self, iri: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<SbolObjectRecord>, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn get_objects_by_iris<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, iris: &'life1 [&'life2 str], ) -> Pin<Box<dyn Future<Output = Result<Vec<SbolObjectRecord>, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

fn list_objects<'life0, 'life1, 'async_trait>( &'life0 self, filter: &'life1 ListObjectsFilter, ) -> Pin<Box<dyn Future<Output = Result<Vec<SbolObjectRecord>, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn get_object_iri_by_id<'life0, 'async_trait>( &'life0 self, id: ObjectId, ) -> Pin<Box<dyn Future<Output = Result<Option<String>, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

impl OntologyStore for SqliteStore

fn load_ontology_from_url<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, prefix: &'life1 str, name: &'life2 str, source_url: &'life3 str, ) -> Pin<Box<dyn Future<Output = Result<OntologyLoadReport, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

fn load_ontology_from_text<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, prefix: &'life1 str, name: &'life2 str, source_url: Option<&'life3 str>, text: &'life4 str, ) -> Pin<Box<dyn Future<Output = Result<OntologyLoadReport, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

fn list_ontologies<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<OntologyRecord>, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn canonicalize<'life0, 'life1, 'async_trait>( &'life0 self, iri: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<String>, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn descendants<'life0, 'life1, 'async_trait>( &'life0 self, iri: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<(String, i16)>, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn list_ontology_terms<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, prefix: &'life1 str, limit: i64, offset: i64, search: Option<&'life2 str>, ) -> Pin<Box<dyn Future<Output = Result<(Vec<OntologyTermRecord>, i64), DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

fn get_ontology_term<'life0, 'life1, 'async_trait>( &'life0 self, iri: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<OntologyTermRecord>, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl ResourceCatalogStore for SqliteStore

fn catalog_resource<'life0, 'life1, 'async_trait>( &'life0 self, iri: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<ResourceRecord>, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn catalog_resource_occurrences<'life0, 'life1, 'async_trait>( &'life0 self, iri: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<ResourceOccurrence>, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn catalog_resources<'life0, 'life1, 'async_trait>( &'life0 self, query: &'life1 ResourceQuery, ) -> Pin<Box<dyn Future<Output = Result<CursorPage<ResourceRecord>, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn catalog_resources_by_iris<'life0, 'life1, 'async_trait>( &'life0 self, iris: &'life1 [String], ) -> Pin<Box<dyn Future<Output = Result<Vec<ResourceRecord>, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Resolve a bounded caller-provided identity list in its original order. Backends may batch the expansion rather than issuing one query per IRI.

fn catalog_top_classes<'life0, 'async_trait>( &'life0 self, limit: u32, ) -> Pin<Box<dyn Future<Output = Result<Vec<ClassCount>, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

impl SbolStore for SqliteStore

fn import_document<'life0, 'async_trait>( &'life0 self, input: ImportInput, ) -> Pin<Box<dyn Future<Output = Result<ImportReport, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn import_documents<'life0, 'async_trait>( &'life0 self, inputs: Vec<ImportInput>, ) -> Pin<Box<dyn Future<Output = Result<Vec<ImportReport>, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn graph_store_write<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, graph: &'life1 str, body: &'life2 str, format: SerializationFormat, mode: GraphWriteMode, ) -> Pin<Box<dyn Future<Output = Result<usize, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

fn graph_store_clear<'life0, 'life1, 'async_trait>( &'life0 self, graph: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<usize, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn graph_store_read<'life0, 'life1, 'async_trait>( &'life0 self, graph: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<Triple>, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn graph_store_read_page<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, graph: &'life1 str, after: Option<&'life2 str>, limit: usize, ) -> Pin<Box<dyn Future<Output = Result<TripleScanPage, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

One stable keyset page from a named graph. The opaque cursor belongs to the backend and allows HTTP exports and migration verification to avoid both OFFSET scans and whole-graph memory limits.

fn triples_for_subject<'life0, 'life1, 'async_trait>( &'life0 self, subject_iri: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<Triple>, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Every triple with the given subject IRI, for single-object RDF export.

fn ping<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<(), DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

impl SequenceCatalogStore for SqliteStore

fn catalog_sequence<'life0, 'life1, 'async_trait>( &'life0 self, iri: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<CatalogSequenceRecord>, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn catalog_sequences<'life0, 'life1, 'async_trait>( &'life0 self, query: &'life1 SequenceQuery, ) -> Pin<Box<dyn Future<Output = Result<CursorPage<CatalogSequenceRecord>, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl SequenceSearchStore for SqliteStore

fn search<'life0, 'life1, 'async_trait>( &'life0 self, pattern: &'life1 str, options: SequenceSearchOptions, ) -> Pin<Box<dyn Future<Output = Result<Vec<SequenceMatch>, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn search_many<'life0, 'life1, 'async_trait>( &'life0 self, patterns: &'life1 [String], options: SequenceSearchOptions, ) -> Pin<Box<dyn Future<Output = Result<Vec<BatchSequenceMatch>, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn align_candidates<'life0, 'life1, 'async_trait>( &'life0 self, query: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<(String, String)>, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Candidate (sequence_iri, elements) pairs for the banded aligner: every indexed DNA/RNA sequence sharing at least one canonical k-mer with query (on either strand, since the seeds are canonical). This is the k-mer prefilter feeding the alignment verify step in the application facade; the store gathers candidates and never aligns, so rust-bio stays out of the backends. A query shorter than the k-mer width has no seed, so every indexed nucleotide sequence is returned as a candidate.

fn sequences_by_iris<'life0, 'life1, 'async_trait>( &'life0 self, iris: &'life1 [String], ) -> Pin<Box<dyn Future<Output = Result<Vec<(String, String)>, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

The (sequence_iri, elements) for the DNA/RNA sequences among iris, dropping any IRI that is absent or non-nucleotide. This materializes the elements of the SketchStore candidate set so the application facade can align them; order is unspecified.

fn all_nucleotide_sequences<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<(String, String)>, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Every DNA/RNA (sequence_iri, elements) in the derived view, the full set the search-index rebuild sketches into the SketchStore. Keyed by the Sequence object’s IRI, the same key the align path materializes elements by, so the sketch index and the align candidates stay aligned regardless of the source SBOL version. Order is unspecified.

impl TextSearchStore for SqliteStore

fn search_objects<'life0, 'life1, 'async_trait>( &'life0 self, query: &'life1 TextSearchQuery, ) -> Pin<Box<dyn Future<Output = Result<(Vec<SbolObjectRecord>, i64), DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Search objects by substring, returning one page plus the total match count. A limit of 0 returns an empty page with the total only, so a caller wanting just the count pays for no row materialization.