NextGraph
/
oxigraph
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Activity

Changed iterators to ignore rocksdb (Compiles :D )

Browse Source
pull/825/head
Peter Heringer 1 year ago
parent d76871f232
commit 44396ca1b5
4 changed files with 564 additions and 555 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 202
      lib/src/sparql/dataset.rs
  2. 538
      lib/src/sparql/eval.rs
  3. 49
      lib/src/storage/mod.rs
  4. 330
      lib/src/store.rs

202
lib/src/sparql/dataset.rs
Unescape View File

@ -37,11 +37,11 @@ impl DatasetView {
predicate: Option<&EncodedTerm>, predicate: Option<&EncodedTerm>,
object: Option<&EncodedTerm>, object: Option<&EncodedTerm>,
graph_name: Option<&EncodedTerm>, graph_name: Option<&EncodedTerm>,
// ) -> impl Iterator<Item = Result<EncodedQuad, EvaluationError>> + 'static { ) -> impl Iterator<Item = Result<EncodedQuad, EvaluationError>> + 'static {
) -> Vec<crate::model::Term> { // ) -> Vec<crate::model::Term> {
self.reader self.reader
.quads_for_pattern(subject, predicate, object, graph_name) .quads_for_pattern(subject, predicate, object, graph_name)
// .map(|t| t.map_err(Into::into)) .map(|t| t.map_err(Into::into))
} }
#[allow(clippy::needless_collect)] #[allow(clippy::needless_collect)]
@ -51,104 +51,104 @@ impl DatasetView {
predicate: Option<&EncodedTerm>, predicate: Option<&EncodedTerm>,
object: Option<&EncodedTerm>, object: Option<&EncodedTerm>,
graph_name: Option<&EncodedTerm>, graph_name: Option<&EncodedTerm>,
// ) -> Box<dyn Iterator<Item = Result<EncodedQuad, EvaluationError>>> { ) -> Box<dyn Iterator<Item = Result<EncodedQuad, EvaluationError>>> {
) -> Vec<crate::model::Term> { // ) -> Vec<crate::model::Term> {
return Vec::new(); // return Vec::new();
// if let Some(graph_name) = graph_name { if let Some(graph_name) = graph_name {
// if graph_name.is_default_graph() { if graph_name.is_default_graph() {
// if let Some(default_graph_graphs) = &self.dataset.default { if let Some(default_graph_graphs) = &self.dataset.default {
// if default_graph_graphs.len() == 1 { if default_graph_graphs.len() == 1 {
// // Single graph optimization // Single graph optimization
// Box::new( Box::new(
// self.store_encoded_quads_for_pattern( self.store_encoded_quads_for_pattern(
// subject, subject,
// predicate, predicate,
// object, object,
// Some(&default_graph_graphs[0]), Some(&default_graph_graphs[0]),
// ) )
// .map(|quad| { .map(|quad| {
// let quad = quad?; let quad = quad?;
// Ok(EncodedQuad::new( Ok(EncodedQuad::new(
// quad.subject, quad.subject,
// quad.predicate, quad.predicate,
// quad.object, quad.object,
// EncodedTerm::DefaultGraph, EncodedTerm::DefaultGraph,
// )) ))
// }), }),
// ) )
// } else { } else {
// let iters = default_graph_graphs let iters = default_graph_graphs
// .iter() .iter()
// .map(|graph_name| { .map(|graph_name| {
// self.store_encoded_quads_for_pattern( self.store_encoded_quads_for_pattern(
// subject, subject,
// predicate, predicate,
// object, object,
// Some(graph_name), Some(graph_name),
// ) )
// }) })
// .collect::<Vec<_>>(); .collect::<Vec<_>>();
// Box::new(iters.into_iter().flatten().map(|quad| { Box::new(iters.into_iter().flatten().map(|quad| {
// let quad = quad?; let quad = quad?;
// Ok(EncodedQuad::new( Ok(EncodedQuad::new(
// quad.subject, quad.subject,
// quad.predicate, quad.predicate,
// quad.object, quad.object,
// EncodedTerm::DefaultGraph, EncodedTerm::DefaultGraph,
// )) ))
// })) }))
// } }
// } else { } else {
// Box::new( Box::new(
// self.store_encoded_quads_for_pattern(subject, predicate, object, None) self.store_encoded_quads_for_pattern(subject, predicate, object, None)
// .map(|quad| { .map(|quad| {
// let quad = quad?; let quad = quad?;
// Ok(EncodedQuad::new( Ok(EncodedQuad::new(
// quad.subject, quad.subject,
// quad.predicate, quad.predicate,
// quad.object, quad.object,
// EncodedTerm::DefaultGraph, EncodedTerm::DefaultGraph,
// )) ))
// }), }),
// ) )
// } }
// } else if self } else if self
// .dataset .dataset
// .named .named
// .as_ref() .as_ref()
// .map_or(true, |d| d.contains(graph_name)) .map_or(true, |d| d.contains(graph_name))
// { {
// Box::new(self.store_encoded_quads_for_pattern( Box::new(self.store_encoded_quads_for_pattern(
// subject, subject,
// predicate, predicate,
// object, object,
// Some(graph_name), Some(graph_name),
// )) ))
// } else { } else {
// Box::new(empty()) Box::new(empty())
// } }
// } else if let Some(named_graphs) = &self.dataset.named { } else if let Some(named_graphs) = &self.dataset.named {
// let iters = named_graphs let iters = named_graphs
// .iter() .iter()
// .map(|graph_name| { .map(|graph_name| {
// self.store_encoded_quads_for_pattern( self.store_encoded_quads_for_pattern(
// subject, subject,
// predicate, predicate,
// object, object,
// Some(graph_name), Some(graph_name),
// ) )
// }) })
// .collect::<Vec<_>>(); .collect::<Vec<_>>();
// Box::new(iters.into_iter().flatten()) Box::new(iters.into_iter().flatten())
// } else { } else {
// Box::new( Box::new(
// self.store_encoded_quads_for_pattern(subject, predicate, object, None) self.store_encoded_quads_for_pattern(subject, predicate, object, None)
// .filter(|quad| match quad { .filter(|quad| match quad {
// Err(_) => true, Err(_) => true,
// Ok(quad) => !quad.graph_name.is_default_graph(), Ok(quad) => !quad.graph_name.is_default_graph(),
// }), }),
// ) )
// } }
} }
pub fn encode_term<'a>(&self, term: impl Into<TermRef<'a>>) -> EncodedTerm { pub fn encode_term<'a>(&self, term: impl Into<TermRef<'a>>) -> EncodedTerm {

538
lib/src/sparql/eval.rs
Unescape View File

@ -214,14 +214,16 @@ impl SimpleEvaluator {
let predicate = predicate.clone(); let predicate = predicate.clone();
let object = object.clone(); let object = object.clone();
let graph_name = graph_name.clone(); let graph_name = graph_name.clone();
Box::new(iter.into_iter().filter_map(move |quad| { Box::new(iter.filter_map(move |quad| match quad {
let mut new_tuple = from.clone(); Ok(quad) => {
// put_pattern_value(&subject, quad.subject, &mut new_tuple)?; let mut new_tuple = from.clone();
// TODO put_pattern_value(&subject, quad.subject, &mut new_tuple)?;
// put_pattern_value(&predicate, quad.predicate, &mut new_tuple)?; put_pattern_value(&predicate, quad.predicate, &mut new_tuple)?;
// put_pattern_value(&object, quad.object, &mut new_tuple)?; put_pattern_value(&object, quad.object, &mut new_tuple)?;
// put_pattern_value(&graph_name, quad.graph_name, &mut new_tuple)?; put_pattern_value(&graph_name, quad.graph_name, &mut new_tuple)?;
Some(Ok(new_tuple)) Some(Ok(new_tuple))
}
Err(error) => Some(Err(error)),
})) }))
}) })
} }
@ -3154,9 +3156,8 @@ impl PathEvaluator {
Some(end), Some(end),
Some(graph_name), Some(graph_name),
) )
.into_iter()
.next() .next()
// .transpose()? .transpose()?
.is_some(), .is_some(),
PlanPropertyPath::Reverse(p) => self.eval_closed_in_graph(p, end, start, graph_name)?, PlanPropertyPath::Reverse(p) => self.eval_closed_in_graph(p, end, start, graph_name)?,
PlanPropertyPath::Sequence(a, b) => self PlanPropertyPath::Sequence(a, b) => self
@ -3202,16 +3203,15 @@ impl PathEvaluator {
PlanPropertyPath::NegatedPropertySet(ps) => self PlanPropertyPath::NegatedPropertySet(ps) => self
.dataset .dataset
.encoded_quads_for_pattern(Some(start), None, Some(end), Some(graph_name)) .encoded_quads_for_pattern(Some(start), None, Some(end), Some(graph_name))
.into_iter() .find_map(move |t| match t {
.find_map(move |t| { Ok(t) => {
// Ok(t) => { if ps.iter().any(|p| p.encoded == t.predicate) {
// if ps.iter().any(|p| p.encoded == t.predicate) { None
// None } else {
// } else { Some(Ok(()))
Some(Ok(())) }
// } }
// } Err(e) => Some(Err(e)),
// Err(e) => Some(Err(e)),
}) })
.transpose()? .transpose()?
.is_some(), .is_some(),
@ -3223,100 +3223,97 @@ impl PathEvaluator {
path: &PlanPropertyPath, path: &PlanPropertyPath,
start: &EncodedTerm, start: &EncodedTerm,
end: &EncodedTerm, end: &EncodedTerm,
// ) -> Box<dyn Iterator<Item = Result<EncodedTerm, EvaluationError>>> { ) -> Box<dyn Iterator<Item = Result<EncodedTerm, EvaluationError>>> {
) -> Vec<Term> { match path {
return Vec::new(); PlanPropertyPath::Path(p) => Box::new(
// match path { self.dataset
// PlanPropertyPath::Path(p) => Box::new( .encoded_quads_for_pattern(Some(start), Some(&p.encoded), Some(end), None)
// self.dataset .map(|t| Ok(t?.graph_name)),
// .encoded_quads_for_pattern(Some(start), Some(&p.encoded), Some(end), None) ),
// .into_iter() PlanPropertyPath::Reverse(p) => self.eval_closed_in_unknown_graph(p, end, start),
// .map(|t| Ok(t.graph_name)), PlanPropertyPath::Sequence(a, b) => {
// ), let eval = self.clone();
// PlanPropertyPath::Reverse(p) => self.eval_closed_in_unknown_graph(p, end, start), let b = Rc::clone(b);
// PlanPropertyPath::Sequence(a, b) => { let end = end.clone();
// let eval = self.clone(); Box::new(self.eval_from_in_unknown_graph(a, start).flat_map_ok(
// let b = Rc::clone(b); move |(middle, graph_name)| {
// let end = end.clone(); eval.eval_closed_in_graph(&b, &middle, &end, &graph_name)
// Box::new(self.eval_from_in_unknown_graph(a, start).flat_map_ok( .map(|is_found| is_found.then(|| graph_name))
// move |(middle, graph_name)| { .transpose()
// eval.eval_closed_in_graph(&b, &middle, &end, &graph_name) },
// .map(|is_found| is_found.then(|| graph_name)) ))
// .transpose() }
// }, PlanPropertyPath::Alternative(a, b) => Box::new(hash_deduplicate(
// )) self.eval_closed_in_unknown_graph(a, start, end)
// } .chain(self.eval_closed_in_unknown_graph(b, start, end)),
// PlanPropertyPath::Alternative(a, b) => Box::new(hash_deduplicate( )),
// self.eval_closed_in_unknown_graph(a, start, end) PlanPropertyPath::ZeroOrMore(p) => {
// .chain(self.eval_closed_in_unknown_graph(b, start, end)), let eval = self.clone();
// )), let start2 = start.clone();
// PlanPropertyPath::ZeroOrMore(p) => { let end = end.clone();
// let eval = self.clone(); let p = Rc::clone(p);
// let start2 = start.clone(); self.run_if_term_is_a_dataset_node(start, move |graph_name| {
// let end = end.clone(); look_in_transitive_closure(
// let p = Rc::clone(p); Some(Ok(start2.clone())),
// self.run_if_term_is_a_dataset_node(start, move |graph_name| { |e| eval.eval_from_in_graph(&p, &e, &graph_name),
// look_in_transitive_closure( &end,
// Some(Ok(start2.clone())), )
// |e| eval.eval_from_in_graph(&p, &e, &graph_name), .map(|is_found| is_found.then(|| graph_name))
// &end, .transpose()
// ) })
// .map(|is_found| is_found.then(|| graph_name)) }
// .transpose() PlanPropertyPath::OneOrMore(p) => {
// }) let eval = self.clone();
// } let end = end.clone();
// PlanPropertyPath::OneOrMore(p) => { let p = Rc::clone(p);
// let eval = self.clone(); Box::new(
// let end = end.clone(); self.eval_from_in_unknown_graph(&p, start)
// let p = Rc::clone(p); .filter_map(move |r| {
// Box::new( r.and_then(|(start, graph_name)| {
// self.eval_from_in_unknown_graph(&p, start) look_in_transitive_closure(
// .filter_map(move |r| { Some(Ok(start)),
// r.and_then(|(start, graph_name)| { |e| eval.eval_from_in_graph(&p, &e, &graph_name),
// look_in_transitive_closure( &end,
// Some(Ok(start)), )
// |e| eval.eval_from_in_graph(&p, &e, &graph_name), .map(|is_found| is_found.then(|| graph_name))
// &end, })
// ) .transpose()
// .map(|is_found| is_found.then(|| graph_name)) }),
// }) )
// .transpose() }
// }), PlanPropertyPath::ZeroOrOne(p) => {
// ) if start == end {
// } self.run_if_term_is_a_dataset_node(start, |graph_name| Some(Ok(graph_name)))
// PlanPropertyPath::ZeroOrOne(p) => { } else {
// if start == end { let eval = self.clone();
// self.run_if_term_is_a_dataset_node(start, |graph_name| Some(Ok(graph_name))) let start2 = start.clone();
// } else { let end = end.clone();
// let eval = self.clone(); let p = Rc::clone(p);
// let start2 = start.clone(); self.run_if_term_is_a_dataset_node(start, move |graph_name| {
// let end = end.clone(); eval.eval_closed_in_graph(&p, &start2, &end, &graph_name)
// let p = Rc::clone(p); .map(|is_found| is_found.then(|| graph_name))
// self.run_if_term_is_a_dataset_node(start, move |graph_name| { .transpose()
// eval.eval_closed_in_graph(&p, &start2, &end, &graph_name) })
// .map(|is_found| is_found.then(|| graph_name)) }
// .transpose() }
// }) PlanPropertyPath::NegatedPropertySet(ps) => {
// } let ps = Rc::clone(ps);
// } Box::new(
// PlanPropertyPath::NegatedPropertySet(ps) => { self.dataset
// let ps = Rc::clone(ps); .encoded_quads_for_pattern(Some(start), None, Some(end), None)
// Box::new( .filter_map(move |t| match t {
// self.dataset Ok(t) => {
// .encoded_quads_for_pattern(Some(start), None, Some(end), None) if ps.iter().any(|p| p.encoded == t.predicate) {
// .filter_map(move |t| match t { None
// Ok(t) => { } else {
// if ps.iter().any(|p| p.encoded == t.predicate) { Some(Ok(t.graph_name))
// None }
// } else { }
// Some(Ok(t.graph_name)) Err(e) => Some(Err(e)),
// } }),
// } )
// Err(e) => Some(Err(e)), }
// }), }
// )
// }
// }
} }
fn eval_from_in_graph( fn eval_from_in_graph(
@ -3324,170 +3321,167 @@ impl PathEvaluator {
path: &PlanPropertyPath, path: &PlanPropertyPath,
start: &EncodedTerm, start: &EncodedTerm,
graph_name: &EncodedTerm, graph_name: &EncodedTerm,
// ) -> Box<dyn Iterator<Item = Result<EncodedTerm, EvaluationError>>> { ) -> Box<dyn Iterator<Item = Result<EncodedTerm, EvaluationError>>> {
) -> Vec<Term> { match path {
Vec::new() PlanPropertyPath::Path(p) => Box::new(
self.dataset
.encoded_quads_for_pattern(
Some(start),
Some(&p.encoded),
None,
Some(graph_name),
)
.map(|t| Ok(t?.object)),
),
PlanPropertyPath::Reverse(p) => self.eval_to_in_graph(p, start, graph_name),
PlanPropertyPath::Sequence(a, b) => {
let eval = self.clone();
let b = Rc::clone(b);
let graph_name2 = graph_name.clone();
Box::new(
self.eval_from_in_graph(a, start, graph_name)
.flat_map_ok(move |middle| {
eval.eval_from_in_graph(&b, &middle, &graph_name2)
}),
)
}
PlanPropertyPath::Alternative(a, b) => Box::new(hash_deduplicate(
self.eval_from_in_graph(a, start, graph_name)
.chain(self.eval_from_in_graph(b, start, graph_name)),
)),
PlanPropertyPath::ZeroOrMore(p) => {
self.run_if_term_is_a_graph_node(start, graph_name, || {
let eval = self.clone();
let p = Rc::clone(p);
let graph_name2 = graph_name.clone();
transitive_closure(Some(Ok(start.clone())), move |e| {
eval.eval_from_in_graph(&p, &e, &graph_name2)
})
})
}
PlanPropertyPath::OneOrMore(p) => {
let eval = self.clone();
let p = Rc::clone(p);
let graph_name2 = graph_name.clone();
Box::new(transitive_closure(
self.eval_from_in_graph(&p, start, graph_name),
move |e| eval.eval_from_in_graph(&p, &e, &graph_name2),
))
}
PlanPropertyPath::ZeroOrOne(p) => {
self.run_if_term_is_a_graph_node(start, graph_name, || {
hash_deduplicate(
once(Ok(start.clone()))
.chain(self.eval_from_in_graph(p, start, graph_name)),
)
})
}
PlanPropertyPath::NegatedPropertySet(ps) => {
let ps = Rc::clone(ps);
Box::new(
self.dataset
.encoded_quads_for_pattern(Some(start), None, None, Some(graph_name))
.filter_map(move |t| match t {
Ok(t) => {
if ps.iter().any(|p| p.encoded == t.predicate) {
None
} else {
Some(Ok(t.object))
}
}
Err(e) => Some(Err(e)),
}),
)
}
}
} }
// match path {
// PlanPropertyPath::Path(p) => Box::new(
// self.dataset
// .encoded_quads_for_pattern(
// Some(start),
// Some(&p.encoded),
// None,
// Some(graph_name),
// )
// .map(|t| Ok(t?.object)),
// ),
// PlanPropertyPath::Reverse(p) => self.eval_to_in_graph(p, start, graph_name),
// PlanPropertyPath::Sequence(a, b) => {
// let eval = self.clone();
// let b = Rc::clone(b);
// let graph_name2 = graph_name.clone();
// Box::new(
// self.eval_from_in_graph(a, start, graph_name)
// .flat_map_ok(move |middle| {
// eval.eval_from_in_graph(&b, &middle, &graph_name2)
// }),
// )
// }
// PlanPropertyPath::Alternative(a, b) => Box::new(hash_deduplicate(
// self.eval_from_in_graph(a, start, graph_name)
// .chain(self.eval_from_in_graph(b, start, graph_name)),
// )),
// PlanPropertyPath::ZeroOrMore(p) => {
// self.run_if_term_is_a_graph_node(start, graph_name, || {
// let eval = self.clone();
// let p = Rc::clone(p);
// let graph_name2 = graph_name.clone();
// transitive_closure(Some(Ok(start.clone())), move |e| {
// eval.eval_from_in_graph(&p, &e, &graph_name2)
// })
// })
// }
// PlanPropertyPath::OneOrMore(p) => {
// let eval = self.clone();
// let p = Rc::clone(p);
// let graph_name2 = graph_name.clone();
// Box::new(transitive_closure(
// self.eval_from_in_graph(&p, start, graph_name),
// move |e| eval.eval_from_in_graph(&p, &e, &graph_name2),
// ))
// }
// PlanPropertyPath::ZeroOrOne(p) => {
// self.run_if_term_is_a_graph_node(start, graph_name, || {
// hash_deduplicate(
// once(Ok(start.clone()))
// .chain(self.eval_from_in_graph(p, start, graph_name)),
// )
// })
// }
// PlanPropertyPath::NegatedPropertySet(ps) => {
// let ps = Rc::clone(ps);
// Box::new(
// self.dataset
// .encoded_quads_for_pattern(Some(start), None, None, Some(graph_name))
// .filter_map(move |t| match t {
// Ok(t) => {
// if ps.iter().any(|p| p.encoded == t.predicate) {
// None
// } else {
// Some(Ok(t.object))
// }
// }
// Err(e) => Some(Err(e)),
// }),
// )
// }
// }
// }
fn eval_from_in_unknown_graph( fn eval_from_in_unknown_graph(
&self, &self,
path: &PlanPropertyPath, path: &PlanPropertyPath,
start: &EncodedTerm, start: &EncodedTerm,
// ) -> Box<dyn Iterator<Item = Result<(EncodedTerm, EncodedTerm), EvaluationError>>> { ) -> Box<dyn Iterator<Item = Result<(EncodedTerm, EncodedTerm), EvaluationError>>> {
// match path { match path {
// PlanPropertyPath::Path(p) => Box::new( PlanPropertyPath::Path(p) => Box::new(
// self.dataset self.dataset
// .encoded_quads_for_pattern(Some(start), Some(&p.encoded), None, None) .encoded_quads_for_pattern(Some(start), Some(&p.encoded), None, None)
// .map(|t| { .map(|t| {
// let t = t?; let t = t?;
// Ok((t.object, t.graph_name)) Ok((t.object, t.graph_name))
// }), }),
// ), ),
// PlanPropertyPath::Reverse(p) => self.eval_to_in_unknown_graph(p, start), PlanPropertyPath::Reverse(p) => self.eval_to_in_unknown_graph(p, start),
// PlanPropertyPath::Sequence(a, b) => { PlanPropertyPath::Sequence(a, b) => {
// let eval = self.clone(); let eval = self.clone();
// let b = Rc::clone(b); let b = Rc::clone(b);
// Box::new(self.eval_from_in_unknown_graph(a, start).flat_map_ok( Box::new(self.eval_from_in_unknown_graph(a, start).flat_map_ok(
// move |(middle, graph_name)| { move |(middle, graph_name)| {
// eval.eval_from_in_graph(&b, &middle, &graph_name) eval.eval_from_in_graph(&b, &middle, &graph_name)
// .map(move |end| Ok((end?, graph_name.clone()))) .map(move |end| Ok((end?, graph_name.clone())))
// }, },
// )) ))
// } }
// PlanPropertyPath::Alternative(a, b) => Box::new(hash_deduplicate( PlanPropertyPath::Alternative(a, b) => Box::new(hash_deduplicate(
// self.eval_from_in_unknown_graph(a, start) self.eval_from_in_unknown_graph(a, start)
// .chain(self.eval_from_in_unknown_graph(b, start)), .chain(self.eval_from_in_unknown_graph(b, start)),
// )), )),
// PlanPropertyPath::ZeroOrMore(p) => { PlanPropertyPath::ZeroOrMore(p) => {
// let start2 = start.clone(); let start2 = start.clone();
// let eval = self.clone(); let eval = self.clone();
// let p = Rc::clone(p); let p = Rc::clone(p);
// self.run_if_term_is_a_dataset_node(start, move |graph_name| { self.run_if_term_is_a_dataset_node(start, move |graph_name| {
// let eval = eval.clone(); let eval = eval.clone();
// let p = Rc::clone(&p); let p = Rc::clone(&p);
// let graph_name2 = graph_name.clone(); let graph_name2 = graph_name.clone();
// transitive_closure(Some(Ok(start2.clone())), move |e| { transitive_closure(Some(Ok(start2.clone())), move |e| {
// eval.eval_from_in_graph(&p, &e, &graph_name2) eval.eval_from_in_graph(&p, &e, &graph_name2)
// }) })
// .map(move |e| Ok((e?, graph_name.clone()))) .map(move |e| Ok((e?, graph_name.clone())))
// }) })
// } }
// PlanPropertyPath::OneOrMore(p) => { PlanPropertyPath::OneOrMore(p) => {
// let eval = self.clone(); let eval = self.clone();
// let p = Rc::clone(p); let p = Rc::clone(p);
// Box::new(transitive_closure( Box::new(transitive_closure(
// self.eval_from_in_unknown_graph(&p, start), self.eval_from_in_unknown_graph(&p, start),
// move |(e, graph_name)| { move |(e, graph_name)| {
// eval.eval_from_in_graph(&p, &e, &graph_name) eval.eval_from_in_graph(&p, &e, &graph_name)
// .map(move |e| Ok((e?, graph_name.clone()))) .map(move |e| Ok((e?, graph_name.clone())))
// }, },
// )) ))
// } }
// PlanPropertyPath::ZeroOrOne(p) => { PlanPropertyPath::ZeroOrOne(p) => {
// let eval = self.clone(); let eval = self.clone();
// let start2 = start.clone(); let start2 = start.clone();
// let p = Rc::clone(p); let p = Rc::clone(p);
// self.run_if_term_is_a_dataset_node(start, move |graph_name| { self.run_if_term_is_a_dataset_node(start, move |graph_name| {
// hash_deduplicate(once(Ok(start2.clone())).chain(eval.eval_from_in_graph( hash_deduplicate(once(Ok(start2.clone())).chain(eval.eval_from_in_graph(
// &p, &p,
// &start2, &start2,
// &graph_name, &graph_name,
// ))) )))
// .map(move |e| Ok((e?, graph_name.clone()))) .map(move |e| Ok((e?, graph_name.clone())))
// }) })
// } }
// PlanPropertyPath::NegatedPropertySet(ps) => { PlanPropertyPath::NegatedPropertySet(ps) => {
// let ps = Rc::clone(ps); let ps = Rc::clone(ps);
// Box::new( Box::new(
// self.dataset self.dataset
// .encoded_quads_for_pattern(Some(start), None, None, None) .encoded_quads_for_pattern(Some(start), None, None, None)
// .filter_map(move |t| match t { .filter_map(move |t| match t {
// Ok(t) => { Ok(t) => {
// if ps.iter().any(|p| p.encoded == t.predicate) { if ps.iter().any(|p| p.encoded == t.predicate) {
// None None
// } else { } else {
// Some(Ok((t.object, t.graph_name))) Some(Ok((t.object, t.graph_name)))
// } }
// } }
// Err(e) => Some(Err(e)), Err(e) => Some(Err(e)),
// }), }),
// ) )
// } }
// } }
// } }
fn eval_to_in_graph( fn eval_to_in_graph(
&self, &self,

49
lib/src/storage/mod.rs
Unescape View File

@ -378,8 +378,14 @@ impl StorageReader {
predicate: Option<&EncodedTerm>, predicate: Option<&EncodedTerm>,
object: Option<&EncodedTerm>, object: Option<&EncodedTerm>,
graph_name: Option<&EncodedTerm>, graph_name: Option<&EncodedTerm>,
) -> Vec<crate::model::Term> { ) -> ChainedDecodingQuadIterator {
return Vec::new(); return ChainedDecodingQuadIterator {
first: DecodingQuadIterator {
terms: Vec::new(),
encoding: QuadEncoding::Spog,
},
second: None,
};
// match subject { // match subject {
// Some(subject) => match predicate { // Some(subject) => match predicate {
// Some(predicate) => match object { // Some(predicate) => match object {
@ -436,8 +442,11 @@ impl StorageReader {
// } // }
} }
pub fn quads(&self) -> Vec<crate::model::Term> { pub fn quads(&self) -> ChainedDecodingQuadIterator {
Vec::new() ChainedDecodingQuadIterator::new(DecodingQuadIterator {
terms: Vec::new(),
encoding: QuadEncoding::Spog,
})
// ChainedDecodingQuadIterator::pair(self.dspo_quads(&[]), self.gspo_quads(&[])) // ChainedDecodingQuadIterator::pair(self.dspo_quads(&[]), self.gspo_quads(&[]))
} }
@ -608,8 +617,8 @@ impl StorageReader {
// }) // })
// } // }
pub fn named_graphs(&self) -> Vec<crate::model::Term> { pub fn named_graphs(&self) -> DecodingGraphIterator {
Vec::new() DecodingGraphIterator { terms: Vec::new() }
} }
pub fn contains_named_graph(&self, graph_name: &EncodedTerm) -> Result<bool, StorageError> { pub fn contains_named_graph(&self, graph_name: &EncodedTerm) -> Result<bool, StorageError> {
@ -671,7 +680,7 @@ impl Iterator for ChainedDecodingQuadIterator {
} }
pub struct DecodingQuadIterator { pub struct DecodingQuadIterator {
iter: Iter, terms: Vec<EncodedQuad>,
encoding: QuadEncoding, encoding: QuadEncoding,
} }
@ -679,29 +688,29 @@ impl Iterator for DecodingQuadIterator {
type Item = Result<EncodedQuad, StorageError>; type Item = Result<EncodedQuad, StorageError>;
fn next(&mut self) -> Option<Result<EncodedQuad, StorageError>> { fn next(&mut self) -> Option<Result<EncodedQuad, StorageError>> {
if let Err(e) = self.iter.status() { // if let Err(e) = self.iter.status() {
return Some(Err(e)); // return Some(Err(e));
} // }
let term = self.encoding.decode(self.iter.key()?); // let term = self.encoding.decode(self.iter.key()?);
self.iter.next(); // self.iter.next();
Some(term) self.terms.pop().map(|x| Ok(x))
} }
} }
pub struct DecodingGraphIterator { pub struct DecodingGraphIterator {
iter: Iter, terms: Vec<EncodedTerm>,
} }
impl Iterator for DecodingGraphIterator { impl Iterator for DecodingGraphIterator {
type Item = Result<EncodedTerm, StorageError>; type Item = Result<EncodedTerm, StorageError>;
fn next(&mut self) -> Option<Result<EncodedTerm, StorageError>> { fn next(&mut self) -> Option<Result<EncodedTerm, StorageError>> {
if let Err(e) = self.iter.status() { // if let Err(e) = self.iter.status() {
return Some(Err(e)); // return Some(Err(e));
} // }
let term = decode_term(self.iter.key()?); // let term = self.encoding.decode(self.iter.key()?);
self.iter.next(); // self.iter.next();
Some(term) self.terms.pop().map(|x| Ok(x))
} }
} }

330
lib/src/store.rs
Unescape View File

@ -237,10 +237,7 @@ impl Store {
options: QueryOptions, options: QueryOptions,
with_stats: bool, with_stats: bool,
) -> Result<(Result<QueryResults, EvaluationError>, QueryExplanation), EvaluationError> { ) -> Result<(Result<QueryResults, EvaluationError>, QueryExplanation), EvaluationError> {
// evaluate_query(self.storage.snapshot(), query, options, with_stats) evaluate_query(self.storage.snapshot(), query, options, with_stats)
Err(EvaluationError::Storage(StorageError::Io(
std::io::Error::new(std::io::ErrorKind::NotFound, "Not yet implemented"),
)))
} }
/// Retrieves quads with a filter on each quad component /// Retrieves quads with a filter on each quad component
@ -268,14 +265,17 @@ impl Store {
predicate: Option<NamedNodeRef<'_>>, predicate: Option<NamedNodeRef<'_>>,
object: Option<TermRef<'_>>, object: Option<TermRef<'_>>,
graph_name: Option<GraphNameRef<'_>>, graph_name: Option<GraphNameRef<'_>>,
) -> Vec<Term> { ) -> QuadIter {
let reader = self.storage.snapshot(); let reader = self.storage.snapshot();
reader.quads_for_pattern( QuadIter {
subject.map(EncodedTerm::from).as_ref(), iter: reader.quads_for_pattern(
predicate.map(EncodedTerm::from).as_ref(), subject.map(EncodedTerm::from).as_ref(),
object.map(EncodedTerm::from).as_ref(), predicate.map(EncodedTerm::from).as_ref(),
graph_name.map(EncodedTerm::from).as_ref(), object.map(EncodedTerm::from).as_ref(),
) graph_name.map(EncodedTerm::from).as_ref(),
),
reader,
}
} }
/// Returns all the quads contained in the store. /// Returns all the quads contained in the store.
@ -297,7 +297,7 @@ impl Store {
/// assert_eq!(vec![quad], results); /// assert_eq!(vec![quad], results);
/// # Result::<_, Box<dyn std::error::Error>>::Ok(()) /// # Result::<_, Box<dyn std::error::Error>>::Ok(())
/// ``` /// ```
pub fn iter(&self) -> Vec<Term> { pub fn iter(&self) -> QuadIter {
self.quads_for_pattern(None, None, None, None) self.quads_for_pattern(None, None, None, None)
} }
@ -489,9 +489,8 @@ impl Store {
// for quad in &quads { // for quad in &quads {
// t.insert(quad.as_ref().in_graph(to_graph_name))?; // t.insert(quad.as_ref().in_graph(to_graph_name))?;
// } // }
// Ok(())
// })
Ok(()) Ok(())
// })
} }
/// Loads a dataset file (i.e. quads) into the store. /// Loads a dataset file (i.e. quads) into the store.
@ -532,9 +531,8 @@ impl Store {
// for quad in &quads { // for quad in &quads {
// t.insert(quad.into())?; // t.insert(quad.into())?;
// } // }
// Ok(())
// })
Ok(()) Ok(())
// })
} }
/// Adds a quad to this store. /// Adds a quad to this store.
@ -625,9 +623,9 @@ impl Store {
from_graph_name: impl Into<GraphNameRef<'a>>, from_graph_name: impl Into<GraphNameRef<'a>>,
) -> Result<(), SerializerError> { ) -> Result<(), SerializerError> {
let mut writer = GraphSerializer::from_format(format).triple_writer(writer)?; let mut writer = GraphSerializer::from_format(format).triple_writer(writer)?;
// for quad in self.quads_for_pattern(None, None, None, Some(from_graph_name.into())) { for quad in self.quads_for_pattern(None, None, None, Some(from_graph_name.into())) {
// writer.write(quad?.as_ref())?; writer.write(quad?.as_ref())?;
// } }
writer.finish()?; writer.finish()?;
Ok(()) Ok(())
} }
@ -654,9 +652,9 @@ impl Store {
format: DatasetFormat, format: DatasetFormat,
) -> Result<(), SerializerError> { ) -> Result<(), SerializerError> {
let mut writer = DatasetSerializer::from_format(format).quad_writer(writer)?; let mut writer = DatasetSerializer::from_format(format).quad_writer(writer)?;
// for quad in self.iter() { for quad in self.iter() {
// writer.write(&quad?)?; writer.write(&quad?)?;
// } }
writer.finish()?; writer.finish()?;
Ok(()) Ok(())
} }
@ -675,13 +673,13 @@ impl Store {
/// assert_eq!(vec![NamedOrBlankNode::from(ex)], store.named_graphs().collect::<Result<Vec<_>,_>>()?); /// assert_eq!(vec![NamedOrBlankNode::from(ex)], store.named_graphs().collect::<Result<Vec<_>,_>>()?);
/// # Result::<_, Box<dyn std::error::Error>>::Ok(()) /// # Result::<_, Box<dyn std::error::Error>>::Ok(())
/// ``` /// ```
// pub fn named_graphs(&self) -> GraphNameIter { pub fn named_graphs(&self) -> GraphNameIter {
// let reader = self.storage.snapshot(); let reader = self.storage.snapshot();
// GraphNameIter { GraphNameIter {
// iter: reader.named_graphs().iter(), iter: reader.named_graphs(),
// reader, reader,
// } }
// } }
/// Checks if the store contains a given graph /// Checks if the store contains a given graph
/// ///
@ -883,7 +881,7 @@ impl Store {
impl fmt::Display for Store { impl fmt::Display for Store {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
for t in self.iter() { for t in self.iter() {
writeln!(f, "{} .", t)?; writeln!(f, "{} .", t.map_err(|_| fmt::Error)?)?;
} }
Ok(()) Ok(())
} }
@ -990,18 +988,21 @@ impl<'a> Transaction<'a> {
predicate: Option<NamedNodeRef<'_>>, predicate: Option<NamedNodeRef<'_>>,
object: Option<TermRef<'_>>, object: Option<TermRef<'_>>,
graph_name: Option<GraphNameRef<'_>>, graph_name: Option<GraphNameRef<'_>>,
) -> Vec<Term> { ) -> QuadIter {
let reader = self.writer.reader(); let reader = self.writer.reader();
reader.quads_for_pattern( QuadIter {
subject.map(EncodedTerm::from).as_ref(), iter: reader.quads_for_pattern(
predicate.map(EncodedTerm::from).as_ref(), subject.map(EncodedTerm::from).as_ref(),
object.map(EncodedTerm::from).as_ref(), predicate.map(EncodedTerm::from).as_ref(),
graph_name.map(EncodedTerm::from).as_ref(), object.map(EncodedTerm::from).as_ref(),
) graph_name.map(EncodedTerm::from).as_ref(),
),
reader,
}
} }
/// Returns all the quads contained in the store. /// Returns all the quads contained in the store.
pub fn iter(&self) -> Vec<Term> { pub fn iter(&self) -> QuadIter {
self.quads_for_pattern(None, None, None, None) self.quads_for_pattern(None, None, None, None)
} }
@ -1202,13 +1203,12 @@ impl<'a> Transaction<'a> {
} }
/// Returns all the store named graphs. /// Returns all the store named graphs.
pub fn named_graphs(&self) -> Vec<Term> { pub fn named_graphs(&self) -> GraphNameIter {
// let reader = self.writer.reader(); let reader = self.writer.reader();
// GraphNameIter { GraphNameIter {
// iter: reader.named_graphs(), iter: reader.named_graphs(),
// reader, reader,
// } }
Vec::new()
} }
/// Checks if the store contains a given graph. /// Checks if the store contains a given graph.
@ -1617,23 +1617,22 @@ fn store() -> Result<(), StorageError> {
GraphName::DefaultGraph, GraphName::DefaultGraph,
), ),
]; ];
// let all_quads = vec![ let all_quads = vec![
// Quad::new( Quad::new(
// main_s.clone(), main_s.clone(),
// main_p.clone(), main_p.clone(),
// Literal::from(0), Literal::from(0),
// GraphName::DefaultGraph, GraphName::DefaultGraph,
// ), ),
// default_quad.clone(), default_quad.clone(),
// Quad::new( Quad::new(
// main_s.clone(), main_s.clone(),
// main_p.clone(), main_p.clone(),
// Literal::from(200_000_000), Literal::from(200_000_000),
// GraphName::DefaultGraph, GraphName::DefaultGraph,
// ), ),
// named_quad.clone(), named_quad.clone(),
// ]; ];
let all_quads = Vec::new();
let store = Store::new()?; let store = Store::new()?;
for t in &default_quads { for t in &default_quads {
@ -1649,140 +1648,147 @@ fn store() -> Result<(), StorageError> {
assert!(!store.insert(&default_quad)?); assert!(!store.insert(&default_quad)?);
assert_eq!(store.len()?, 4); assert_eq!(store.len()?, 4);
assert_eq!(store.iter(), all_quads); assert_eq!(store.iter().collect::<Result<Vec<_>, _>>()?, all_quads);
assert_eq!( assert_eq!(
store.quads_for_pattern(Some(main_s.as_ref()), None, None, None), store
.quads_for_pattern(Some(main_s.as_ref()), None, None, None)
.collect::<Result<Vec<_>, _>>()?,
all_quads all_quads
); );
assert_eq!( assert_eq!(
store.quads_for_pattern(Some(main_s.as_ref()), Some(main_p.as_ref()), None, None), store
.quads_for_pattern(Some(main_s.as_ref()), Some(main_p.as_ref()), None, None)
.collect::<Result<Vec<_>, _>>()?,
all_quads all_quads
); );
assert_eq!( assert_eq!(
store.quads_for_pattern( store
Some(main_s.as_ref()), .quads_for_pattern(
Some(main_p.as_ref()), Some(main_s.as_ref()),
Some(main_o.as_ref()), Some(main_p.as_ref()),
None Some(main_o.as_ref()),
), None
// vec![default_quad.clone(), named_quad.clone()] )
Vec::new() .collect::<Result<Vec<_>, _>>()?,
vec![default_quad.clone(), named_quad.clone()]
); );
assert_eq!( assert_eq!(
store.quads_for_pattern( store
Some(main_s.as_ref()), .quads_for_pattern(
Some(main_p.as_ref()), Some(main_s.as_ref()),
Some(main_o.as_ref()), Some(main_p.as_ref()),
Some(GraphNameRef::DefaultGraph) Some(main_o.as_ref()),
), Some(GraphNameRef::DefaultGraph)
// .collect::<Result<Vec<_>, _>>()?, )
// vec![default_quad.clone()] .collect::<Result<Vec<_>, _>>()?,
Vec::new() vec![default_quad.clone()]
); );
assert_eq!( assert_eq!(
store.quads_for_pattern( store
Some(main_s.as_ref()), .quads_for_pattern(
Some(main_p.as_ref()), Some(main_s.as_ref()),
Some(main_o.as_ref()), Some(main_p.as_ref()),
Some(main_g.as_ref()) Some(main_o.as_ref()),
), Some(main_g.as_ref())
// .collect::<Result<Vec<_>, _>>()?, )
// vec![named_quad.clone()] .collect::<Result<Vec<_>, _>>()?,
Vec::new() vec![named_quad.clone()]
); );
assert_eq!( assert_eq!(
store.quads_for_pattern( store
Some(main_s.as_ref()), .quads_for_pattern(
Some(main_p.as_ref()), Some(main_s.as_ref()),
None, Some(main_p.as_ref()),
Some(GraphNameRef::DefaultGraph) None,
), Some(GraphNameRef::DefaultGraph)
// .collect::<Result<Vec<_>, _>>()?, )
// default_quads .collect::<Result<Vec<_>, _>>()?,
Vec::new() default_quads
); );
assert_eq!( assert_eq!(
store.quads_for_pattern(Some(main_s.as_ref()), None, Some(main_o.as_ref()), None), store
// vec![default_quad.clone(), named_quad.clone()] .quads_for_pattern(Some(main_s.as_ref()), None, Some(main_o.as_ref()), None)
Vec::new() .collect::<Result<Vec<_>, _>>()?,
vec![default_quad.clone(), named_quad.clone()]
); );
assert_eq!( assert_eq!(
store.quads_for_pattern( store
Some(main_s.as_ref()), .quads_for_pattern(
None, Some(main_s.as_ref()),
Some(main_o.as_ref()), None,
Some(GraphNameRef::DefaultGraph) Some(main_o.as_ref()),
), Some(GraphNameRef::DefaultGraph)
// .collect::<Result<Vec<_>, _>>()?, )
// vec![default_quad.clone()] .collect::<Result<Vec<_>, _>>()?,
Vec::new() vec![default_quad.clone()]
); );
assert_eq!( assert_eq!(
store.quads_for_pattern( store
Some(main_s.as_ref()), .quads_for_pattern(
None, Some(main_s.as_ref()),
Some(main_o.as_ref()), None,
Some(main_g.as_ref()) Some(main_o.as_ref()),
), Some(main_g.as_ref())
// .collect::<Result<Vec<_>, _>>()?, )
// vec![named_quad.clone()] .collect::<Result<Vec<_>, _>>()?,
Vec::new() vec![named_quad.clone()]
); );
assert_eq!( assert_eq!(
store.quads_for_pattern( store
Some(main_s.as_ref()), .quads_for_pattern(
None, Some(main_s.as_ref()),
None, None,
Some(GraphNameRef::DefaultGraph) None,
), Some(GraphNameRef::DefaultGraph)
// .collect::<Result<Vec<_>, _>>()?, )
// default_quads .collect::<Result<Vec<_>, _>>()?,
Vec::new() default_quads
); );
assert_eq!( assert_eq!(
store.quads_for_pattern(None, Some(main_p.as_ref()), None, None), store
// .collect::<Result<Vec<_>, _>>()?, .quads_for_pattern(None, Some(main_p.as_ref()), None, None)
.collect::<Result<Vec<_>, _>>()?,
all_quads all_quads
); );
assert_eq!( assert_eq!(
store.quads_for_pattern(None, Some(main_p.as_ref()), Some(main_o.as_ref()), None), store
// .collect::<Result<Vec<_>, _>>()?, .quads_for_pattern(None, Some(main_p.as_ref()), Some(main_o.as_ref()), None)
// vec![default_quad.clone(), named_quad.clone()] .collect::<Result<Vec<_>, _>>()?,
Vec::new() vec![default_quad.clone(), named_quad.clone()]
); );
assert_eq!( assert_eq!(
store.quads_for_pattern(None, None, Some(main_o.as_ref()), None), store
// .collect::<Result<Vec<_>, _>>()?, .quads_for_pattern(None, None, Some(main_o.as_ref()), None)
// vec![default_quad.clone(), named_quad.clone()] .collect::<Result<Vec<_>, _>>()?,
Vec::new() vec![default_quad.clone(), named_quad.clone()]
); );
assert_eq!( assert_eq!(
store.quads_for_pattern(None, None, None, Some(GraphNameRef::DefaultGraph)), store
// .collect::<Result<Vec<_>, _>>()?, .quads_for_pattern(None, None, None, Some(GraphNameRef::DefaultGraph))
// default_quads .collect::<Result<Vec<_>, _>>()?,
Vec::new() default_quads
); );
assert_eq!( assert_eq!(
store.quads_for_pattern( store
None, .quads_for_pattern(
Some(main_p.as_ref()), None,
Some(main_o.as_ref()), Some(main_p.as_ref()),
Some(GraphNameRef::DefaultGraph) Some(main_o.as_ref()),
), Some(GraphNameRef::DefaultGraph)
// .collect::<Result<Vec<_>, _>>()?, )
// vec![default_quad] .collect::<Result<Vec<_>, _>>()?,
Vec::new() vec![default_quad]
); );
assert_eq!( assert_eq!(
store.quads_for_pattern( store
None, .quads_for_pattern(
Some(main_p.as_ref()), None,
Some(main_o.as_ref()), Some(main_p.as_ref()),
Some(main_g.as_ref()) Some(main_o.as_ref()),
), Some(main_g.as_ref())
// .collect::<Result<Vec<_>, _>>()?, )
// vec![named_quad] .collect::<Result<Vec<_>, _>>()?,
Vec::new() vec![named_quad]
); );
Ok(()) Ok(())

Write Preview
Loading…
Cancel
Save