Struct oxigraph::store::sled::SledStore

pub struct SledStore { /* fields omitted */ }

Store based on the Sled key-value database. It encodes a RDF dataset and allows to query it using SPARQL.

To use it, the "sled" feature needs to be activated.

Warning: Sled is not stable yet and might break its storage format.

Usage example:

use oxigraph::SledStore;
use oxigraph::sparql::QueryResults;
use oxigraph::model::*;

let store = SledStore::open("example.db")?;

// insertion
let ex = NamedNode::new("http://example.com")?;
let quad = Quad::new(ex.clone(), ex.clone(), ex.clone(), None);
store.insert(&quad)?;

// quad filter
let results: Result<Vec<Quad>,_> = store.quads_for_pattern(None, None, None, None).collect();
assert_eq!(vec![quad], results?);

// SPARQL query
if let QueryResults::Solutions(mut solutions) = store.query("SELECT ?s WHERE { ?s ?p ?o }")? {
    assert_eq!(solutions.next().unwrap()?.get("s"), Some(&ex.into()));
};

Implementations

impl SledStore

pub fn new() -> Result<Self, Error>

Creates a temporary SledStore that will be deleted after drop.

pub fn open(path: impl AsRef<Path>) -> Result<Self, Error>

Opens a SledStore and creates it if it does not exist yet.

pub fn query(
    &self,
    query: impl TryInto<Query, Error = impl Into<EvaluationError>>
) -> Result<QueryResults, EvaluationError>

Executes a SPARQL 1.1 query.

See MemoryStore for a usage example.

pub fn query_opt(
    &self,
    query: impl TryInto<Query, Error = impl Into<EvaluationError>>,
    options: QueryOptions
) -> Result<QueryResults, EvaluationError>

Executes a SPARQL 1.1 query with some options.

pub fn quads_for_pattern(
    &self,
    subject: Option<NamedOrBlankNodeRef<'_>>,
    predicate: Option<NamedNodeRef<'_>>,
    object: Option<TermRef<'_>>,
    graph_name: Option<GraphNameRef<'_>>
) -> SledQuadIter

Retrieves quads with a filter on each quad component

See MemoryStore for a usage example.

pub fn iter(&self) -> SledQuadIter

Returns all the quads contained in the store

pub fn contains<'a>(&self, quad: impl Into<QuadRef<'a>>) -> Result<bool, Error>

Checks if this store contains a given quad

pub fn len(&self) -> usize

Returns the number of quads in the store

Warning: this function executes a full scan

pub fn is_empty(&self) -> bool

Returns if the store is empty

pub fn update(
    &self,
    update: impl TryInto<Update, Error = impl Into<EvaluationError>>
) -> Result<(), EvaluationError>

Executes a SPARQL 1.1 update.

The store does not track the existence of empty named graphs. This method has no ACID guarantees.

See MemoryStore for a usage example.

pub fn update_opt(
    &self,
    update: impl TryInto<Update, Error = impl Into<EvaluationError>>,
    options: UpdateOptions
) -> Result<(), EvaluationError>

Executes a SPARQL 1.1 update with some options.

pub fn transaction<T, E>(
    &self,
    f: impl Fn(SledTransaction<'_>) -> Result<T, SledConflictableTransactionError<E>>
) -> Result<T, SledTransactionError<E>>

Executes an ACID transaction.

The transaction is executed if the given closure returns Ok. The transaction is rollbacked if the closure returns Err.

Usage example:

use oxigraph::SledStore;
use oxigraph::model::*;
use oxigraph::store::sled::SledConflictableTransactionError;
use std::convert::Infallible;

let store = SledStore::new()?;

let ex = NamedNode::new("http://example.com")?;
let quad = Quad::new(ex.clone(), ex.clone(), ex.clone(), None);

// transaction
store.transaction(|transaction| {
    transaction.insert(&quad)?;
    Ok(()) as Result<(),SledConflictableTransactionError<Infallible>>
})?;

// quad filter
assert!(store.contains(&quad)?);

pub fn load_graph<'a>(
    &self,
    reader: impl BufRead,
    format: GraphFormat,
    to_graph_name: impl Into<GraphNameRef<'a>>,
    base_iri: Option<&str>
) -> Result<(), Error>

Loads a graph file (i.e. triples) into the store

Warning: This functions saves the triples in a not atomic way. If the parsing fails in the middle of the file, only a part of it may be written to the store. Also, this method is optimized for performances and is not atomic. It might leave the store in a bad state if a crash happens during a triple insertion. Use a (memory greedy) transaction if you do not want that.

See MemoryStore for a usage example.

Errors related to parameter validation like the base IRI use the InvalidInput error kind. Errors related to a bad syntax in the loaded file use the InvalidData or UnexpectedEof error kinds. Errors related to data loading into the store use the other error kinds.

