oxilite-core 0.9.0

The I/O-free core of oxilite: SPARQL to SQL compiler, term encoding and SQLite schema (sans-IO jobs for any SQLite backend)
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

use std::fmt;

/// Result alias used across oxilite.
pub type Result<T, E = Error> = std::result::Result<T, E>;

/// Errors raised by oxilite.
#[derive(Debug, thiserror::Error)]
pub enum Error {
    /// The SPARQL query or update could not be parsed.
    #[error(transparent)]
    Syntax(#[from] spargebra::SparqlSyntaxError),
    /// An RDF document could not be parsed.
    #[error(transparent)]
    Parse(#[from] oxrdfio::RdfParseError),
    /// The SQL backend failed.
    #[error("SQL backend error: {0}")]
    Backend(String),
    /// The operation needs something the compiler or backend cannot do.
    #[error("unsupported: {0}")]
    Unsupported(String),
    /// Two different terms hashed to the same id.
    #[error("term hash collision: {0}")]
    Collision(String),
    /// The database content is not what oxilite expects.
    #[error("corrupted store: {0}")]
    Corrupted(String),
    /// Evaluation by the fallback evaluator failed.
    #[error(transparent)]
    Evaluation(#[from] spareval::QueryEvaluationError),
    /// I/O error while reading or writing RDF.
    #[error(transparent)]
    Io(#[from] std::io::Error),
    /// Other errors.
    #[error("{0}")]
    Other(String),
}

impl Error {
    pub fn backend(e: impl fmt::Display) -> Self {
        let msg = e.to_string();
        if msg.contains("oxilite: term hash collision") {
            Self::Collision(msg)
        } else if msg.contains("graph_does_not_exist") {
            Self::Other("the graph does not exist".into())
        } else if msg.contains("graph_already_exists") {
            Self::Other("the graph already exists".into())
        } else if msg.contains("vector_dimensions_mismatch") {
            Self::Other(
                "a value of the indexed property is not a JSON array with the index's dimensions"
                    .into(),
            )
        } else if msg.contains("computed_value_not_storable") {
            Self::Unsupported(
                "an update template stores a computed non-integer value, which SQL cannot hash"
                    .into(),
            )
        } else {
            Self::Backend(msg)
        }
    }

    pub fn unsupported(msg: impl Into<String>) -> Self {
        Self::Unsupported(msg.into())
    }

    pub fn corrupted(msg: impl Into<String>) -> Self {
        Self::Corrupted(msg.into())
    }

    /// Is this error a request for the fallback evaluator?
    pub fn is_unsupported(&self) -> bool {
        matches!(self, Self::Unsupported(_))
    }
}