|
|
|
@ -237,7 +237,10 @@ 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
|
|
|
|
@ -265,17 +268,14 @@ impl Store { |
|
|
|
predicate: Option<NamedNodeRef<'_>>, |
|
|
|
predicate: Option<NamedNodeRef<'_>>, |
|
|
|
object: Option<TermRef<'_>>, |
|
|
|
object: Option<TermRef<'_>>, |
|
|
|
graph_name: Option<GraphNameRef<'_>>, |
|
|
|
graph_name: Option<GraphNameRef<'_>>, |
|
|
|
) -> QuadIter { |
|
|
|
) -> Vec<Term> { |
|
|
|
let reader = self.storage.snapshot(); |
|
|
|
let reader = self.storage.snapshot(); |
|
|
|
QuadIter { |
|
|
|
reader.quads_for_pattern( |
|
|
|
iter: reader.quads_for_pattern( |
|
|
|
subject.map(EncodedTerm::from).as_ref(), |
|
|
|
subject.map(EncodedTerm::from).as_ref(), |
|
|
|
predicate.map(EncodedTerm::from).as_ref(), |
|
|
|
predicate.map(EncodedTerm::from).as_ref(), |
|
|
|
object.map(EncodedTerm::from).as_ref(), |
|
|
|
object.map(EncodedTerm::from).as_ref(), |
|
|
|
graph_name.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) -> QuadIter { |
|
|
|
pub fn iter(&self) -> Vec<Term> { |
|
|
|
self.quads_for_pattern(None, None, None, None) |
|
|
|
self.quads_for_pattern(None, None, None, None) |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
@ -387,12 +387,12 @@ impl Store { |
|
|
|
/// })?;
|
|
|
|
/// })?;
|
|
|
|
/// # Result::<_, Box<dyn std::error::Error>>::Ok(())
|
|
|
|
/// # Result::<_, Box<dyn std::error::Error>>::Ok(())
|
|
|
|
/// ```
|
|
|
|
/// ```
|
|
|
|
pub fn transaction<'a, 'b: 'a, T, E: Error + 'static + From<StorageError>>( |
|
|
|
// pub fn transaction<'a, 'b: 'a, T, E: Error + 'static + From<StorageError>>(
|
|
|
|
&'b self, |
|
|
|
// &'b self,
|
|
|
|
f: impl Fn(Transaction<'a>) -> Result<T, E>, |
|
|
|
// f: impl Fn(Transaction<'a>) -> Result<T, E>,
|
|
|
|
) -> Result<T, E> { |
|
|
|
// ) -> Result<T, E> {
|
|
|
|
self.storage.transaction(|writer| f(Transaction { writer })) |
|
|
|
// self.storage.transaction(|writer| f(Transaction { writer }))
|
|
|
|
} |
|
|
|
// }
|
|
|
|
|
|
|
|
|
|
|
|
/// Executes a [SPARQL 1.1 update](https://www.w3.org/TR/sparql11-update/).
|
|
|
|
/// Executes a [SPARQL 1.1 update](https://www.w3.org/TR/sparql11-update/).
|
|
|
|
///
|
|
|
|
///
|
|
|
|
@ -442,8 +442,9 @@ impl Store { |
|
|
|
) -> Result<(), EvaluationError> { |
|
|
|
) -> Result<(), EvaluationError> { |
|
|
|
let update = update.try_into().map_err(Into::into)?; |
|
|
|
let update = update.try_into().map_err(Into::into)?; |
|
|
|
let options = options.into(); |
|
|
|
let options = options.into(); |
|
|
|
self.storage |
|
|
|
// self.storage
|
|
|
|
.transaction(|mut t| evaluate_update(&mut t, &update, &options)) |
|
|
|
// .transaction(|mut t| evaluate_update(&mut t, &update, &options))
|
|
|
|
|
|
|
|
Ok(()) |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
/// Loads a graph file (i.e. triples) into the store.
|
|
|
|
/// Loads a graph file (i.e. triples) into the store.
|
|
|
|
@ -484,12 +485,13 @@ impl Store { |
|
|
|
.read_triples(reader)? |
|
|
|
.read_triples(reader)? |
|
|
|
.collect::<Result<Vec<_>, _>>()?; |
|
|
|
.collect::<Result<Vec<_>, _>>()?; |
|
|
|
let to_graph_name = to_graph_name.into(); |
|
|
|
let to_graph_name = to_graph_name.into(); |
|
|
|
self.storage.transaction(move |mut t| { |
|
|
|
// self.storage.transaction(move |mut t| {
|
|
|
|
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.
|
|
|
|
@ -526,12 +528,13 @@ impl Store { |
|
|
|
.map_err(|e| ParseError::invalid_base_iri(base_iri, e))?; |
|
|
|
.map_err(|e| ParseError::invalid_base_iri(base_iri, e))?; |
|
|
|
} |
|
|
|
} |
|
|
|
let quads = parser.read_quads(reader)?.collect::<Result<Vec<_>, _>>()?; |
|
|
|
let quads = parser.read_quads(reader)?.collect::<Result<Vec<_>, _>>()?; |
|
|
|
self.storage.transaction(move |mut t| { |
|
|
|
// self.storage.transaction(move |mut t| {
|
|
|
|
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.
|
|
|
|
@ -555,7 +558,8 @@ impl Store { |
|
|
|
/// ```
|
|
|
|
/// ```
|
|
|
|
pub fn insert<'a>(&self, quad: impl Into<QuadRef<'a>>) -> Result<bool, StorageError> { |
|
|
|
pub fn insert<'a>(&self, quad: impl Into<QuadRef<'a>>) -> Result<bool, StorageError> { |
|
|
|
let quad = quad.into(); |
|
|
|
let quad = quad.into(); |
|
|
|
self.transaction(|mut t| t.insert(quad)) |
|
|
|
// self.transaction(|mut t| t.insert(quad))
|
|
|
|
|
|
|
|
Ok(true) |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
/// Adds atomically a set of quads to this store.
|
|
|
|
/// Adds atomically a set of quads to this store.
|
|
|
|
@ -566,7 +570,8 @@ impl Store { |
|
|
|
quads: impl IntoIterator<Item = impl Into<Quad>>, |
|
|
|
quads: impl IntoIterator<Item = impl Into<Quad>>, |
|
|
|
) -> Result<(), StorageError> { |
|
|
|
) -> Result<(), StorageError> { |
|
|
|
let quads = quads.into_iter().map(Into::into).collect::<Vec<_>>(); |
|
|
|
let quads = quads.into_iter().map(Into::into).collect::<Vec<_>>(); |
|
|
|
self.transaction(move |mut t| t.extend(&quads)) |
|
|
|
// self.transaction(move |mut t| t.extend(&quads))
|
|
|
|
|
|
|
|
Ok(()) |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
/// Removes a quad from this store.
|
|
|
|
/// Removes a quad from this store.
|
|
|
|
@ -591,7 +596,8 @@ impl Store { |
|
|
|
/// ```
|
|
|
|
/// ```
|
|
|
|
pub fn remove<'a>(&self, quad: impl Into<QuadRef<'a>>) -> Result<bool, StorageError> { |
|
|
|
pub fn remove<'a>(&self, quad: impl Into<QuadRef<'a>>) -> Result<bool, StorageError> { |
|
|
|
let quad = quad.into(); |
|
|
|
let quad = quad.into(); |
|
|
|
self.transaction(move |mut t| t.remove(quad)) |
|
|
|
// self.transaction(move |mut t| t.remove(quad))
|
|
|
|
|
|
|
|
Ok(true) |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
/// Dumps a store graph into a file.
|
|
|
|
/// Dumps a store graph into a file.
|
|
|
|
@ -619,9 +625,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(()) |
|
|
|
} |
|
|
|
} |
|
|
|
@ -648,9 +654,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(()) |
|
|
|
} |
|
|
|
} |
|
|
|
@ -669,13 +675,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: reader.named_graphs().iter(),
|
|
|
|
reader, |
|
|
|
// reader,
|
|
|
|
} |
|
|
|
// }
|
|
|
|
} |
|
|
|
// }
|
|
|
|
|
|
|
|
|
|
|
|
/// Checks if the store contains a given graph
|
|
|
|
/// Checks if the store contains a given graph
|
|
|
|
///
|
|
|
|
///
|
|
|
|
@ -719,7 +725,8 @@ impl Store { |
|
|
|
graph_name: impl Into<NamedOrBlankNodeRef<'a>>, |
|
|
|
graph_name: impl Into<NamedOrBlankNodeRef<'a>>, |
|
|
|
) -> Result<bool, StorageError> { |
|
|
|
) -> Result<bool, StorageError> { |
|
|
|
let graph_name = graph_name.into(); |
|
|
|
let graph_name = graph_name.into(); |
|
|
|
self.transaction(|mut t| t.insert_named_graph(graph_name)) |
|
|
|
// self.transaction(|mut t| t.insert_named_graph(graph_name))
|
|
|
|
|
|
|
|
Ok(true) |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
/// Clears a graph from this store.
|
|
|
|
/// Clears a graph from this store.
|
|
|
|
@ -745,7 +752,8 @@ impl Store { |
|
|
|
graph_name: impl Into<GraphNameRef<'a>>, |
|
|
|
graph_name: impl Into<GraphNameRef<'a>>, |
|
|
|
) -> Result<(), StorageError> { |
|
|
|
) -> Result<(), StorageError> { |
|
|
|
let graph_name = graph_name.into(); |
|
|
|
let graph_name = graph_name.into(); |
|
|
|
self.transaction(|mut t| t.clear_graph(graph_name)) |
|
|
|
// self.transaction(|mut t| t.clear_graph(graph_name))
|
|
|
|
|
|
|
|
Ok(()) |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
/// Removes a graph from this store.
|
|
|
|
/// Removes a graph from this store.
|
|
|
|
@ -773,7 +781,8 @@ impl Store { |
|
|
|
graph_name: impl Into<NamedOrBlankNodeRef<'a>>, |
|
|
|
graph_name: impl Into<NamedOrBlankNodeRef<'a>>, |
|
|
|
) -> Result<bool, StorageError> { |
|
|
|
) -> Result<bool, StorageError> { |
|
|
|
let graph_name = graph_name.into(); |
|
|
|
let graph_name = graph_name.into(); |
|
|
|
self.transaction(|mut t| t.remove_named_graph(graph_name)) |
|
|
|
// self.transaction(|mut t| t.remove_named_graph(graph_name))
|
|
|
|
|
|
|
|
Ok(true) |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
/// Clears the store.
|
|
|
|
/// Clears the store.
|
|
|
|
@ -794,7 +803,8 @@ impl Store { |
|
|
|
/// # Result::<_, Box<dyn std::error::Error>>::Ok(())
|
|
|
|
/// # Result::<_, Box<dyn std::error::Error>>::Ok(())
|
|
|
|
/// ```
|
|
|
|
/// ```
|
|
|
|
pub fn clear(&self) -> Result<(), StorageError> { |
|
|
|
pub fn clear(&self) -> Result<(), StorageError> { |
|
|
|
self.transaction(|mut t| t.clear()) |
|
|
|
// self.transaction(|mut t| t.clear())
|
|
|
|
|
|
|
|
Ok(()) |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
/// Flushes all buffers and ensures that all writes are saved on disk.
|
|
|
|
/// Flushes all buffers and ensures that all writes are saved on disk.
|
|
|
|
@ -873,7 +883,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.map_err(|_| fmt::Error)?)?; |
|
|
|
writeln!(f, "{} .", t)?; |
|
|
|
} |
|
|
|
} |
|
|
|
Ok(()) |
|
|
|
Ok(()) |
|
|
|
} |
|
|
|
} |
|
|
|
@ -980,21 +990,18 @@ impl<'a> Transaction<'a> { |
|
|
|
predicate: Option<NamedNodeRef<'_>>, |
|
|
|
predicate: Option<NamedNodeRef<'_>>, |
|
|
|
object: Option<TermRef<'_>>, |
|
|
|
object: Option<TermRef<'_>>, |
|
|
|
graph_name: Option<GraphNameRef<'_>>, |
|
|
|
graph_name: Option<GraphNameRef<'_>>, |
|
|
|
) -> QuadIter { |
|
|
|
) -> Vec<Term> { |
|
|
|
let reader = self.writer.reader(); |
|
|
|
let reader = self.writer.reader(); |
|
|
|
QuadIter { |
|
|
|
reader.quads_for_pattern( |
|
|
|
iter: reader.quads_for_pattern( |
|
|
|
subject.map(EncodedTerm::from).as_ref(), |
|
|
|
subject.map(EncodedTerm::from).as_ref(), |
|
|
|
predicate.map(EncodedTerm::from).as_ref(), |
|
|
|
predicate.map(EncodedTerm::from).as_ref(), |
|
|
|
object.map(EncodedTerm::from).as_ref(), |
|
|
|
object.map(EncodedTerm::from).as_ref(), |
|
|
|
graph_name.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) -> QuadIter { |
|
|
|
pub fn iter(&self) -> Vec<Term> { |
|
|
|
self.quads_for_pattern(None, None, None, None) |
|
|
|
self.quads_for_pattern(None, None, None, None) |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
@ -1195,12 +1202,13 @@ impl<'a> Transaction<'a> { |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
/// Returns all the store named graphs.
|
|
|
|
/// Returns all the store named graphs.
|
|
|
|
pub fn named_graphs(&self) -> GraphNameIter { |
|
|
|
pub fn named_graphs(&self) -> Vec<Term> { |
|
|
|
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.
|
|
|
|
@ -1609,22 +1617,23 @@ 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 { |
|
|
|
@ -1640,147 +1649,140 @@ 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().collect::<Result<Vec<_>, _>>()?, all_quads); |
|
|
|
assert_eq!(store.iter(), all_quads); |
|
|
|
assert_eq!( |
|
|
|
assert_eq!( |
|
|
|
store |
|
|
|
store.quads_for_pattern(Some(main_s.as_ref()), None, None, None), |
|
|
|
.quads_for_pattern(Some(main_s.as_ref()), None, None, None) |
|
|
|
|
|
|
|
.collect::<Result<Vec<_>, _>>()?, |
|
|
|
|
|
|
|
all_quads |
|
|
|
all_quads |
|
|
|
); |
|
|
|
); |
|
|
|
assert_eq!( |
|
|
|
assert_eq!( |
|
|
|
store |
|
|
|
store.quads_for_pattern(Some(main_s.as_ref()), Some(main_p.as_ref()), None, None), |
|
|
|
.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 |
|
|
|
store.quads_for_pattern( |
|
|
|
.quads_for_pattern( |
|
|
|
Some(main_s.as_ref()), |
|
|
|
Some(main_s.as_ref()), |
|
|
|
Some(main_p.as_ref()), |
|
|
|
Some(main_p.as_ref()), |
|
|
|
Some(main_o.as_ref()), |
|
|
|
Some(main_o.as_ref()), |
|
|
|
None |
|
|
|
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 |
|
|
|
store.quads_for_pattern( |
|
|
|
.quads_for_pattern( |
|
|
|
Some(main_s.as_ref()), |
|
|
|
Some(main_s.as_ref()), |
|
|
|
Some(main_p.as_ref()), |
|
|
|
Some(main_p.as_ref()), |
|
|
|
Some(main_o.as_ref()), |
|
|
|
Some(main_o.as_ref()), |
|
|
|
Some(GraphNameRef::DefaultGraph) |
|
|
|
Some(GraphNameRef::DefaultGraph) |
|
|
|
), |
|
|
|
) |
|
|
|
// .collect::<Result<Vec<_>, _>>()?,
|
|
|
|
.collect::<Result<Vec<_>, _>>()?, |
|
|
|
// vec![default_quad.clone()]
|
|
|
|
vec![default_quad.clone()] |
|
|
|
Vec::new() |
|
|
|
); |
|
|
|
); |
|
|
|
assert_eq!( |
|
|
|
assert_eq!( |
|
|
|
store |
|
|
|
store.quads_for_pattern( |
|
|
|
.quads_for_pattern( |
|
|
|
Some(main_s.as_ref()), |
|
|
|
Some(main_s.as_ref()), |
|
|
|
Some(main_p.as_ref()), |
|
|
|
Some(main_p.as_ref()), |
|
|
|
Some(main_o.as_ref()), |
|
|
|
Some(main_o.as_ref()), |
|
|
|
Some(main_g.as_ref()) |
|
|
|
Some(main_g.as_ref()) |
|
|
|
), |
|
|
|
) |
|
|
|
// .collect::<Result<Vec<_>, _>>()?,
|
|
|
|
.collect::<Result<Vec<_>, _>>()?, |
|
|
|
// vec![named_quad.clone()]
|
|
|
|
vec![named_quad.clone()] |
|
|
|
Vec::new() |
|
|
|
); |
|
|
|
); |
|
|
|
assert_eq!( |
|
|
|
assert_eq!( |
|
|
|
store |
|
|
|
store.quads_for_pattern( |
|
|
|
.quads_for_pattern( |
|
|
|
Some(main_s.as_ref()), |
|
|
|
Some(main_s.as_ref()), |
|
|
|
Some(main_p.as_ref()), |
|
|
|
Some(main_p.as_ref()), |
|
|
|
None, |
|
|
|
None, |
|
|
|
Some(GraphNameRef::DefaultGraph) |
|
|
|
Some(GraphNameRef::DefaultGraph) |
|
|
|
), |
|
|
|
) |
|
|
|
// .collect::<Result<Vec<_>, _>>()?,
|
|
|
|
.collect::<Result<Vec<_>, _>>()?, |
|
|
|
// default_quads
|
|
|
|
default_quads |
|
|
|
Vec::new() |
|
|
|
); |
|
|
|
); |
|
|
|
assert_eq!( |
|
|
|
assert_eq!( |
|
|
|
store |
|
|
|
store.quads_for_pattern(Some(main_s.as_ref()), None, Some(main_o.as_ref()), None), |
|
|
|
.quads_for_pattern(Some(main_s.as_ref()), 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 |
|
|
|
store.quads_for_pattern( |
|
|
|
.quads_for_pattern( |
|
|
|
Some(main_s.as_ref()), |
|
|
|
Some(main_s.as_ref()), |
|
|
|
None, |
|
|
|
None, |
|
|
|
Some(main_o.as_ref()), |
|
|
|
Some(main_o.as_ref()), |
|
|
|
Some(GraphNameRef::DefaultGraph) |
|
|
|
Some(GraphNameRef::DefaultGraph) |
|
|
|
), |
|
|
|
) |
|
|
|
// .collect::<Result<Vec<_>, _>>()?,
|
|
|
|
.collect::<Result<Vec<_>, _>>()?, |
|
|
|
// vec![default_quad.clone()]
|
|
|
|
vec![default_quad.clone()] |
|
|
|
Vec::new() |
|
|
|
); |
|
|
|
); |
|
|
|
assert_eq!( |
|
|
|
assert_eq!( |
|
|
|
store |
|
|
|
store.quads_for_pattern( |
|
|
|
.quads_for_pattern( |
|
|
|
Some(main_s.as_ref()), |
|
|
|
Some(main_s.as_ref()), |
|
|
|
None, |
|
|
|
None, |
|
|
|
Some(main_o.as_ref()), |
|
|
|
Some(main_o.as_ref()), |
|
|
|
Some(main_g.as_ref()) |
|
|
|
Some(main_g.as_ref()) |
|
|
|
), |
|
|
|
) |
|
|
|
// .collect::<Result<Vec<_>, _>>()?,
|
|
|
|
.collect::<Result<Vec<_>, _>>()?, |
|
|
|
// vec![named_quad.clone()]
|
|
|
|
vec![named_quad.clone()] |
|
|
|
Vec::new() |
|
|
|
); |
|
|
|
); |
|
|
|
assert_eq!( |
|
|
|
assert_eq!( |
|
|
|
store |
|
|
|
store.quads_for_pattern( |
|
|
|
.quads_for_pattern( |
|
|
|
Some(main_s.as_ref()), |
|
|
|
Some(main_s.as_ref()), |
|
|
|
None, |
|
|
|
None, |
|
|
|
None, |
|
|
|
None, |
|
|
|
Some(GraphNameRef::DefaultGraph) |
|
|
|
Some(GraphNameRef::DefaultGraph) |
|
|
|
), |
|
|
|
) |
|
|
|
// .collect::<Result<Vec<_>, _>>()?,
|
|
|
|
.collect::<Result<Vec<_>, _>>()?, |
|
|
|
// default_quads
|
|
|
|
default_quads |
|
|
|
Vec::new() |
|
|
|
); |
|
|
|
); |
|
|
|
assert_eq!( |
|
|
|
assert_eq!( |
|
|
|
store |
|
|
|
store.quads_for_pattern(None, Some(main_p.as_ref()), None, None), |
|
|
|
.quads_for_pattern(None, Some(main_p.as_ref()), None, None) |
|
|
|
// .collect::<Result<Vec<_>, _>>()?,
|
|
|
|
.collect::<Result<Vec<_>, _>>()?, |
|
|
|
|
|
|
|
all_quads |
|
|
|
all_quads |
|
|
|
); |
|
|
|
); |
|
|
|
assert_eq!( |
|
|
|
assert_eq!( |
|
|
|
store |
|
|
|
store.quads_for_pattern(None, Some(main_p.as_ref()), Some(main_o.as_ref()), None), |
|
|
|
.quads_for_pattern(None, Some(main_p.as_ref()), Some(main_o.as_ref()), None) |
|
|
|
// .collect::<Result<Vec<_>, _>>()?,
|
|
|
|
.collect::<Result<Vec<_>, _>>()?, |
|
|
|
// vec![default_quad.clone(), named_quad.clone()]
|
|
|
|
vec![default_quad.clone(), named_quad.clone()] |
|
|
|
Vec::new() |
|
|
|
); |
|
|
|
); |
|
|
|
assert_eq!( |
|
|
|
assert_eq!( |
|
|
|
store |
|
|
|
store.quads_for_pattern(None, None, Some(main_o.as_ref()), None), |
|
|
|
.quads_for_pattern(None, None, Some(main_o.as_ref()), None) |
|
|
|
// .collect::<Result<Vec<_>, _>>()?,
|
|
|
|
.collect::<Result<Vec<_>, _>>()?, |
|
|
|
// vec![default_quad.clone(), named_quad.clone()]
|
|
|
|
vec![default_quad.clone(), named_quad.clone()] |
|
|
|
Vec::new() |
|
|
|
); |
|
|
|
); |
|
|
|
assert_eq!( |
|
|
|
assert_eq!( |
|
|
|
store |
|
|
|
store.quads_for_pattern(None, None, None, Some(GraphNameRef::DefaultGraph)), |
|
|
|
.quads_for_pattern(None, None, None, Some(GraphNameRef::DefaultGraph)) |
|
|
|
// .collect::<Result<Vec<_>, _>>()?,
|
|
|
|
.collect::<Result<Vec<_>, _>>()?, |
|
|
|
// default_quads
|
|
|
|
default_quads |
|
|
|
Vec::new() |
|
|
|
); |
|
|
|
); |
|
|
|
assert_eq!( |
|
|
|
assert_eq!( |
|
|
|
store |
|
|
|
store.quads_for_pattern( |
|
|
|
.quads_for_pattern( |
|
|
|
None, |
|
|
|
None, |
|
|
|
Some(main_p.as_ref()), |
|
|
|
Some(main_p.as_ref()), |
|
|
|
Some(main_o.as_ref()), |
|
|
|
Some(main_o.as_ref()), |
|
|
|
Some(GraphNameRef::DefaultGraph) |
|
|
|
Some(GraphNameRef::DefaultGraph) |
|
|
|
), |
|
|
|
) |
|
|
|
// .collect::<Result<Vec<_>, _>>()?,
|
|
|
|
.collect::<Result<Vec<_>, _>>()?, |
|
|
|
// vec![default_quad]
|
|
|
|
vec![default_quad] |
|
|
|
Vec::new() |
|
|
|
); |
|
|
|
); |
|
|
|
assert_eq!( |
|
|
|
assert_eq!( |
|
|
|
store |
|
|
|
store.quads_for_pattern( |
|
|
|
.quads_for_pattern( |
|
|
|
None, |
|
|
|
None, |
|
|
|
Some(main_p.as_ref()), |
|
|
|
Some(main_p.as_ref()), |
|
|
|
Some(main_o.as_ref()), |
|
|
|
Some(main_o.as_ref()), |
|
|
|
Some(main_g.as_ref()) |
|
|
|
Some(main_g.as_ref()) |
|
|
|
), |
|
|
|
) |
|
|
|
// .collect::<Result<Vec<_>, _>>()?,
|
|
|
|
.collect::<Result<Vec<_>, _>>()?, |
|
|
|
// vec![named_quad]
|
|
|
|
vec![named_quad] |
|
|
|
Vec::new() |
|
|
|
); |
|
|
|
); |
|
|
|
|
|
|
|
|
|
|
|
Ok(()) |
|
|
|
Ok(()) |
|
|
|
|
Peter Heringer
1 year ago