pub fn load_dataset(
    &self,
    reader: impl BufRead,
    format: DatasetFormat,
    base_iri: Option<&str>
) -> Result<(), Error>

Loads a dataset file (i.e. quads) into the store.

Warning: This functions saves the triples in a not atomic way. If the parsing fails in the middle of the file, only a part of it may be written to the store. Also, this method is optimized for performances and is not atomic. It might leave the store in a bad state if a crash happens during a quad insertion. Use a (memory greedy) transaction if you do not want that.

See MemoryStore for a usage example.

Errors related to parameter validation like the base IRI use the InvalidInput error kind. Errors related to a bad syntax in the loaded file use the InvalidData or UnexpectedEof error kinds. Errors related to data loading into the store use the other error kinds.

pub fn insert<'a>(&self, quad: impl Into<QuadRef<'a>>) -> Result<(), Error>

Adds a quad to this store.

This method is optimized for performances and is not atomic. It might leave the store in a bad state if a crash happens during the insertion. Use a (memory greedy) transaction if you do not want that.

pub fn remove<'a>(&self, quad: impl Into<QuadRef<'a>>) -> Result<(), Error>

Removes a quad from this store.

This method is optimized for performances and is not atomic. It might leave the store in a bad state if a crash happens during the removal. Use a (memory greedy) transaction if you do not want that.

pub fn dump_graph<'a>(
    &self,
    writer: impl Write,
    format: GraphFormat,
    from_graph_name: impl Into<GraphNameRef<'a>>
) -> Result<(), Error>

Dumps a store graph into a file.

See MemoryStore for a usage example.

pub fn dump_dataset(
    &self,
    writer: impl Write,
    format: DatasetFormat
) -> Result<(), Error>

Dumps the store into a file.

See MemoryStore for a usage example.

pub fn named_graphs(&self) -> SledGraphNameIter

Returns all the store named graphs

See MemoryStore for a usage example.

pub fn contains_named_graph<'a>(
    &self,
    graph_name: impl Into<NamedOrBlankNodeRef<'a>>
) -> Result<bool, Error>

Checks if the store contains a given graph

See MemoryStore for a usage example.

pub fn insert_named_graph<'a>(
    &self,
    graph_name: impl Into<NamedOrBlankNodeRef<'a>>
) -> Result<(), Error>

Inserts a graph into this store

See MemoryStore for a usage example.

pub fn clear_graph<'a>(
    &self,
    graph_name: impl Into<GraphNameRef<'a>>
) -> Result<(), Error>

Clears a graph from this store.

See MemoryStore for a usage example.

pub fn remove_named_graph<'a>(
    &self,
    graph_name: impl Into<NamedOrBlankNodeRef<'a>>
) -> Result<(), Error>

Removes a graph from this store.

See MemoryStore for a usage example.

pub fn clear(&self) -> Result<(), Error>

Clears the store.

See MemoryStore for a usage example.

Trait Implementations

impl Clone for SledStore

pub fn clone(&self) -> SledStore

Returns a copy of the value.

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

Performs copy-assignment from source.

impl CollectibleDataset for SledStore

pub fn from_quad_source<QS: QuadSource>(
    quads: QS
) -> StreamResult<Self, QS::Error, Self::Error>

impl Dataset for SledStore

type Quad = ByValue<([Term; 3], Option<Term>)>

Determine the type of Quads that the methods of this dataset will yield (see streaming_mode

type Error = Error

The error type that this dataset may raise.

pub fn quads(&self) -> DQuadSource<'_, Self>

An iterator visiting all quads of this dataset in arbitrary order.

pub fn quads_with_s<'s, TS: ?Sized>(
    &'s self,
    s: &'s TS
) -> DQuadSource<'s, Self> where
    TS: TTerm, 

An iterator visiting all quads with the given subject.

pub fn quads_with_p<'s, TP: ?Sized>(
    &'s self,
    p: &'s TP
) -> DQuadSource<'s, Self> where
    TP: TTerm, 

An iterator visiting all quads with the given predicate.

pub fn quads_with_o<'s, TS: ?Sized>(
    &'s self,
    o: &'s TS
) -> DQuadSource<'s, Self> where
    TS: TTerm, 

An iterator visiting add quads with the given object.

pub fn quads_with_g<'s, TS: ?Sized>(
    &'s self,
    g: Option<&'s TS>
) -> DQuadSource<'s, Self> where
    TS: TTerm, 

An iterator visiting add quads with the given graph name.

pub fn quads_with_sp<'s, TS: ?Sized, TP: ?Sized>(
    &'s self,
    s: &'s TS,
    p: &'s TP
) -> DQuadSource<'s, Self> where
    TS: TTerm,
    TP: TTerm, 

