oxirs-fuseki 0.2.4

SPARQL 1.1/1.2 HTTP protocol server with Fuseki-compatible configuration
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

//! Implement oxirs_core::Store trait for fuseki Store

use crate::store::Store;
use oxirs_core::model::{GraphName, Quad, Triple};
use oxirs_core::rdf_store::{OxirsQueryResults, PreparedQuery};
use oxirs_core::{OxirsError, Result};

impl oxirs_core::Store for Store {
    fn insert_quad(&self, quad: Quad) -> Result<bool> {
        let store = self
            .default_store
            .write()
            .map_err(|e| OxirsError::Store(format!("Lock error: {}", e)))?;
        store.insert_quad(quad)
    }

    fn remove_quad(&self, quad: &Quad) -> Result<bool> {
        let store = self
            .default_store
            .write()
            .map_err(|e| OxirsError::Store(format!("Lock error: {}", e)))?;
        store.remove_quad(quad)
    }

    fn find_quads(
        &self,
        subject: Option<&oxirs_core::model::Subject>,
        predicate: Option<&oxirs_core::model::Predicate>,
        object: Option<&oxirs_core::model::Object>,
        graph: Option<&GraphName>,
    ) -> Result<Vec<Quad>> {
        let store = self
            .default_store
            .read()
            .map_err(|e| OxirsError::Store(format!("Lock error: {}", e)))?;
        store.find_quads(subject, predicate, object, graph)
    }

    fn is_ready(&self) -> bool {
        true
    }

    fn len(&self) -> Result<usize> {
        let store = self
            .default_store
            .read()
            .map_err(|e| OxirsError::Store(format!("Lock error: {}", e)))?;
        store.len()
    }

    fn is_empty(&self) -> Result<bool> {
        let store = self
            .default_store
            .read()
            .map_err(|e| OxirsError::Store(format!("Lock error: {}", e)))?;
        store.is_empty()
    }

    fn query(&self, sparql: &str) -> Result<OxirsQueryResults> {
        let store = self
            .default_store
            .read()
            .map_err(|e| OxirsError::Store(format!("Lock error: {}", e)))?;
        store.query(sparql)
    }

    fn prepare_query(&self, sparql: &str) -> Result<PreparedQuery> {
        let store = self
            .default_store
            .read()
            .map_err(|e| OxirsError::Store(format!("Lock error: {}", e)))?;
        store.prepare_query(sparql)
    }
}