use oxilite_core::encoding::{EncodedRows, DEFAULT_GRAPH_ID};
use oxilite_core::writer::{insert_statements_into, term_statements};
use oxilite_core::{ops, run_sync, Request, Result, SyncBackend};
use oxrdf::{GraphNameRef, QuadRef, Triple};
use reasonable::reasoner::Reasoner;
use std::collections::HashSet;
pub fn infer<B: SyncBackend>(backend: &B) -> Result<Vec<Triple>> {
let caps = backend.capabilities().clone();
let quads = run_sync(backend, ops::scan_job(None, None, None, None, &caps))?;
let default: HashSet<Triple> = quads
.iter()
.filter(|q| q.graph_name.is_default_graph())
.map(|q| Triple::from(q.clone()))
.collect();
let input: Vec<Triple> = quads
.into_iter()
.map(Triple::from)
.collect::<HashSet<_>>()
.into_iter()
.collect();
let mut reasoner = Reasoner::new();
reasoner.load_triples(input);
reasoner.reason();
let mut out: Vec<Triple> = reasoner
.get_triples()
.into_iter()
.filter(|t| !default.contains(t))
.collect::<HashSet<_>>()
.into_iter()
.collect();
out.sort_by_cached_key(ToString::to_string);
Ok(out)
}
pub fn materialize<B: SyncBackend>(backend: &B) -> Result<u64> {
let caps = backend.capabilities().clone();
let triples = infer(backend)?;
let mut rows = EncodedRows::default();
let ids: Vec<[i64; 4]> = triples
.iter()
.map(|t| {
let [s, p, o, _] = rows.quad(QuadRef::new(
t.subject.as_ref(),
t.predicate.as_ref(),
t.object.as_ref(),
GraphNameRef::DefaultGraph,
));
[s, p, o, DEFAULT_GRAPH_ID]
})
.collect();
rows.dedup();
let mut stmts = oxilite_core::reason::inference_reset(oxilite_core::reason::OWL_PRODUCER);
stmts.extend(term_statements(&rows, &caps));
stmts.extend(insert_statements_into("quads_inf", &ids, &caps));
stmts.push(oxilite_core::reason::inference_attribute(
oxilite_core::reason::OWL_PRODUCER,
));
backend.execute(&Request::atomic(stmts))?;
Ok(ids.len() as u64)
}