An iterator visiting add quads with the given subject and predicate.

pub fn quads_with_so<'s, TS: ?Sized, TO: ?Sized>(
    &'s self,
    s: &'s TS,
    o: &'s TO
) -> DQuadSource<'s, Self> where
    TS: TTerm,
    TO: TTerm, 

An iterator visiting add quads with the given subject and object.

pub fn quads_with_sg<'s, TS: ?Sized, TG: ?Sized>(
    &'s self,
    s: &'s TS,
    g: Option<&'s TG>
) -> DQuadSource<'s, Self> where
    TS: TTerm,
    TG: TTerm, 

An iterator visiting add quads with the given subject and graph name.

pub fn quads_with_po<'s, TP: ?Sized, TO: ?Sized>(
    &'s self,
    p: &'s TP,
    o: &'s TO
) -> DQuadSource<'s, Self> where
    TP: TTerm,
    TO: TTerm, 

An iterator visiting add quads with the given predicate and object.

pub fn quads_with_pg<'s, TP: ?Sized, TG: ?Sized>(
    &'s self,
    p: &'s TP,
    g: Option<&'s TG>
) -> DQuadSource<'s, Self> where
    TP: TTerm,
    TG: TTerm, 

An iterator visiting add quads with the given predicate and graph name.

pub fn quads_with_og<'s, TO: ?Sized, TG: ?Sized>(
    &'s self,
    o: &'s TO,
    g: Option<&'s TG>
) -> DQuadSource<'s, Self> where
    TO: TTerm,
    TG: TTerm, 

An iterator visiting add quads with the given object and graph name.

pub fn quads_with_spo<'s, TS: ?Sized, TP: ?Sized, TO: ?Sized>(
    &'s self,
    s: &'s TS,
    p: &'s TP,
    o: &'s TO
) -> DQuadSource<'s, Self> where
    TS: TTerm,
    TP: TTerm,
    TO: TTerm, 

An iterator visiting add quads with the given subject, predicate and object.

pub fn quads_with_spg<'s, TS: ?Sized, TP: ?Sized, TG: ?Sized>(
    &'s self,
    s: &'s TS,
    p: &'s TP,
    g: Option<&'s TG>
) -> DQuadSource<'s, Self> where
    TS: TTerm,
    TP: TTerm,
    TG: TTerm, 

An iterator visiting add quads with the given subject, predicate and graph name.

pub fn quads_with_sog<'s, TS: ?Sized, TO: ?Sized, TG: ?Sized>(
    &'s self,
    s: &'s TS,
    o: &'s TO,
    g: Option<&'s TG>
) -> DQuadSource<'s, Self> where
    TS: TTerm,
    TO: TTerm,
    TG: TTerm, 

An iterator visiting add quads with the given subject, object and graph name.

pub fn quads_with_pog<'s, TP: ?Sized, TO: ?Sized, TG: ?Sized>(
    &'s self,
    p: &'s TP,
    o: &'s TO,
    g: Option<&'s TG>
) -> DQuadSource<'s, Self> where
    TP: TTerm,
    TO: TTerm,
    TG: TTerm, 

An iterator visiting add quads with the given predicate, object and graph name.

pub fn quads_with_spog<'s, TS: ?Sized, TP: ?Sized, TO: ?Sized, TG: ?Sized>(
    &'s self,
    s: &'s TS,
    p: &'s TP,
    o: &'s TO,
    g: Option<&'s TG>
) -> DQuadSource<'s, Self> where
    TS: TTerm,
    TP: TTerm,
    TO: TTerm,
    TG: TTerm, 

An iterator visiting add quads with the given subject, predicate, object and graph name.

pub fn subjects(&self) -> DResultTermSet<Self> where
    DTerm<Self>: Clone + Eq + Hash, 

Build a Hashset of all the terms used as subject in this Dataset.

pub fn predicates(&self) -> DResultTermSet<Self> where
    DTerm<Self>: Clone + Eq + Hash, 

Build a Hashset of all the terms used as predicate in this Dataset.

pub fn objects(&self) -> DResultTermSet<Self> where
    DTerm<Self>: Clone + Eq + Hash, 

Build a Hashset of all the terms used as object in this Dataset.

pub fn graph_names(&self) -> DResultTermSet<Self> where
    DTerm<Self>: Clone + Eq + Hash, 

Build a Hashset of all the terms used as graph names in this Dataset.

pub fn iris(&self) -> DResultTermSet<Self> where
    DTerm<Self>: Clone + Eq + Hash, 

Build a Hashset of all the IRIs used in this Dataset.

