oxilite 0.7.0

Oxigraph-compatible RDF database and SPARQL engine on SQLite (native, dlopen'ed libsqlite3, Cloudflare D1)
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
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

//! Helpers shared by the blocking and async stores.

use oxilite_core::query::QueryOutput;
use oxilite_core::{Error, Result};
use oxrdf::{Quad, Variable};
use oxrdfio::{RdfParser, RdfSerializer};
use spareval::{QueryResults, QuerySolutionIter, QueryTripleIter};
use spargebra::{Query, SparqlParser, Update};
use std::io::Write;
use std::sync::Arc;

/// Anything that can be turned into a SPARQL query.
pub trait IntoQuery {
    fn into_query(self) -> Result<Query>;
}

impl IntoQuery for Query {
    fn into_query(self) -> Result<Query> {
        Ok(self)
    }
}

impl IntoQuery for &Query {
    fn into_query(self) -> Result<Query> {
        Ok(self.clone())
    }
}

impl IntoQuery for &str {
    fn into_query(self) -> Result<Query> {
        Ok(SparqlParser::new().parse_query(self)?)
    }
}

impl IntoQuery for &String {
    fn into_query(self) -> Result<Query> {
        self.as_str().into_query()
    }
}

impl IntoQuery for String {
    fn into_query(self) -> Result<Query> {
        self.as_str().into_query()
    }
}

/// Anything that can be turned into a SPARQL update.
pub trait IntoUpdate {
    fn into_update(self) -> Result<Update>;
}

impl IntoUpdate for Update {
    fn into_update(self) -> Result<Update> {
        Ok(self)
    }
}

impl IntoUpdate for &Update {
    fn into_update(self) -> Result<Update> {
        Ok(self.clone())
    }
}

impl IntoUpdate for &str {
    fn into_update(self) -> Result<Update> {
        Ok(SparqlParser::new().parse_update(self)?)
    }
}

impl IntoUpdate for &String {
    fn into_update(self) -> Result<Update> {
        self.as_str().into_update()
    }
}

impl IntoUpdate for String {
    fn into_update(self) -> Result<Update> {
        self.as_str().into_update()
    }
}

/// Converts decoded output into Oxigraph's `QueryResults`.
pub fn to_results(out: QueryOutput) -> QueryResults<'static> {
    match out {
        QueryOutput::Solutions { variables, rows } => {
            let variables: Arc<[Variable]> = variables.into();
            QueryResults::Solutions(QuerySolutionIter::from_tuples(
                variables,
                rows.into_iter().map(Ok),
            ))
        }
        QueryOutput::Boolean(b) => QueryResults::Boolean(b),
        QueryOutput::Graph(triples) => {
            QueryResults::Graph(QueryTripleIter::new(triples.into_iter().map(Ok)))
        }
    }
}

/// Parses a document into quads, renaming blank nodes (like Oxigraph's loader).
pub fn parse_all(
    parser: RdfParser,
    reader: impl std::io::Read,
    mut on_error: Option<&mut dyn FnMut(oxrdfio::RdfParseError) -> Result<()>>,
) -> Result<Vec<Quad>> {
    let mut out = Vec::new();
    for q in parser.rename_blank_nodes().for_reader(reader) {
        match q {
            Ok(q) => out.push(q),
            Err(e) => match on_error.as_mut() {
                Some(f) => f(e)?,
                None => return Err(e.into()),
            },
        }
    }
    Ok(out)
}

/// Serializes quads (dataset formats) to a writer.
pub fn serialize_quads<W: Write>(
    serializer: RdfSerializer,
    writer: W,
    quads: &[Quad],
) -> Result<W> {
    let mut s = serializer.for_writer(writer);
    for q in quads {
        s.serialize_quad(q)?;
    }
    Ok(s.finish()?)
}

/// Serializes the triples of quads (graph formats) to a writer.
pub fn serialize_triples<W: Write>(
    serializer: RdfSerializer,
    writer: W,
    quads: &[Quad],
) -> Result<W> {
    let mut s = serializer.for_writer(writer);
    for q in quads {
        s.serialize_triple(q.as_ref())?;
    }
    Ok(s.finish()?)
}

pub fn explain_unsupported(e: &Error) -> String {
    format!(
        "-- oxilite: not fully compiled to SQL ({e}); the operators above the compiled subqueries are evaluated in Rust by spareval (sync backends only)"
    )
}