pub fn bnodes(&self) -> DResultTermSet<Self> where
    DTerm<Self>: Clone + Eq + Hash, 

Build a Hashset of all the BNodes used in this Dataset.

pub fn literals(&self) -> DResultTermSet<Self> where
    DTerm<Self>: Clone + Eq + Hash, 

Build a Hashset of all the Literals used in this Dataset.

pub fn variables(&self) -> DResultTermSet<Self> where
    DTerm<Self>: Clone + Eq + Hash, 

Build a Hashset of all the variables used in this Dataset.

pub fn contains<TS, TP, TO, TG>(
    &'s self,
    s: &'s TS,
    p: &'s TP,
    o: &'s TO,
    g: Option<&'s TG>
) -> Result<bool, Self::Error> where
    TO: TTerm + ?Sized,
    TS: TTerm + ?Sized,
    TP: TTerm + ?Sized,
    TG: TTerm + ?Sized, 

Return true if this dataset contains the given quad.

pub fn quads_matching<S, P, O, G>(
    &'s self,
    ms: &'s S,
    mp: &'s P,
    mo: &'s O,
    mg: &'s G
) -> Box<dyn Iterator<Item = Result<StreamedQuad<'s, Self::Quad>, Self::Error>> + 's, Global> where
    P: TermMatcher + ?Sized,
    S: TermMatcher + ?Sized,
    O: TermMatcher + ?Sized,
    G: GraphNameMatcher + ?Sized, 

An iterator visiting add quads matching the given subject, predicate, object and graph name.

pub fn graph<T>(
    &'s self,
    graph_name: Option<&'s T>
) -> DatasetGraph<Self, &'s Self, Option<&'s T>> where
    T: TTerm + ?Sized, 

Borrows one of the graphs of this dataset

pub fn graph_mut<T>(
    &'s mut self,
    graph_name: Option<&'s T>
) -> DatasetGraph<Self, &'s mut Self, Option<&'s T>> where
    T: TTerm + ?Sized, 

Borrows mutably one of the graphs of this dataset

pub fn union_graph<'s, T>(
    &'s self,
    gmatcher: T
) -> DatasetGraph<Self, &'s Self, T> where
    T: GraphNameMatcher + 's, 

impl Display for SledStore

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl MutableDataset for SledStore

type MutationError = Error

The error type that this dataset may raise during mutations.

pub fn insert<TS: ?Sized, TP: ?Sized, TO: ?Sized, TG: ?Sized>(
    &mut self,
    s: &TS,
    p: &TP,
    o: &TO,
    g: Option<&TG>
) -> MDResult<Self, bool> where
    TS: TTerm,
    TP: TTerm,
    TO: TTerm,
    TG: TTerm, 

Insert the given quad in this dataset.

pub fn remove<TS: ?Sized, TP: ?Sized, TO: ?Sized, TG: ?Sized>(
    &mut self,
    s: &TS,
    p: &TP,
    o: &TO,
    g: Option<&TG>
) -> MDResult<Self, bool> where
    TS: TTerm,
    TP: TTerm,
    TO: TTerm,
    TG: TTerm, 

Remove the given quad from this dataset.

pub fn insert_all<QS>(
    &mut self,
    src: QS
) -> Result<usize, StreamError<<QS as QuadSource>::Error, Self::MutationError>> where
    QS: QuadSource, 

Insert into this dataset all quads from the given source.

pub fn remove_all<QS>(
    &mut self,
    src: QS
) -> Result<usize, StreamError<<QS as QuadSource>::Error, Self::MutationError>> where
    QS: QuadSource, 

Remove from this dataset all quads from the given source.

pub fn remove_matching<S, P, O, G>(
    &mut self,
    ms: &S,
    mp: &P,
    mo: &O,
    mg: &G
) -> Result<usize, Self::MutationError> where
    P: TermMatcher + ?Sized,
    S: TermMatcher + ?Sized,
    O: TermMatcher + ?Sized,
    G: GraphNameMatcher + ?Sized,
    <<Self::Quad as QuadStreamingMode>::UnsafeQuad as UnsafeQuad>::Term: Clone,
    Self::Error: Into<Self::MutationError>, 

Remove all quads matching the given matchers.

pub fn retain_matching<S, P, O, G>(
    &mut self,
    ms: &S,
    mp: &P,
    mo: &O,
    mg: &G
) -> Result<(), Self::MutationError> where
    P: TermMatcher + ?Sized,
    S: TermMatcher + ?Sized,
    O: TermMatcher + ?Sized,
    G: GraphNameMatcher + ?Sized,
    <<Self::Quad as QuadStreamingMode>::UnsafeQuad as UnsafeQuad>::Term: Clone,
    Self::Error: Into<Self::MutationError>, 

Keep only the quads matching the given matchers.