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

Enables more Clippy lints and enforces them

Browse Source
pull/171/head
Tpt 4 years ago
parent 1abda73dc9
commit f084cfe332
42 changed files with 667 additions and 646 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. 1
      clippy.toml
  2. 4
      lib/Cargo.toml
  3. 6
      lib/src/error.rs
  4. 12
      lib/src/io/format.rs
  5. 20
      lib/src/io/read.rs
  6. 2
      lib/src/io/write.rs
  7. 87
      lib/src/lib.rs
  8. 55
      lib/src/model/dataset.rs
  9. 4
      lib/src/model/graph.rs
  10. 4
      lib/src/model/interning.rs
  11. 56
      lib/src/model/literal.rs
  12. 6
      lib/src/model/parser.rs
  13. 50
      lib/src/model/sophia.rs
  14. 4
      lib/src/model/triple.rs
  15. 2
      lib/src/model/vocab.rs
  16. 44
      lib/src/model/xsd/date_time.rs
  17. 18
      lib/src/model/xsd/decimal.rs
  18. 32
      lib/src/model/xsd/duration.rs
  19. 12
      lib/src/model/xsd/parser.rs
  20. 16
      lib/src/sophia.rs
  21. 16
      lib/src/sparql/algebra.rs
  22. 8
      lib/src/sparql/dataset.rs
  23. 2
      lib/src/sparql/error.rs
  24. 131
      lib/src/sparql/eval.rs
  25. 31
      lib/src/sparql/http/simple.rs
  26. 16
      lib/src/sparql/mod.rs
  27. 16
      lib/src/sparql/model.rs
  28. 234
      lib/src/sparql/plan.rs
  29. 13
      lib/src/sparql/plan_builder.rs
  30. 166
      lib/src/sparql/update.rs
  31. 8
      lib/src/sparql/xml_results.rs
  32. 11
      lib/src/storage/io.rs
  33. 41
      lib/src/storage/mod.rs
  34. 41
      lib/src/storage/numeric_encoder.rs
  35. 6
      lib/src/storage/small_string.rs
  36. 6
      lib/src/store.rs
  37. 2
      server/src/main.rs
  38. 2
      spargebra/Cargo.toml
  39. 106
      spargebra/src/algebra.rs
  40. 8
      spargebra/src/parser.rs
  41. 4
      spargebra/src/term.rs
  42. 8
      wikibase/src/main.rs

1
clippy.toml
Unescape View File

@ -1,3 +1,4 @@
avoid-breaking-exported-api = false
cognitive-complexity-threshold = 50 cognitive-complexity-threshold = 50
too-many-arguments-threshold = 10 too-many-arguments-threshold = 10
type-complexity-threshold = 500 type-complexity-threshold = 500

4
lib/Cargo.toml
Unescape View File

@ -39,7 +39,7 @@ hex = "0.4"
nom = "6" nom = "6"
siphasher = "0.3" siphasher = "0.3"
lasso = "0.5" lasso = "0.5"
sophia_api = { version = "0.6.2", optional = true } sophia_api = { version = "0.7", optional = true }
http = "0.2" http = "0.2"
httparse = { version = "1", optional = true } httparse = { version = "1", optional = true }
native-tls = { version = "0.2", optional = true } native-tls = { version = "0.2", optional = true }
@ -50,7 +50,7 @@ spargebra = { version = "0.1", path="../spargebra", features = ["rdf-star"] }
[dev-dependencies] [dev-dependencies]
rayon = "1" rayon = "1"
criterion = "0.3" criterion = "0.3"
sophia_api = { version = "0.6.2", features = ["test_macro"] } sophia_api = { version = "0.7", features = ["test_macro"] }
[[bench]] [[bench]]
name = "store" name = "store"

6
lib/src/error.rs
Unescape View File

@ -3,7 +3,7 @@ use std::error::Error;
use std::io; use std::io;
/// Traits that allows unwrapping only infallible results /// Traits that allows unwrapping only infallible results
pub(crate) trait UnwrapInfallible { pub trait UnwrapInfallible {
type Value; type Value;
fn unwrap_infallible(self) -> Self::Value; fn unwrap_infallible(self) -> Self::Value;
@ -20,10 +20,10 @@ impl<T> UnwrapInfallible for Result<T, Infallible> {
} }
} }
pub(crate) fn invalid_data_error(error: impl Into<Box<dyn Error + Send + Sync>>) -> io::Error { pub fn invalid_data_error(error: impl Into<Box<dyn Error + Send + Sync>>) -> io::Error {
io::Error::new(io::ErrorKind::InvalidData, error) io::Error::new(io::ErrorKind::InvalidData, error)
} }
pub(crate) fn invalid_input_error(error: impl Into<Box<dyn Error + Send + Sync>>) -> io::Error { pub fn invalid_input_error(error: impl Into<Box<dyn Error + Send + Sync>>) -> io::Error {
io::Error::new(io::ErrorKind::InvalidInput, error) io::Error::new(io::ErrorKind::InvalidInput, error)
} }

12
lib/src/io/format.rs
Unescape View File

@ -74,11 +74,9 @@ impl GraphFormat {
pub fn from_media_type(media_type: &str) -> Option<Self> { pub fn from_media_type(media_type: &str) -> Option<Self> {
if let Some(base_type) = media_type.split(';').next() { if let Some(base_type) = media_type.split(';').next() {
match base_type.trim() { match base_type.trim() {
"application/n-triples" | "text/plain" => Some(GraphFormat::NTriples), "application/n-triples" | "text/plain" => Some(Self::NTriples),
"text/turtle" | "application/turtle" | "application/x-turtle" => { "text/turtle" | "application/turtle" | "application/x-turtle" => Some(Self::Turtle),
Some(GraphFormat::Turtle) "application/rdf+xml" | "application/xml" | "text/xml" => Some(Self::RdfXml),
}
"application/rdf+xml" | "application/xml" | "text/xml" => Some(GraphFormat::RdfXml),
_ => None, _ => None,
} }
} else { } else {
@ -158,9 +156,9 @@ impl DatasetFormat {
if let Some(base_type) = media_type.split(';').next() { if let Some(base_type) = media_type.split(';').next() {
match base_type.trim() { match base_type.trim() {
"application/n-quads" | "text/x-nquads" | "text/nquads" => { "application/n-quads" | "text/x-nquads" | "text/nquads" => {
Some(DatasetFormat::NQuads) Some(Self::NQuads)
} }
"application/trig" | "application/x-trig" => Some(DatasetFormat::TriG), "application/trig" | "application/x-trig" => Some(Self::TriG),
_ => None, _ => None,
} }
} else { } else {

20
lib/src/io/read.rs
Unescape View File

@ -66,6 +66,7 @@ impl GraphParser {
} }
/// Executes the parsing itself on a [`BufRead`](std::io::BufRead) implementation and returns an iterator of triples /// Executes the parsing itself on a [`BufRead`](std::io::BufRead) implementation and returns an iterator of triples
#[allow(clippy::unnecessary_wraps)]
pub fn read_triples<R: BufRead>(&self, reader: R) -> io::Result<TripleReader<R>> { pub fn read_triples<R: BufRead>(&self, reader: R) -> io::Result<TripleReader<R>> {
Ok(TripleReader { Ok(TripleReader {
mapper: RioMapper::default(), mapper: RioMapper::default(),
@ -214,6 +215,7 @@ impl DatasetParser {
} }
/// Executes the parsing itself on a [`BufRead`](std::io::BufRead) implementation and returns an iterator of quads /// Executes the parsing itself on a [`BufRead`](std::io::BufRead) implementation and returns an iterator of quads
#[allow(clippy::unnecessary_wraps)]
pub fn read_quads<R: BufRead>(&self, reader: R) -> io::Result<QuadReader<R>> { pub fn read_quads<R: BufRead>(&self, reader: R) -> io::Result<QuadReader<R>> {
Ok(QuadReader { Ok(QuadReader {
mapper: RioMapper::default(), mapper: RioMapper::default(),
@ -307,7 +309,7 @@ struct RioMapper {
} }
impl<'a> RioMapper { impl<'a> RioMapper {
fn named_node(&self, node: rio::NamedNode<'a>) -> NamedNode { fn named_node(node: rio::NamedNode<'a>) -> NamedNode {
NamedNode::new_unchecked(node.iri) NamedNode::new_unchecked(node.iri)
} }
@ -318,21 +320,21 @@ impl<'a> RioMapper {
.clone() .clone()
} }
fn literal(&self, literal: rio::Literal<'a>) -> Literal { fn literal(literal: rio::Literal<'a>) -> Literal {
match literal { match literal {
rio::Literal::Simple { value } => Literal::new_simple_literal(value), rio::Literal::Simple { value } => Literal::new_simple_literal(value),
rio::Literal::LanguageTaggedString { value, language } => { rio::Literal::LanguageTaggedString { value, language } => {
Literal::new_language_tagged_literal_unchecked(value, language) Literal::new_language_tagged_literal_unchecked(value, language)
} }
rio::Literal::Typed { value, datatype } => { rio::Literal::Typed { value, datatype } => {
Literal::new_typed_literal(value, self.named_node(datatype)) Literal::new_typed_literal(value, Self::named_node(datatype))
} }
} }
} }
fn subject(&mut self, node: rio::Subject<'a>) -> Subject { fn subject(&mut self, node: rio::Subject<'a>) -> Subject {
match node { match node {
rio::Subject::NamedNode(node) => self.named_node(node).into(), rio::Subject::NamedNode(node) => Self::named_node(node).into(),
rio::Subject::BlankNode(node) => self.blank_node(node).into(), rio::Subject::BlankNode(node) => self.blank_node(node).into(),
rio::Subject::Triple(triple) => self.triple(triple).into(), rio::Subject::Triple(triple) => self.triple(triple).into(),
} }
@ -340,9 +342,9 @@ impl<'a> RioMapper {
fn term(&mut self, node: rio::Term<'a>) -> Term { fn term(&mut self, node: rio::Term<'a>) -> Term {
match node { match node {
rio::Term::NamedNode(node) => self.named_node(node).into(), rio::Term::NamedNode(node) => Self::named_node(node).into(),
rio::Term::BlankNode(node) => self.blank_node(node).into(), rio::Term::BlankNode(node) => self.blank_node(node).into(),
rio::Term::Literal(literal) => self.literal(literal).into(), rio::Term::Literal(literal) => Self::literal(literal).into(),
rio::Term::Triple(triple) => self.triple(triple).into(), rio::Term::Triple(triple) => self.triple(triple).into(),
} }
} }
@ -350,14 +352,14 @@ impl<'a> RioMapper {
fn triple(&mut self, triple: &rio::Triple<'a>) -> Triple { fn triple(&mut self, triple: &rio::Triple<'a>) -> Triple {
Triple { Triple {
subject: self.subject(triple.subject), subject: self.subject(triple.subject),
predicate: self.named_node(triple.predicate), predicate: Self::named_node(triple.predicate),
object: self.term(triple.object), object: self.term(triple.object),
} }
} }
fn graph_name(&mut self, graph_name: Option<rio::GraphName<'a>>) -> GraphName { fn graph_name(&mut self, graph_name: Option<rio::GraphName<'a>>) -> GraphName {
match graph_name { match graph_name {
Some(rio::GraphName::NamedNode(node)) => self.named_node(node).into(), Some(rio::GraphName::NamedNode(node)) => Self::named_node(node).into(),
Some(rio::GraphName::BlankNode(node)) => self.blank_node(node).into(), Some(rio::GraphName::BlankNode(node)) => self.blank_node(node).into(),
None => GraphName::DefaultGraph, None => GraphName::DefaultGraph,
} }
@ -366,7 +368,7 @@ impl<'a> RioMapper {
fn quad(&mut self, quad: &rio::Quad<'a>) -> Quad { fn quad(&mut self, quad: &rio::Quad<'a>) -> Quad {
Quad { Quad {
subject: self.subject(quad.subject), subject: self.subject(quad.subject),
predicate: self.named_node(quad.predicate), predicate: Self::named_node(quad.predicate),
object: self.term(quad.object), object: self.term(quad.object),
graph_name: self.graph_name(quad.graph_name), graph_name: self.graph_name(quad.graph_name),
} }

2
lib/src/io/write.rs
Unescape View File

@ -183,6 +183,7 @@ impl DatasetSerializer {
} }
/// Returns a `QuadWriter` allowing writing triples into the given [`Write`](std::io::Write) implementation /// Returns a `QuadWriter` allowing writing triples into the given [`Write`](std::io::Write) implementation
#[allow(clippy::unnecessary_wraps)]
pub fn quad_writer<W: Write>(&self, writer: W) -> io::Result<QuadWriter<W>> { pub fn quad_writer<W: Write>(&self, writer: W) -> io::Result<QuadWriter<W>> {
Ok(QuadWriter { Ok(QuadWriter {
formatter: match self.format { formatter: match self.format {
@ -250,6 +251,7 @@ impl<W: Write> QuadWriter<W> {
} }
/// Writes the last bytes of the file /// Writes the last bytes of the file
#[allow(clippy::unused_self, clippy::unnecessary_wraps)]
pub fn finish(self) -> io::Result<()> { pub fn finish(self) -> io::Result<()> {
Ok(()) Ok(())
} }

87
lib/src/lib.rs
Unescape View File

@ -46,10 +46,6 @@
)] )]
#![doc(html_favicon_url = "https://raw.githubusercontent.com/oxigraph/oxigraph/master/logo.svg")] #![doc(html_favicon_url = "https://raw.githubusercontent.com/oxigraph/oxigraph/master/logo.svg")]
#![doc(html_logo_url = "https://raw.githubusercontent.com/oxigraph/oxigraph/master/logo.svg")] #![doc(html_logo_url = "https://raw.githubusercontent.com/oxigraph/oxigraph/master/logo.svg")]
#![allow(
clippy::multiple_crate_versions, //TODO
clippy::rc_buffer //TODO: enforce
)]
#![warn( #![warn(
clippy::cast_lossless, clippy::cast_lossless,
clippy::cast_possible_truncation, clippy::cast_possible_truncation,
@ -57,56 +53,119 @@
clippy::cast_precision_loss, clippy::cast_precision_loss,
clippy::cast_sign_loss, clippy::cast_sign_loss,
clippy::checked_conversions, clippy::checked_conversions,
clippy::cloned_instead_of_copied,
clippy::copy_iterator,
clippy::dbg_macro,
clippy::debug_assert_with_mut_call,
clippy::decimal_literal_representation, clippy::decimal_literal_representation,
//TODO clippy::doc_markdown, //TODO clippy::doc_markdown,
//clippy::else_if_without_else, // clippy::else_if_without_else,
clippy::empty_line_after_outer_attr,
clippy::empty_enum, clippy::empty_enum,
clippy::enum_glob_use,
clippy::expect_used, clippy::expect_used,
clippy::expl_impl_clone_on_copy, clippy::expl_impl_clone_on_copy,
clippy::explicit_deref_methods,
clippy::explicit_into_iter_loop, clippy::explicit_into_iter_loop,
clippy::explicit_iter_loop, clippy::explicit_iter_loop,
clippy::expl_impl_clone_on_copy,
clippy::fallible_impl_from, clippy::fallible_impl_from,
clippy::manual_filter_map,
clippy::filter_map_next, clippy::filter_map_next,
clippy::manual_find_map, clippy::flat_map_option,
clippy::from_iter_instead_of_collect,
clippy::get_unwrap, clippy::get_unwrap,
clippy::if_not_else, clippy::if_not_else,
// clippy::if_then_some_else_none,
clippy::implicit_clone,
clippy::implicit_saturating_sub,
clippy::imprecise_flops,
clippy::inconsistent_struct_constructor,
// clippy::indexing_slicing,
clippy::inefficient_to_string,
clippy::inline_always, clippy::inline_always,
clippy::invalid_upcast_comparisons, clippy::invalid_upcast_comparisons,
clippy::items_after_statements, clippy::items_after_statements,
clippy::map_entry, clippy::large_digit_groups,
clippy::large_stack_arrays,
clippy::large_types_passed_by_value,
clippy::let_underscore_drop,
clippy::let_underscore_must_use,
clippy::let_unit_value,
clippy::linkedlist,
clippy::macro_use_imports,
clippy::manual_ok_or,
//TODO clippy::map_err_ignore,
clippy::map_flatten, clippy::map_flatten,
clippy::map_unwrap_or, clippy::map_unwrap_or,
//TODO clippy::match_same_arms, clippy::match_bool,
// clippy::match_on_vec_items,
clippy::match_same_arms,
clippy::match_wildcard_for_single_variants,
clippy::maybe_infinite_iter, clippy::maybe_infinite_iter,
clippy::mem_forget, clippy::mem_forget,
//TODO clippy::must_use_candidate,
//TODO clippy::missing_const_for_fn, //TODO clippy::missing_const_for_fn,
//TODO clippy::module_name_repetitions,
clippy::multiple_crate_versions, clippy::multiple_crate_versions,
clippy::multiple_inherent_impl, clippy::multiple_inherent_impl,
//TODO clippy::must_use_candidate,
clippy::mut_mut, clippy::mut_mut,
clippy::needless_borrow, clippy::mutex_integer,
clippy::naive_bytecount,
clippy::needless_bitwise_bool,
clippy::needless_continue, clippy::needless_continue,
clippy::needless_pass_by_value, clippy::needless_pass_by_value,
clippy::non_ascii_literal, clippy::non_ascii_literal,
// clippy::panic, does not work well with tests //TODO clippy::nonstandard_macro_braces,
//TODO clippy::option_if_let_else,
// clippy::panic, clippy::panic_in_result_fn, does not work well with tests
clippy::path_buf_push_overwrite, clippy::path_buf_push_overwrite,
clippy::print_stderr,
clippy::print_stdout, clippy::print_stdout,
clippy::range_minus_one,
clippy::range_plus_one,
//TODO clippy::rc_mutex,
//TODO clippy::redundant_closure_for_method_calls, //TODO clippy::redundant_closure_for_method_calls,
clippy::redundant_else,
clippy::redundant_pub_crate,
clippy::ref_binding_to_reference,
clippy::ref_option_ref,
clippy::rest_pat_in_fully_bound_structs,
clippy::same_functions_in_if_condition,
// clippy::shadow_reuse, // clippy::shadow_reuse,
// clippy::shadow_same, // clippy::shadow_same,
// clippy::shadow_unrelated, // clippy::shadow_unrelated,
// clippy::single_match_else, // clippy::single_match_else,
clippy::str_to_string,
clippy::string_add, clippy::string_add,
clippy::string_add_assign, clippy::string_add_assign,
clippy::string_lit_as_bytes,
clippy::string_to_string,
clippy::suboptimal_flops,
clippy::suspicious_operation_groupings,
clippy::todo, clippy::todo,
clippy::trait_duplication_in_bounds,
clippy::transmute_ptr_to_ptr,
clippy::trivial_regex,
clippy::trivially_copy_pass_by_ref,
clippy::type_repetition_in_bounds, clippy::type_repetition_in_bounds,
clippy::unicode_not_nfc, clippy::unicode_not_nfc,
clippy::unimplemented, clippy::unimplemented,
clippy::unnecessary_self_imports,
clippy::unnecessary_wraps,
clippy::unneeded_field_pattern,
clippy::unnested_or_patterns,
clippy::unreadable_literal,
clippy::unseparated_literal_suffix, clippy::unseparated_literal_suffix,
clippy::unused_async,
clippy::unused_self,
clippy::use_debug,
clippy::use_self,
clippy::used_underscore_binding, clippy::used_underscore_binding,
clippy::wildcard_dependencies clippy::useless_let_if_seq,
clippy::useless_transmute,
clippy::verbose_bit_mask,
clippy::verbose_file_reads,
clippy::wildcard_dependencies,
clippy::zero_sized_map_values
)] )]
#![doc(test(attr(deny(warnings))))] #![doc(test(attr(deny(warnings))))]

55
lib/src/model/dataset.rs
Unescape View File

@ -222,13 +222,13 @@ impl Dataset {
let predicate = self let predicate = self
.encoded_named_node(predicate) .encoded_named_node(predicate)
.unwrap_or_else(InternedNamedNode::impossible); .unwrap_or_else(InternedNamedNode::impossible);
self.interned_quads_for_predicate(&predicate) self.interned_quads_for_predicate(predicate)
.map(move |q| self.decode_spog(q)) .map(move |q| self.decode_spog(q))
} }
fn interned_quads_for_predicate( fn interned_quads_for_predicate(
&self, &self,
predicate: &InternedNamedNode, predicate: InternedNamedNode,
) -> impl Iterator< ) -> impl Iterator<
Item = ( Item = (
&InternedSubject, &InternedSubject,
@ -240,7 +240,7 @@ impl Dataset {
self.posg self.posg
.range( .range(
&( &(
*predicate, predicate,
InternedTerm::first(), InternedTerm::first(),
InternedSubject::first(), InternedSubject::first(),
InternedGraphName::first(), InternedGraphName::first(),
@ -653,7 +653,7 @@ impl Dataset {
self.interned_quads_for_subject(&InternedSubject::BlankNode(*bnode)) self.interned_quads_for_subject(&InternedSubject::BlankNode(*bnode))
{ {
to_hash.push(( to_hash.push((
self.hash_named_node(p), self.hash_named_node(*p),
self.hash_term(o, &hashes), self.hash_term(o, &hashes),
self.hash_graph_name(g, &hashes), self.hash_graph_name(g, &hashes),
0, 0,
@ -663,7 +663,7 @@ impl Dataset {
{ {
to_hash.push(( to_hash.push((
self.hash_subject(s, &hashes), self.hash_subject(s, &hashes),
self.hash_named_node(p), self.hash_named_node(*p),
self.hash_graph_name(g, &hashes), self.hash_graph_name(g, &hashes),
1, 1,
)); ));
@ -673,13 +673,13 @@ impl Dataset {
{ {
to_hash.push(( to_hash.push((
self.hash_subject(s, &hashes), self.hash_subject(s, &hashes),
self.hash_named_node(p), self.hash_named_node(*p),
self.hash_term(o, &hashes), self.hash_term(o, &hashes),
2, 2,
)); ));
} }
to_hash.sort_unstable(); to_hash.sort_unstable();
let hash = self.hash_tuple((old_hash, &to_hash)); let hash = Self::hash_tuple((old_hash, &to_hash));
to_hash.clear(); to_hash.clear();
new_hashes.insert(*bnode, hash); new_hashes.insert(*bnode, hash);
partition.entry(hash).or_default().push(*bnode); partition.entry(hash).or_default().push(*bnode);
@ -695,8 +695,8 @@ impl Dataset {
} }
} }
fn hash_named_node(&self, node: &InternedNamedNode) -> u64 { fn hash_named_node(&self, node: InternedNamedNode) -> u64 {
self.hash_tuple(node.decode_from(&self.interner)) Self::hash_tuple(node.decode_from(&self.interner))
} }
fn hash_subject( fn hash_subject(
@ -709,7 +709,7 @@ impl Dataset {
} else if let InternedSubject::Triple(triple) = node { } else if let InternedSubject::Triple(triple) = node {
self.hash_triple(triple, bnodes_hash) self.hash_triple(triple, bnodes_hash)
} else { } else {
self.hash_tuple(node.decode_from(&self.interner)) Self::hash_tuple(node.decode_from(&self.interner))
} }
} }
@ -719,7 +719,7 @@ impl Dataset {
} else if let InternedTerm::Triple(triple) = term { } else if let InternedTerm::Triple(triple) = term {
self.hash_triple(triple, bnodes_hash) self.hash_triple(triple, bnodes_hash)
} else { } else {
self.hash_tuple(term.decode_from(&self.interner)) Self::hash_tuple(term.decode_from(&self.interner))
} }
} }
@ -731,7 +731,7 @@ impl Dataset {
if let InternedGraphName::BlankNode(bnode) = graph_name { if let InternedGraphName::BlankNode(bnode) = graph_name {
bnodes_hash[bnode] bnodes_hash[bnode]
} else { } else {
self.hash_tuple(graph_name.decode_from(&self.interner)) Self::hash_tuple(graph_name.decode_from(&self.interner))
} }
} }
@ -740,14 +740,14 @@ impl Dataset {
triple: &InternedTriple, triple: &InternedTriple,
bnodes_hash: &HashMap<InternedBlankNode, u64>, bnodes_hash: &HashMap<InternedBlankNode, u64>,
) -> u64 { ) -> u64 {
self.hash_tuple(( Self::hash_tuple((
self.hash_subject(&triple.subject, bnodes_hash), self.hash_subject(&triple.subject, bnodes_hash),
self.hash_named_node(&triple.predicate), self.hash_named_node(triple.predicate),
self.hash_term(&triple.object, bnodes_hash), self.hash_term(&triple.object, bnodes_hash),
)) ))
} }
fn hash_tuple(&self, v: impl Hash) -> u64 { fn hash_tuple(v: impl Hash) -> u64 {
let mut hasher = DefaultHasher::new(); let mut hasher = DefaultHasher::new();
v.hash(&mut hasher); v.hash(&mut hasher);
hasher.finish() hasher.finish()
@ -771,7 +771,7 @@ impl Dataset {
.iter() .iter()
.map(|b| { .map(|b| {
let mut hash_prime = hash.clone(); let mut hash_prime = hash.clone();
hash_prime.insert(*b, self.hash_tuple((hash_prime[b], 22))); hash_prime.insert(*b, Self::hash_tuple((hash_prime[b], 22)));
let (hash_prime_prime, partition_prime) = self.hash_bnodes(hash_prime); let (hash_prime_prime, partition_prime) = self.hash_bnodes(hash_prime);
self.distinguish(&hash_prime_prime, &partition_prime) self.distinguish(&hash_prime_prime, &partition_prime)
}) })
@ -808,7 +808,7 @@ impl Dataset {
.map(|(s, p, o, g)| { .map(|(s, p, o, g)| {
( (
if let InternedSubject::BlankNode(bnode) = s { if let InternedSubject::BlankNode(bnode) = s {
InternedSubject::BlankNode(self.map_bnode(&bnode, hashes)) InternedSubject::BlankNode(self.map_bnode(bnode, hashes))
} else if let InternedSubject::Triple(triple) = s { } else if let InternedSubject::Triple(triple) = s {
InternedSubject::Triple(Box::new(InternedTriple::encoded_into( InternedSubject::Triple(Box::new(InternedTriple::encoded_into(
self.label_triple(&triple, hashes).as_ref(), self.label_triple(&triple, hashes).as_ref(),
@ -819,7 +819,7 @@ impl Dataset {
}, },
p, p,
if let InternedTerm::BlankNode(bnode) = o { if let InternedTerm::BlankNode(bnode) = o {
InternedTerm::BlankNode(self.map_bnode(&bnode, hashes)) InternedTerm::BlankNode(self.map_bnode(bnode, hashes))
} else if let InternedTerm::Triple(triple) = o { } else if let InternedTerm::Triple(triple) = o {
InternedTerm::Triple(Box::new(InternedTriple::encoded_into( InternedTerm::Triple(Box::new(InternedTriple::encoded_into(
self.label_triple(&triple, hashes).as_ref(), self.label_triple(&triple, hashes).as_ref(),
@ -829,7 +829,7 @@ impl Dataset {
o o
}, },
if let InternedGraphName::BlankNode(bnode) = g { if let InternedGraphName::BlankNode(bnode) = g {
InternedGraphName::BlankNode(self.map_bnode(&bnode, hashes)) InternedGraphName::BlankNode(self.map_bnode(bnode, hashes))
} else { } else {
g g
}, },
@ -847,7 +847,7 @@ impl Dataset {
) -> Triple { ) -> Triple {
Triple { Triple {
subject: if let InternedSubject::BlankNode(bnode) = &triple.subject { subject: if let InternedSubject::BlankNode(bnode) = &triple.subject {
self.gen_bnode(bnode, hashes).into() Self::gen_bnode(*bnode, hashes).into()
} else if let InternedSubject::Triple(t) = &triple.subject { } else if let InternedSubject::Triple(t) = &triple.subject {
self.label_triple(t, hashes).into() self.label_triple(t, hashes).into()
} else { } else {
@ -855,7 +855,7 @@ impl Dataset {
}, },
predicate: triple.predicate.decode_from(&self.interner).into_owned(), predicate: triple.predicate.decode_from(&self.interner).into_owned(),
object: if let InternedTerm::BlankNode(bnode) = &triple.object { object: if let InternedTerm::BlankNode(bnode) = &triple.object {
self.gen_bnode(bnode, hashes).into() Self::gen_bnode(*bnode, hashes).into()
} else if let InternedTerm::Triple(t) = &triple.object { } else if let InternedTerm::Triple(t) = &triple.object {
self.label_triple(t, hashes).into() self.label_triple(t, hashes).into()
} else { } else {
@ -866,21 +866,20 @@ impl Dataset {
fn map_bnode( fn map_bnode(
&mut self, &mut self,
old_bnode: &InternedBlankNode, old_bnode: InternedBlankNode,
hashes: &HashMap<InternedBlankNode, u64>, hashes: &HashMap<InternedBlankNode, u64>,
) -> InternedBlankNode { ) -> InternedBlankNode {
InternedBlankNode::encoded_into( InternedBlankNode::encoded_into(
self.gen_bnode(old_bnode, hashes).as_ref(), Self::gen_bnode(old_bnode, hashes).as_ref(),
&mut self.interner, &mut self.interner,
) )
} }
fn gen_bnode( fn gen_bnode(
&self, old_bnode: InternedBlankNode,
old_bnode: &InternedBlankNode,
hashes: &HashMap<InternedBlankNode, u64>, hashes: &HashMap<InternedBlankNode, u64>,
) -> BlankNode { ) -> BlankNode {
BlankNode::new_from_unique_id(hashes[old_bnode]) BlankNode::new_from_unique_id(hashes[&old_bnode])
} }
} }
@ -911,7 +910,7 @@ impl<'a> IntoIterator for &'a Dataset {
impl FromIterator<Quad> for Dataset { impl FromIterator<Quad> for Dataset {
fn from_iter<I: IntoIterator<Item = Quad>>(iter: I) -> Self { fn from_iter<I: IntoIterator<Item = Quad>>(iter: I) -> Self {
let mut g = Dataset::new(); let mut g = Self::new();
g.extend(iter); g.extend(iter);
g g
} }
@ -919,7 +918,7 @@ impl FromIterator<Quad> for Dataset {
impl<'a, T: Into<QuadRef<'a>>> FromIterator<T> for Dataset { impl<'a, T: Into<QuadRef<'a>>> FromIterator<T> for Dataset {
fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self { fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
let mut g = Dataset::new(); let mut g = Self::new();
g.extend(iter); g.extend(iter);
g g
} }

4
lib/src/model/graph.rs
Unescape View File

@ -285,7 +285,7 @@ impl<'a> IntoIterator for &'a Graph {
impl FromIterator<Triple> for Graph { impl FromIterator<Triple> for Graph {
fn from_iter<I: IntoIterator<Item = Triple>>(iter: I) -> Self { fn from_iter<I: IntoIterator<Item = Triple>>(iter: I) -> Self {
let mut g = Graph::new(); let mut g = Self::new();
g.extend(iter); g.extend(iter);
g g
} }
@ -293,7 +293,7 @@ impl FromIterator<Triple> for Graph {
impl<'a, T: Into<TripleRef<'a>>> FromIterator<T> for Graph { impl<'a, T: Into<TripleRef<'a>>> FromIterator<T> for Graph {
fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self { fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
let mut g = Graph::new(); let mut g = Self::new();
g.extend(iter); g.extend(iter);
g g
} }

4
lib/src/model/interning.rs
Unescape View File

@ -37,7 +37,7 @@ impl InternedNamedNode {
Self { id: fist_spur() } Self { id: fist_spur() }
} }
pub fn next(&self) -> Self { pub fn next(self) -> Self {
Self { Self {
id: next_spur(self.id), id: next_spur(self.id),
} }
@ -72,7 +72,7 @@ impl InternedBlankNode {
BlankNodeRef::new_unchecked(interner.strings.resolve(&self.id)) BlankNodeRef::new_unchecked(interner.strings.resolve(&self.id))
} }
pub fn next(&self) -> Self { pub fn next(self) -> Self {
Self { Self {
id: next_spur(self.id), id: next_spur(self.id),
} }

56
lib/src/model/literal.rs
Unescape View File

@ -47,7 +47,7 @@ impl Literal {
/// Builds an RDF [simple literal](https://www.w3.org/TR/rdf11-concepts/#dfn-simple-literal) /// Builds an RDF [simple literal](https://www.w3.org/TR/rdf11-concepts/#dfn-simple-literal)
#[inline] #[inline]
pub fn new_simple_literal(value: impl Into<String>) -> Self { pub fn new_simple_literal(value: impl Into<String>) -> Self {
Literal(LiteralContent::String(value.into())) Self(LiteralContent::String(value.into()))
} }
/// Builds an RDF [literal](https://www.w3.org/TR/rdf11-concepts/#dfn-literal) with a [datatype](https://www.w3.org/TR/rdf11-concepts/#dfn-datatype-iri) /// Builds an RDF [literal](https://www.w3.org/TR/rdf11-concepts/#dfn-literal) with a [datatype](https://www.w3.org/TR/rdf11-concepts/#dfn-datatype-iri)
@ -55,7 +55,7 @@ impl Literal {
pub fn new_typed_literal(value: impl Into<String>, datatype: impl Into<NamedNode>) -> Self { pub fn new_typed_literal(value: impl Into<String>, datatype: impl Into<NamedNode>) -> Self {
let value = value.into(); let value = value.into();
let datatype = datatype.into(); let datatype = datatype.into();
Literal(if datatype == xsd::STRING { Self(if datatype == xsd::STRING {
LiteralContent::String(value) LiteralContent::String(value)
} else { } else {
LiteralContent::TypedLiteral { value, datatype } LiteralContent::TypedLiteral { value, datatype }
@ -88,7 +88,7 @@ impl Literal {
value: impl Into<String>, value: impl Into<String>,
language: impl Into<String>, language: impl Into<String>,
) -> Self { ) -> Self {
Literal(LiteralContent::LanguageTaggedString { Self(LiteralContent::LanguageTaggedString {
value: value.into(), value: value.into(),
language: language.into(), language: language.into(),
}) })
@ -164,28 +164,28 @@ impl fmt::Display for Literal {
impl<'a> From<&'a str> for Literal { impl<'a> From<&'a str> for Literal {
#[inline] #[inline]
fn from(value: &'a str) -> Self { fn from(value: &'a str) -> Self {
Literal(LiteralContent::String(value.into())) Self(LiteralContent::String(value.into()))
} }
} }
impl From<String> for Literal { impl From<String> for Literal {
#[inline] #[inline]
fn from(value: String) -> Self { fn from(value: String) -> Self {
Literal(LiteralContent::String(value)) Self(LiteralContent::String(value))
} }
} }
impl<'a> From<Cow<'a, str>> for Literal { impl<'a> From<Cow<'a, str>> for Literal {
#[inline] #[inline]
fn from(value: Cow<'a, str>) -> Self { fn from(value: Cow<'a, str>) -> Self {
Literal(LiteralContent::String(value.into())) Self(LiteralContent::String(value.into()))
} }
} }
impl From<bool> for Literal { impl From<bool> for Literal {
#[inline] #[inline]
fn from(value: bool) -> Self { fn from(value: bool) -> Self {
Literal(LiteralContent::TypedLiteral { Self(LiteralContent::TypedLiteral {
value: value.to_string(), value: value.to_string(),
datatype: xsd::BOOLEAN.into(), datatype: xsd::BOOLEAN.into(),
}) })
@ -195,7 +195,7 @@ impl From<bool> for Literal {
impl From<i128> for Literal { impl From<i128> for Literal {
#[inline] #[inline]
fn from(value: i128) -> Self { fn from(value: i128) -> Self {
Literal(LiteralContent::TypedLiteral { Self(LiteralContent::TypedLiteral {
value: value.to_string(), value: value.to_string(),
datatype: xsd::INTEGER.into(), datatype: xsd::INTEGER.into(),
}) })
@ -205,7 +205,7 @@ impl From<i128> for Literal {
impl From<i64> for Literal { impl From<i64> for Literal {
#[inline] #[inline]
fn from(value: i64) -> Self { fn from(value: i64) -> Self {
Literal(LiteralContent::TypedLiteral { Self(LiteralContent::TypedLiteral {
value: value.to_string(), value: value.to_string(),
datatype: xsd::INTEGER.into(), datatype: xsd::INTEGER.into(),
}) })
@ -215,7 +215,7 @@ impl From<i64> for Literal {
impl From<i32> for Literal { impl From<i32> for Literal {
#[inline] #[inline]
fn from(value: i32) -> Self { fn from(value: i32) -> Self {
Literal(LiteralContent::TypedLiteral { Self(LiteralContent::TypedLiteral {
value: value.to_string(), value: value.to_string(),
datatype: xsd::INTEGER.into(), datatype: xsd::INTEGER.into(),
}) })
@ -225,7 +225,7 @@ impl From<i32> for Literal {
impl From<i16> for Literal { impl From<i16> for Literal {
#[inline] #[inline]
fn from(value: i16) -> Self { fn from(value: i16) -> Self {
Literal(LiteralContent::TypedLiteral { Self(LiteralContent::TypedLiteral {
value: value.to_string(), value: value.to_string(),
datatype: xsd::INTEGER.into(), datatype: xsd::INTEGER.into(),
}) })
@ -235,7 +235,7 @@ impl From<i16> for Literal {
impl From<u64> for Literal { impl From<u64> for Literal {
#[inline] #[inline]
fn from(value: u64) -> Self { fn from(value: u64) -> Self {
Literal(LiteralContent::TypedLiteral { Self(LiteralContent::TypedLiteral {
value: value.to_string(), value: value.to_string(),
datatype: xsd::INTEGER.into(), datatype: xsd::INTEGER.into(),
}) })
@ -245,7 +245,7 @@ impl From<u64> for Literal {
impl From<u32> for Literal { impl From<u32> for Literal {
#[inline] #[inline]
fn from(value: u32) -> Self { fn from(value: u32) -> Self {
Literal(LiteralContent::TypedLiteral { Self(LiteralContent::TypedLiteral {
value: value.to_string(), value: value.to_string(),
datatype: xsd::INTEGER.into(), datatype: xsd::INTEGER.into(),
}) })
@ -255,7 +255,7 @@ impl From<u32> for Literal {
impl From<u16> for Literal { impl From<u16> for Literal {
#[inline] #[inline]
fn from(value: u16) -> Self { fn from(value: u16) -> Self {
Literal(LiteralContent::TypedLiteral { Self(LiteralContent::TypedLiteral {
value: value.to_string(), value: value.to_string(),
datatype: xsd::INTEGER.into(), datatype: xsd::INTEGER.into(),
}) })
@ -265,7 +265,7 @@ impl From<u16> for Literal {
impl From<f32> for Literal { impl From<f32> for Literal {
#[inline] #[inline]
fn from(value: f32) -> Self { fn from(value: f32) -> Self {
Literal(LiteralContent::TypedLiteral { Self(LiteralContent::TypedLiteral {
value: value.to_string(), value: value.to_string(),
datatype: xsd::FLOAT.into(), datatype: xsd::FLOAT.into(),
}) })
@ -275,7 +275,7 @@ impl From<f32> for Literal {
impl From<f64> for Literal { impl From<f64> for Literal {
#[inline] #[inline]
fn from(value: f64) -> Self { fn from(value: f64) -> Self {
Literal(LiteralContent::TypedLiteral { Self(LiteralContent::TypedLiteral {
value: value.to_string(), value: value.to_string(),
datatype: xsd::DOUBLE.into(), datatype: xsd::DOUBLE.into(),
}) })
@ -285,7 +285,7 @@ impl From<f64> for Literal {
impl From<Decimal> for Literal { impl From<Decimal> for Literal {
#[inline] #[inline]
fn from(value: Decimal) -> Self { fn from(value: Decimal) -> Self {
Literal(LiteralContent::TypedLiteral { Self(LiteralContent::TypedLiteral {
value: value.to_string(), value: value.to_string(),
datatype: xsd::DECIMAL.into(), datatype: xsd::DECIMAL.into(),
}) })
@ -295,7 +295,7 @@ impl From<Decimal> for Literal {
impl From<DateTime> for Literal { impl From<DateTime> for Literal {
#[inline] #[inline]
fn from(value: DateTime) -> Self { fn from(value: DateTime) -> Self {
Literal(LiteralContent::TypedLiteral { Self(LiteralContent::TypedLiteral {
value: value.to_string(), value: value.to_string(),
datatype: xsd::DATE_TIME.into(), datatype: xsd::DATE_TIME.into(),
}) })
@ -305,7 +305,7 @@ impl From<DateTime> for Literal {
impl From<Time> for Literal { impl From<Time> for Literal {
#[inline] #[inline]
fn from(value: Time) -> Self { fn from(value: Time) -> Self {
Literal(LiteralContent::TypedLiteral { Self(LiteralContent::TypedLiteral {
value: value.to_string(), value: value.to_string(),
datatype: xsd::TIME.into(), datatype: xsd::TIME.into(),
}) })
@ -315,7 +315,7 @@ impl From<Time> for Literal {
impl From<Date> for Literal { impl From<Date> for Literal {
#[inline] #[inline]
fn from(value: Date) -> Self { fn from(value: Date) -> Self {
Literal(LiteralContent::TypedLiteral { Self(LiteralContent::TypedLiteral {
value: value.to_string(), value: value.to_string(),
datatype: xsd::DATE.into(), datatype: xsd::DATE.into(),
}) })
@ -325,7 +325,7 @@ impl From<Date> for Literal {
impl From<GYearMonth> for Literal { impl From<GYearMonth> for Literal {
#[inline] #[inline]
fn from(value: GYearMonth) -> Self { fn from(value: GYearMonth) -> Self {
Literal(LiteralContent::TypedLiteral { Self(LiteralContent::TypedLiteral {
value: value.to_string(), value: value.to_string(),
datatype: xsd::G_YEAR_MONTH.into(), datatype: xsd::G_YEAR_MONTH.into(),
}) })
@ -335,7 +335,7 @@ impl From<GYearMonth> for Literal {
impl From<GYear> for Literal { impl From<GYear> for Literal {
#[inline] #[inline]
fn from(value: GYear) -> Self { fn from(value: GYear) -> Self {
Literal(LiteralContent::TypedLiteral { Self(LiteralContent::TypedLiteral {
value: value.to_string(), value: value.to_string(),
datatype: xsd::G_YEAR.into(), datatype: xsd::G_YEAR.into(),
}) })
@ -345,7 +345,7 @@ impl From<GYear> for Literal {
impl From<GMonthDay> for Literal { impl From<GMonthDay> for Literal {
#[inline] #[inline]
fn from(value: GMonthDay) -> Self { fn from(value: GMonthDay) -> Self {
Literal(LiteralContent::TypedLiteral { Self(LiteralContent::TypedLiteral {
value: value.to_string(), value: value.to_string(),
datatype: xsd::G_MONTH_DAY.into(), datatype: xsd::G_MONTH_DAY.into(),
}) })
@ -355,7 +355,7 @@ impl From<GMonthDay> for Literal {
impl From<GMonth> for Literal { impl From<GMonth> for Literal {
#[inline] #[inline]
fn from(value: GMonth) -> Self { fn from(value: GMonth) -> Self {
Literal(LiteralContent::TypedLiteral { Self(LiteralContent::TypedLiteral {
value: value.to_string(), value: value.to_string(),
datatype: xsd::G_MONTH.into(), datatype: xsd::G_MONTH.into(),
}) })
@ -365,7 +365,7 @@ impl From<GMonth> for Literal {
impl From<GDay> for Literal { impl From<GDay> for Literal {
#[inline] #[inline]
fn from(value: GDay) -> Self { fn from(value: GDay) -> Self {
Literal(LiteralContent::TypedLiteral { Self(LiteralContent::TypedLiteral {
value: value.to_string(), value: value.to_string(),
datatype: xsd::G_DAY.into(), datatype: xsd::G_DAY.into(),
}) })
@ -375,7 +375,7 @@ impl From<GDay> for Literal {
impl From<Duration> for Literal { impl From<Duration> for Literal {
#[inline] #[inline]
fn from(value: Duration) -> Self { fn from(value: Duration) -> Self {
Literal(LiteralContent::TypedLiteral { Self(LiteralContent::TypedLiteral {
value: value.to_string(), value: value.to_string(),
datatype: xsd::DURATION.into(), datatype: xsd::DURATION.into(),
}) })
@ -385,7 +385,7 @@ impl From<Duration> for Literal {
impl From<YearMonthDuration> for Literal { impl From<YearMonthDuration> for Literal {
#[inline] #[inline]
fn from(value: YearMonthDuration) -> Self { fn from(value: YearMonthDuration) -> Self {
Literal(LiteralContent::TypedLiteral { Self(LiteralContent::TypedLiteral {
value: value.to_string(), value: value.to_string(),
datatype: xsd::YEAR_MONTH_DURATION.into(), datatype: xsd::YEAR_MONTH_DURATION.into(),
}) })
@ -395,7 +395,7 @@ impl From<YearMonthDuration> for Literal {
impl From<DayTimeDuration> for Literal { impl From<DayTimeDuration> for Literal {
#[inline] #[inline]
fn from(value: DayTimeDuration) -> Self { fn from(value: DayTimeDuration) -> Self {
Literal(LiteralContent::TypedLiteral { Self(LiteralContent::TypedLiteral {
value: value.to_string(), value: value.to_string(),
datatype: xsd::DAY_TIME_DURATION.into(), datatype: xsd::DAY_TIME_DURATION.into(),
}) })

6
lib/src/model/parser.rs
Unescape View File

@ -120,7 +120,7 @@ impl FromStr for Variable {
"Variable serialization should start with ? or $", "Variable serialization should start with ? or $",
)); ));
} }
Variable::new(&s[1..]).map_err(|error| TermParseError { Self::new(&s[1..]).map_err(|error| TermParseError {
kind: TermParseErrorKind::Variable { kind: TermParseErrorKind::Variable {
value: s.to_owned(), value: s.to_owned(),
error, error,
@ -238,7 +238,7 @@ fn read_literal(s: &str) -> Result<(Literal, &str), TermParseError> {
} }
let mut cursor = match input.get(0) { let mut cursor = match input.get(0) {
Some(b'+') | Some(b'-') => 1, Some(b'+' | b'-') => 1,
_ => 0, _ => 0,
}; };
let mut with_dot = false; let mut with_dot = false;
@ -262,7 +262,7 @@ fn read_literal(s: &str) -> Result<(Literal, &str), TermParseError> {
if cursor < input.len() && (input[cursor] == b'e' || input[cursor] == b'E') { if cursor < input.len() && (input[cursor] == b'e' || input[cursor] == b'E') {
cursor += 1; cursor += 1;
cursor += match input.get(cursor) { cursor += match input.get(cursor) {
Some(b'+') | Some(b'-') => 1, Some(b'+' | b'-') => 1,
_ => 0, _ => 0,
}; };
let mut count_exponent = 0; let mut count_exponent = 0;

50
lib/src/model/sophia.rs
Unescape View File

@ -26,7 +26,7 @@ impl TryCopyTerm for BlankNode {
T: TTerm + ?Sized, T: TTerm + ?Sized,
{ {
match other.kind() { match other.kind() {
TermKind::BlankNode => Ok(BlankNode::new_unchecked(other.value_raw().0)), TermKind::BlankNode => Ok(Self::new_unchecked(other.value_raw().0)),
_ => Err(SophiaToOxigraphConversionError), _ => Err(SophiaToOxigraphConversionError),
} }
} }
@ -52,18 +52,18 @@ impl TTerm for Literal {
} }
fn value_raw(&self) -> RawValue<'_> { fn value_raw(&self) -> RawValue<'_> {
Literal::value(self).into() Self::value(self).into()
} }
fn datatype(&self) -> Option<SimpleIri<'_>> { fn datatype(&self) -> Option<SimpleIri<'_>> {
Some(SimpleIri::new_unchecked( Some(SimpleIri::new_unchecked(
Literal::datatype(self).as_str(), Self::datatype(self).as_str(),
None, None,
)) ))
} }
fn language(&self) -> Option<&str> { fn language(&self) -> Option<&str> {
Literal::language(self) Self::language(self)
} }
fn as_dyn(&self) -> &dyn TTerm { fn as_dyn(&self) -> &dyn TTerm {
@ -80,11 +80,11 @@ impl TryCopyTerm for Literal {
{ {
match other.kind() { match other.kind() {
TermKind::Literal => match other.language() { TermKind::Literal => match other.language() {
Some(tag) => Ok(Literal::new_language_tagged_literal_unchecked( Some(tag) => Ok(Self::new_language_tagged_literal_unchecked(
other.value_raw().0, other.value_raw().0,
tag, tag,
)), )),
None => Ok(Literal::new_typed_literal( None => Ok(Self::new_typed_literal(
other.value_raw().0, other.value_raw().0,
other.datatype().unwrap(), other.datatype().unwrap(),
)), )),
@ -141,7 +141,7 @@ impl TryCopyTerm for NamedNode {
T: TTerm + ?Sized, T: TTerm + ?Sized,
{ {
match other.kind() { match other.kind() {
TermKind::Iri => Ok(NamedNode::new_unchecked(other.value())), TermKind::Iri => Ok(Self::new_unchecked(other.value())),
_ => Err(SophiaToOxigraphConversionError), _ => Err(SophiaToOxigraphConversionError),
} }
} }
@ -149,7 +149,7 @@ impl TryCopyTerm for NamedNode {
impl<'a> From<SimpleIri<'a>> for NamedNode { impl<'a> From<SimpleIri<'a>> for NamedNode {
fn from(other: SimpleIri<'a>) -> Self { fn from(other: SimpleIri<'a>) -> Self {
NamedNode::new_unchecked(other.value()) Self::new_unchecked(other.value())
} }
} }
@ -169,22 +169,20 @@ impl<'a> TTerm for NamedNodeRef<'a> {
impl From<GraphName> for Option<Term> { impl From<GraphName> for Option<Term> {
fn from(other: GraphName) -> Self { fn from(other: GraphName) -> Self {
use GraphName::*;
match other { match other {
NamedNode(n) => Some(n.into()), GraphName::NamedNode(n) => Some(n.into()),
BlankNode(n) => Some(n.into()), GraphName::BlankNode(n) => Some(n.into()),
DefaultGraph => None, GraphName::DefaultGraph => None,
} }
} }
} }
impl<'a> From<GraphNameRef<'a>> for Option<TermRef<'a>> { impl<'a> From<GraphNameRef<'a>> for Option<TermRef<'a>> {
fn from(other: GraphNameRef<'a>) -> Self { fn from(other: GraphNameRef<'a>) -> Self {
use GraphNameRef::*;
match other { match other {
NamedNode(n) => Some(n.into()), GraphNameRef::NamedNode(n) => Some(n.into()),
BlankNode(n) => Some(n.into()), GraphNameRef::BlankNode(n) => Some(n.into()),
DefaultGraph => None, GraphNameRef::DefaultGraph => None,
} }
} }
} }
@ -312,7 +310,7 @@ impl TryCopyTerm for Term {
TermKind::Iri => Ok(NamedNode::try_copy(other).unwrap().into()), TermKind::Iri => Ok(NamedNode::try_copy(other).unwrap().into()),
TermKind::BlankNode => Ok(BlankNode::try_copy(other).unwrap().into()), TermKind::BlankNode => Ok(BlankNode::try_copy(other).unwrap().into()),
TermKind::Literal => Ok(Literal::try_copy(other).unwrap().into()), TermKind::Literal => Ok(Literal::try_copy(other).unwrap().into()),
_ => Err(SophiaToOxigraphConversionError), TermKind::Variable => Err(SophiaToOxigraphConversionError),
} }
} }
} }
@ -327,15 +325,6 @@ impl<'a> TTerm for TermRef<'a> {
} }
} }
fn value_raw(&self) -> RawValue<'_> {
match self {
Self::NamedNode(n) => n.value_raw(),
Self::BlankNode(n) => n.value_raw(),
Self::Literal(l) => l.value_raw(),
Self::Triple(_) => panic!("RDF-star is not supported yet by Sophia"),
}
}
fn datatype(&self) -> Option<SimpleIri<'_>> { fn datatype(&self) -> Option<SimpleIri<'_>> {
if let Self::Literal(l) = self { if let Self::Literal(l) = self {
TTerm::datatype(l) TTerm::datatype(l)
@ -352,6 +341,15 @@ impl<'a> TTerm for TermRef<'a> {
} }
} }
fn value_raw(&self) -> RawValue<'_> {
match self {
Self::NamedNode(n) => n.value_raw(),
Self::BlankNode(n) => n.value_raw(),
Self::Literal(l) => l.value_raw(),
Self::Triple(_) => panic!("RDF-star is not supported yet by Sophia"),
}
}
fn as_dyn(&self) -> &dyn TTerm { fn as_dyn(&self) -> &dyn TTerm {
match self { match self {
Self::NamedNode(n) => n.as_dyn(), Self::NamedNode(n) => n.as_dyn(),

4
lib/src/model/triple.rs
Unescape View File

@ -856,7 +856,7 @@ impl fmt::Display for GraphName {
impl From<NamedNode> for GraphName { impl From<NamedNode> for GraphName {
#[inline] #[inline]
fn from(node: NamedNode) -> Self { fn from(node: NamedNode) -> Self {
GraphName::NamedNode(node) Self::NamedNode(node)
} }
} }
@ -870,7 +870,7 @@ impl From<NamedNodeRef<'_>> for GraphName {
impl From<BlankNode> for GraphName { impl From<BlankNode> for GraphName {
#[inline] #[inline]
fn from(node: BlankNode) -> Self { fn from(node: BlankNode) -> Self {
GraphName::BlankNode(node) Self::BlankNode(node)
} }
} }

2
lib/src/model/vocab.rs
Unescape View File

@ -69,7 +69,7 @@ pub mod rdfs {
/// The class of RDF containers. /// The class of RDF containers.
pub const CONTAINER: NamedNodeRef<'_> = pub const CONTAINER: NamedNodeRef<'_> =
NamedNodeRef::new_unchecked("http://www.w3.org/2000/01/rdf-schema#Container"); NamedNodeRef::new_unchecked("http://www.w3.org/2000/01/rdf-schema#Container");
/// The class of container membership properties, rdf:_1, rdf:_2, ..., all of which are sub-properties of 'member'. /// The class of container membership properties, `rdf:_1`, `rdf:_2`, ..., all of which are sub-properties of `member`.
pub const CONTAINER_MEMBERSHIP_PROPERTY: NamedNodeRef<'_> = NamedNodeRef::new_unchecked( pub const CONTAINER_MEMBERSHIP_PROPERTY: NamedNodeRef<'_> = NamedNodeRef::new_unchecked(
"http://www.w3.org/2000/01/rdf-schema#ContainerMembershipProperty", "http://www.w3.org/2000/01/rdf-schema#ContainerMembershipProperty",
); );

44
lib/src/model/xsd/date_time.rs
Unescape View File

@ -182,7 +182,7 @@ impl TryFrom<Date> for DateTime {
type Error = DateTimeError; type Error = DateTimeError;
fn try_from(date: Date) -> Result<Self, DateTimeError> { fn try_from(date: Date) -> Result<Self, DateTimeError> {
DateTime::new( Self::new(
date.year(), date.year(),
date.month(), date.month(),
date.day(), date.day(),
@ -347,7 +347,7 @@ impl TryFrom<DateTime> for Time {
type Error = DateTimeError; type Error = DateTimeError;
fn try_from(date_time: DateTime) -> Result<Self, DateTimeError> { fn try_from(date_time: DateTime) -> Result<Self, DateTimeError> {
Time::new( Self::new(
date_time.hour(), date_time.hour(),
date_time.minute(), date_time.minute(),
date_time.second(), date_time.second(),
@ -499,7 +499,7 @@ impl TryFrom<DateTime> for Date {
type Error = DateTimeError; type Error = DateTimeError;
fn try_from(date_time: DateTime) -> Result<Self, DateTimeError> { fn try_from(date_time: DateTime) -> Result<Self, DateTimeError> {
Date::new( Self::new(
date_time.year(), date_time.year(),
date_time.month(), date_time.month(),
date_time.day(), date_time.day(),
@ -591,7 +591,7 @@ impl TryFrom<DateTime> for GYearMonth {
type Error = DateTimeError; type Error = DateTimeError;
fn try_from(date_time: DateTime) -> Result<Self, DateTimeError> { fn try_from(date_time: DateTime) -> Result<Self, DateTimeError> {
GYearMonth::new( Self::new(
date_time.year(), date_time.year(),
date_time.month(), date_time.month(),
date_time.timezone_offset(), date_time.timezone_offset(),
@ -604,7 +604,7 @@ impl TryFrom<Date> for GYearMonth {
type Error = DateTimeError; type Error = DateTimeError;
fn try_from(date: Date) -> Result<Self, DateTimeError> { fn try_from(date: Date) -> Result<Self, DateTimeError> {
GYearMonth::new(date.year(), date.month(), date.timezone_offset()) Self::new(date.year(), date.month(), date.timezone_offset())
} }
} }
@ -686,7 +686,7 @@ impl TryFrom<DateTime> for GYear {
type Error = DateTimeError; type Error = DateTimeError;
fn try_from(date_time: DateTime) -> Result<Self, DateTimeError> { fn try_from(date_time: DateTime) -> Result<Self, DateTimeError> {
GYear::new(date_time.year(), date_time.timezone_offset()) Self::new(date_time.year(), date_time.timezone_offset())
} }
} }
@ -695,7 +695,7 @@ impl TryFrom<Date> for GYear {
type Error = DateTimeError; type Error = DateTimeError;
fn try_from(date: Date) -> Result<Self, DateTimeError> { fn try_from(date: Date) -> Result<Self, DateTimeError> {
GYear::new(date.year(), date.timezone_offset()) Self::new(date.year(), date.timezone_offset())
} }
} }
@ -703,7 +703,7 @@ impl TryFrom<GYearMonth> for GYear {
type Error = DateTimeError; type Error = DateTimeError;
fn try_from(year_month: GYearMonth) -> Result<Self, DateTimeError> { fn try_from(year_month: GYearMonth) -> Result<Self, DateTimeError> {
GYear::new(year_month.year(), year_month.timezone_offset()) Self::new(year_month.year(), year_month.timezone_offset())
} }
} }
@ -790,7 +790,7 @@ impl TryFrom<DateTime> for GMonthDay {
type Error = DateTimeError; type Error = DateTimeError;
fn try_from(date_time: DateTime) -> Result<Self, DateTimeError> { fn try_from(date_time: DateTime) -> Result<Self, DateTimeError> {
GMonthDay::new( Self::new(
date_time.month(), date_time.month(),
date_time.day(), date_time.day(),
date_time.timezone_offset(), date_time.timezone_offset(),
@ -803,7 +803,7 @@ impl TryFrom<Date> for GMonthDay {
type Error = DateTimeError; type Error = DateTimeError;
fn try_from(date: Date) -> Result<Self, DateTimeError> { fn try_from(date: Date) -> Result<Self, DateTimeError> {
GMonthDay::new(date.month(), date.day(), date.timezone_offset()) Self::new(date.month(), date.day(), date.timezone_offset())
} }
} }
@ -881,7 +881,7 @@ impl TryFrom<DateTime> for GMonth {
type Error = DateTimeError; type Error = DateTimeError;
fn try_from(date_time: DateTime) -> Result<Self, DateTimeError> { fn try_from(date_time: DateTime) -> Result<Self, DateTimeError> {
GMonth::new(date_time.month(), date_time.timezone_offset()) Self::new(date_time.month(), date_time.timezone_offset())
} }
} }
@ -890,7 +890,7 @@ impl TryFrom<Date> for GMonth {
type Error = DateTimeError; type Error = DateTimeError;
fn try_from(date: Date) -> Result<Self, DateTimeError> { fn try_from(date: Date) -> Result<Self, DateTimeError> {
GMonth::new(date.month(), date.timezone_offset()) Self::new(date.month(), date.timezone_offset())
} }
} }
@ -898,7 +898,7 @@ impl TryFrom<GYearMonth> for GMonth {
type Error = DateTimeError; type Error = DateTimeError;
fn try_from(year_month: GYearMonth) -> Result<Self, DateTimeError> { fn try_from(year_month: GYearMonth) -> Result<Self, DateTimeError> {
GMonth::new(year_month.month(), year_month.timezone_offset()) Self::new(year_month.month(), year_month.timezone_offset())
} }
} }
@ -906,7 +906,7 @@ impl TryFrom<GMonthDay> for GMonth {
type Error = DateTimeError; type Error = DateTimeError;
fn try_from(month_day: GMonthDay) -> Result<Self, DateTimeError> { fn try_from(month_day: GMonthDay) -> Result<Self, DateTimeError> {
GMonth::new(month_day.month(), month_day.timezone_offset()) Self::new(month_day.month(), month_day.timezone_offset())
} }
} }
@ -984,7 +984,7 @@ impl TryFrom<DateTime> for GDay {
type Error = DateTimeError; type Error = DateTimeError;
fn try_from(date_time: DateTime) -> Result<Self, DateTimeError> { fn try_from(date_time: DateTime) -> Result<Self, DateTimeError> {
GDay::new(date_time.day(), date_time.timezone_offset()) Self::new(date_time.day(), date_time.timezone_offset())
} }
} }
@ -993,7 +993,7 @@ impl TryFrom<Date> for GDay {
type Error = DateTimeError; type Error = DateTimeError;
fn try_from(date: Date) -> Result<Self, DateTimeError> { fn try_from(date: Date) -> Result<Self, DateTimeError> {
GDay::new(date.day(), date.timezone_offset()) Self::new(date.day(), date.timezone_offset())
} }
} }
@ -1001,7 +1001,7 @@ impl TryFrom<GMonthDay> for GDay {
type Error = DateTimeError; type Error = DateTimeError;
fn try_from(month_day: GMonthDay) -> Result<Self, DateTimeError> { fn try_from(month_day: GMonthDay) -> Result<Self, DateTimeError> {
GDay::new(month_day.day(), month_day.timezone_offset()) Self::new(month_day.day(), month_day.timezone_offset())
} }
} }
@ -1039,7 +1039,7 @@ impl TimezoneOffset {
} }
pub fn from_be_bytes(bytes: [u8; 2]) -> Self { pub fn from_be_bytes(bytes: [u8; 2]) -> Self {
TimezoneOffset { Self {
offset: i16::from_be_bytes(bytes), offset: i16::from_be_bytes(bytes),
} }
} }
@ -1051,13 +1051,13 @@ impl TimezoneOffset {
impl From<i16> for TimezoneOffset { impl From<i16> for TimezoneOffset {
fn from(offset: i16) -> Self { fn from(offset: i16) -> Self {
TimezoneOffset { offset } Self { offset }
} }
} }
impl From<TimezoneOffset> for DayTimeDuration { impl From<TimezoneOffset> for DayTimeDuration {
fn from(value: TimezoneOffset) -> Self { fn from(value: TimezoneOffset) -> Self {
DayTimeDuration::new(i32::from(value.offset) * 60) Self::new(i32::from(value.offset) * 60)
} }
} }
@ -1163,7 +1163,7 @@ impl Timestamp {
} }
fn now() -> Result<Self, DateTimeError> { fn now() -> Result<Self, DateTimeError> {
Timestamp::new( Self::new(
&date_time_plus_duration( &date_time_plus_duration(
since_unix_epoch()?, since_unix_epoch()?,
&DateTimeSevenPropertyModel { &DateTimeSevenPropertyModel {
@ -1311,7 +1311,7 @@ impl Timestamp {
}) })
} }
fn checked_sub(&self, rhs: Timestamp) -> Option<Duration> { fn checked_sub(&self, rhs: Self) -> Option<Duration> {
match (self.timezone_offset, rhs.timezone_offset) { match (self.timezone_offset, rhs.timezone_offset) {
(Some(_), Some(_)) | (None, None) => { (Some(_), Some(_)) | (None, None) => {
Some(Duration::new(0, self.value.checked_sub(rhs.value)?)) Some(Duration::new(0, self.value.checked_sub(rhs.value)?))

18
lib/src/model/xsd/decimal.rs
Unescape View File

@ -99,7 +99,7 @@ impl Decimal {
/// [fn:abs](https://www.w3.org/TR/xpath-functions/#func-abs) /// [fn:abs](https://www.w3.org/TR/xpath-functions/#func-abs)
#[inline] #[inline]
pub const fn abs(&self) -> Decimal { pub const fn abs(&self) -> Self {
Self { Self {
value: self.value.abs(), value: self.value.abs(),
} }
@ -107,7 +107,7 @@ impl Decimal {
/// [fn:round](https://www.w3.org/TR/xpath-functions/#func-round) /// [fn:round](https://www.w3.org/TR/xpath-functions/#func-round)
#[inline] #[inline]
pub fn round(&self) -> Decimal { pub fn round(&self) -> Self {
let value = self.value / DECIMAL_PART_POW_MINUS_ONE; let value = self.value / DECIMAL_PART_POW_MINUS_ONE;
Self { Self {
value: if value >= 0 { value: if value >= 0 {
@ -120,7 +120,7 @@ impl Decimal {
/// [fn:ceiling](https://www.w3.org/TR/xpath-functions/#func-ceiling) /// [fn:ceiling](https://www.w3.org/TR/xpath-functions/#func-ceiling)
#[inline] #[inline]
pub fn ceil(&self) -> Decimal { pub fn ceil(&self) -> Self {
Self { Self {
value: if self.value >= 0 && self.value % DECIMAL_PART_POW != 0 { value: if self.value >= 0 && self.value % DECIMAL_PART_POW != 0 {
(self.value / DECIMAL_PART_POW + 1) * DECIMAL_PART_POW (self.value / DECIMAL_PART_POW + 1) * DECIMAL_PART_POW
@ -132,7 +132,7 @@ impl Decimal {
/// [fn:floor](https://www.w3.org/TR/xpath-functions/#func-floor) /// [fn:floor](https://www.w3.org/TR/xpath-functions/#func-floor)
#[inline] #[inline]
pub fn floor(&self) -> Decimal { pub fn floor(&self) -> Self {
Self { Self {
value: if self.value >= 0 || self.value % DECIMAL_PART_POW == 0 { value: if self.value >= 0 || self.value % DECIMAL_PART_POW == 0 {
(self.value / DECIMAL_PART_POW) * DECIMAL_PART_POW (self.value / DECIMAL_PART_POW) * DECIMAL_PART_POW
@ -184,21 +184,21 @@ impl Decimal {
} }
#[cfg(test)] #[cfg(test)]
pub(super) const fn min_value() -> Decimal { pub(super) const fn min_value() -> Self {
Self { Self {
value: i128::min_value(), value: i128::min_value(),
} }
} }
#[cfg(test)] #[cfg(test)]
pub(super) const fn max_value() -> Decimal { pub(super) const fn max_value() -> Self {
Self { Self {
value: i128::max_value(), value: i128::max_value(),
} }
} }
#[cfg(test)] #[cfg(test)]
pub(super) const fn step() -> Decimal { pub(super) const fn step() -> Self {
Self { value: 1 } Self { value: 1 }
} }
} }
@ -445,7 +445,7 @@ impl fmt::Display for Decimal {
let last_non_zero = i - 1; let last_non_zero = i - 1;
let first_non_zero = digits let first_non_zero = digits
.iter() .iter()
.cloned() .copied()
.enumerate() .enumerate()
.find_map(|(i, v)| if v == b'0' { None } else { Some(i) }) .find_map(|(i, v)| if v == b'0' { None } else { Some(i) })
.unwrap_or(40); .unwrap_or(40);
@ -503,7 +503,7 @@ impl Neg for Decimal {
impl TryFrom<Decimal> for i64 { impl TryFrom<Decimal> for i64 {
type Error = DecimalOverflowError; type Error = DecimalOverflowError;
fn try_from(value: Decimal) -> Result<i64, DecimalOverflowError> { fn try_from(value: Decimal) -> Result<Self, DecimalOverflowError> {
value value
.value .value
.checked_div(DECIMAL_PART_POW) .checked_div(DECIMAL_PART_POW)

32
lib/src/model/xsd/duration.rs
Unescape View File

@ -240,36 +240,40 @@ impl YearMonthDuration {
} }
/// [fn:years-from-duration](https://www.w3.org/TR/xpath-functions/#func-years-from-duration) /// [fn:years-from-duration](https://www.w3.org/TR/xpath-functions/#func-years-from-duration)
pub fn years(&self) -> i64 { pub fn years(self) -> i64 {
self.months / 12 self.months / 12
} }
/// [fn:months-from-duration](https://www.w3.org/TR/xpath-functions/#func-months-from-duration) /// [fn:months-from-duration](https://www.w3.org/TR/xpath-functions/#func-months-from-duration)
pub fn months(&self) -> i64 { pub fn months(self) -> i64 {
self.months % 12 self.months % 12
} }
/// [fn:days-from-duration](https://www.w3.org/TR/xpath-functions/#func-days-from-duration) /// [fn:days-from-duration](https://www.w3.org/TR/xpath-functions/#func-days-from-duration)
pub fn days(&self) -> i64 { #[allow(clippy::unused_self)]
pub fn days(self) -> i64 {
0 0
} }
/// [fn:hours-from-duration](https://www.w3.org/TR/xpath-functions/#func-hours-from-duration) /// [fn:hours-from-duration](https://www.w3.org/TR/xpath-functions/#func-hours-from-duration)
pub fn hours(&self) -> i64 { #[allow(clippy::unused_self)]
pub fn hours(self) -> i64 {
0 0
} }
/// [fn:minutes-from-duration](https://www.w3.org/TR/xpath-functions/#func-minutes-from-duration) /// [fn:minutes-from-duration](https://www.w3.org/TR/xpath-functions/#func-minutes-from-duration)
pub fn minutes(&self) -> i64 { #[allow(clippy::unused_self)]
pub fn minutes(self) -> i64 {
0 0
} }
/// [fn:seconds-from-duration](https://www.w3.org/TR/xpath-functions/#func-seconds-from-duration) /// [fn:seconds-from-duration](https://www.w3.org/TR/xpath-functions/#func-seconds-from-duration)
pub fn seconds(&self) -> Decimal { #[allow(clippy::unused_self)]
pub fn seconds(self) -> Decimal {
Decimal::default() Decimal::default()
} }
pub(super) const fn all_months(&self) -> i64 { pub(super) const fn all_months(self) -> i64 {
self.months self.months
} }
@ -278,7 +282,7 @@ impl YearMonthDuration {
} }
/// [op:add-yearMonthDurations](https://www.w3.org/TR/xpath-functions/#func-add-yearMonthDurations) /// [op:add-yearMonthDurations](https://www.w3.org/TR/xpath-functions/#func-add-yearMonthDurations)
pub fn checked_add(&self, rhs: impl Into<Self>) -> Option<Self> { pub fn checked_add(self, rhs: impl Into<Self>) -> Option<Self> {
let rhs = rhs.into(); let rhs = rhs.into();
Some(Self { Some(Self {
months: self.months.checked_add(rhs.months)?, months: self.months.checked_add(rhs.months)?,
@ -286,7 +290,7 @@ impl YearMonthDuration {
} }
/// [op:subtract-yearMonthDurations](https://www.w3.org/TR/xpath-functions/#func-subtract-yearMonthDurations) /// [op:subtract-yearMonthDurations](https://www.w3.org/TR/xpath-functions/#func-subtract-yearMonthDurations)
pub fn checked_sub(&self, rhs: impl Into<Self>) -> Option<Self> { pub fn checked_sub(self, rhs: impl Into<Self>) -> Option<Self> {
let rhs = rhs.into(); let rhs = rhs.into();
Some(Self { Some(Self {
months: self.months.checked_sub(rhs.months)?, months: self.months.checked_sub(rhs.months)?,
@ -341,7 +345,7 @@ impl PartialEq<Duration> for YearMonthDuration {
impl PartialEq<YearMonthDuration> for Duration { impl PartialEq<YearMonthDuration> for Duration {
fn eq(&self, other: &YearMonthDuration) -> bool { fn eq(&self, other: &YearMonthDuration) -> bool {
self.eq(&Duration::from(*other)) self.eq(&Self::from(*other))
} }
} }
@ -353,7 +357,7 @@ impl PartialOrd<Duration> for YearMonthDuration {
impl PartialOrd<YearMonthDuration> for Duration { impl PartialOrd<YearMonthDuration> for Duration {
fn partial_cmp(&self, other: &YearMonthDuration) -> Option<Ordering> { fn partial_cmp(&self, other: &YearMonthDuration) -> Option<Ordering> {
self.partial_cmp(&Duration::from(*other)) self.partial_cmp(&Self::from(*other))
} }
} }
@ -389,11 +393,13 @@ impl DayTimeDuration {
} }
/// [fn:years-from-duration](https://www.w3.org/TR/xpath-functions/#func-years-from-duration) /// [fn:years-from-duration](https://www.w3.org/TR/xpath-functions/#func-years-from-duration)
#[allow(clippy::unused_self)]
pub fn years(&self) -> i64 { pub fn years(&self) -> i64 {
0 0
} }
/// [fn:months-from-duration](https://www.w3.org/TR/xpath-functions/#func-months-from-duration) /// [fn:months-from-duration](https://www.w3.org/TR/xpath-functions/#func-months-from-duration)
#[allow(clippy::unused_self)]
pub fn months(&self) -> i64 { pub fn months(&self) -> i64 {
0 0
} }
@ -502,7 +508,7 @@ impl PartialEq<Duration> for DayTimeDuration {
impl PartialEq<DayTimeDuration> for Duration { impl PartialEq<DayTimeDuration> for Duration {
fn eq(&self, other: &DayTimeDuration) -> bool { fn eq(&self, other: &DayTimeDuration) -> bool {
self.eq(&Duration::from(*other)) self.eq(&Self::from(*other))
} }
} }
@ -526,7 +532,7 @@ impl PartialOrd<Duration> for DayTimeDuration {
impl PartialOrd<DayTimeDuration> for Duration { impl PartialOrd<DayTimeDuration> for Duration {
fn partial_cmp(&self, other: &DayTimeDuration) -> Option<Ordering> { fn partial_cmp(&self, other: &DayTimeDuration) -> Option<Ordering> {
self.partial_cmp(&Duration::from(*other)) self.partial_cmp(&Self::from(*other))
} }
} }

12
lib/src/model/xsd/parser.rs
Unescape View File

@ -106,7 +106,7 @@ impl ParseError<&str> for XsdParseError {
impl From<ParseIntError> for XsdParseError { impl From<ParseIntError> for XsdParseError {
fn from(error: ParseIntError) -> Self { fn from(error: ParseIntError) -> Self {
XsdParseError { Self {
kind: XsdParseErrorKind::ParseInt(error), kind: XsdParseErrorKind::ParseInt(error),
} }
} }
@ -114,7 +114,7 @@ impl From<ParseIntError> for XsdParseError {
impl From<ParseDecimalError> for XsdParseError { impl From<ParseDecimalError> for XsdParseError {
fn from(error: ParseDecimalError) -> Self { fn from(error: ParseDecimalError) -> Self {
XsdParseError { Self {
kind: XsdParseErrorKind::ParseDecimal(error), kind: XsdParseErrorKind::ParseDecimal(error),
} }
} }
@ -122,16 +122,16 @@ impl From<ParseDecimalError> for XsdParseError {
impl From<DateTimeError> for XsdParseError { impl From<DateTimeError> for XsdParseError {
fn from(error: DateTimeError) -> Self { fn from(error: DateTimeError) -> Self {
XsdParseError { Self {
kind: XsdParseErrorKind::DateTime(error), kind: XsdParseErrorKind::DateTime(error),
} }
} }
} }
impl From<Err<XsdParseError>> for XsdParseError { impl From<Err<Self>> for XsdParseError {
fn from(err: Err<XsdParseError>) -> Self { fn from(err: Err<Self>) -> Self {
match err { match err {
Err::Incomplete(needed) => XsdParseError { Err::Incomplete(needed) => Self {
kind: XsdParseErrorKind::MissingData(needed), kind: XsdParseErrorKind::MissingData(needed),
}, },
Err::Error(e) | Err::Failure(e) => e, Err::Error(e) | Err::Failure(e) => e,

16
lib/src/sophia.rs
Unescape View File

@ -6,7 +6,7 @@ use crate::model::{
use crate::sparql::{EvaluationError, QueryResults}; use crate::sparql::{EvaluationError, QueryResults};
use crate::store::Store; use crate::store::Store;
use sophia_api::dataset::{ use sophia_api::dataset::{
CollectibleDataset, DQuadSource, DResultTermSet, DTerm, Dataset, MDResult, MutableDataset, CollectibleDataset, DQuadSource, DResultTermSet, DTerm, Dataset, MdResult, MutableDataset,
}; };
use sophia_api::quad::stream::{QuadSource, StreamResult}; use sophia_api::quad::stream::{QuadSource, StreamResult};
use sophia_api::quad::streaming_mode::{ByValue, StreamedQuad}; use sophia_api::quad::streaming_mode::{ByValue, StreamedQuad};
@ -380,7 +380,7 @@ impl MutableDataset for Store {
p: &TP, p: &TP,
o: &TO, o: &TO,
g: Option<&TG>, g: Option<&TG>,
) -> MDResult<Self, bool> ) -> MdResult<Self, bool>
where where
TS: TTerm + ?Sized, TS: TTerm + ?Sized,
TP: TTerm + ?Sized, TP: TTerm + ?Sized,
@ -396,7 +396,7 @@ impl MutableDataset for Store {
Some(quad) => quad, Some(quad) => quad,
None => return Ok(false), None => return Ok(false),
}; };
Store::insert(self, quadref).map(|_| true) Self::insert(self, quadref).map(|_| true)
} }
fn remove<TS, TP, TO, TG>( fn remove<TS, TP, TO, TG>(
@ -405,7 +405,7 @@ impl MutableDataset for Store {
p: &TP, p: &TP,
o: &TO, o: &TO,
g: Option<&TG>, g: Option<&TG>,
) -> MDResult<Self, bool> ) -> MdResult<Self, bool>
where where
TS: TTerm + ?Sized, TS: TTerm + ?Sized,
TP: TTerm + ?Sized, TP: TTerm + ?Sized,
@ -421,13 +421,13 @@ impl MutableDataset for Store {
Some(quad) => quad, Some(quad) => quad,
None => return Ok(false), None => return Ok(false),
}; };
Store::remove(self, quadref).map(|_| true) Self::remove(self, quadref).map(|_| true)
} }
} }
impl CollectibleDataset for Store { impl CollectibleDataset for Store {
fn from_quad_source<QS: QuadSource>(quads: QS) -> StreamResult<Self, QS::Error, Self::Error> { fn from_quad_source<QS: QuadSource>(quads: QS) -> StreamResult<Self, QS::Error, Self::Error> {
let mut d = Store::new().map_err(sophia_api::quad::stream::StreamError::SinkError)?; let mut d = Self::new().map_err(sophia_api::quad::stream::StreamError::SinkError)?;
d.insert_all(quads)?; d.insert_all(quads)?;
Ok(d) Ok(d)
} }
@ -488,7 +488,7 @@ where
}; };
Some(lit.into()) Some(lit.into())
} }
_ => None, TermKind::Variable => None,
} }
} }
@ -569,7 +569,7 @@ where
Some(QuadRef::new(s, p, o, g)) Some(QuadRef::new(s, p, o, g))
} }
/// Execute a SPARQL query in a store, and return the result as a HashSet, /// Execute a SPARQL query in a store, and return the result as a `HashSet`,
/// mapping the error (if any) through the given function. /// mapping the error (if any) through the given function.
/// ///
/// # Precondition /// # Precondition

16
lib/src/sparql/algebra.rs
Unescape View File

@ -39,10 +39,10 @@ impl Query {
let query = spargebra::Query::parse(query, base_iri)?; let query = spargebra::Query::parse(query, base_iri)?;
Ok(Self { Ok(Self {
dataset: QueryDataset::from_algebra(match &query { dataset: QueryDataset::from_algebra(match &query {
spargebra::Query::Select { dataset, .. } => dataset, spargebra::Query::Select { dataset, .. }
spargebra::Query::Construct { dataset, .. } => dataset, | spargebra::Query::Construct { dataset, .. }
spargebra::Query::Describe { dataset, .. } => dataset, | spargebra::Query::Describe { dataset, .. }
spargebra::Query::Ask { dataset, .. } => dataset, | spargebra::Query::Ask { dataset, .. } => dataset,
}), }),
inner: query, inner: query,
}) })
@ -128,12 +128,16 @@ impl Update {
/// Returns [the query dataset specification](https://www.w3.org/TR/sparql11-query/#specifyingDataset) in [DELETE/INSERT operations](https://www.w3.org/TR/sparql11-update/#deleteInsert). /// Returns [the query dataset specification](https://www.w3.org/TR/sparql11-query/#specifyingDataset) in [DELETE/INSERT operations](https://www.w3.org/TR/sparql11-update/#deleteInsert).
pub fn using_datasets(&self) -> impl Iterator<Item = &QueryDataset> { pub fn using_datasets(&self) -> impl Iterator<Item = &QueryDataset> {
self.using_datasets.iter().filter_map(|q| q.as_ref()) self.using_datasets
.iter()
.filter_map(std::option::Option::as_ref)
} }
/// Returns [the query dataset specification](https://www.w3.org/TR/sparql11-query/#specifyingDataset) in [DELETE/INSERT operations](https://www.w3.org/TR/sparql11-update/#deleteInsert). /// Returns [the query dataset specification](https://www.w3.org/TR/sparql11-query/#specifyingDataset) in [DELETE/INSERT operations](https://www.w3.org/TR/sparql11-update/#deleteInsert).
pub fn using_datasets_mut(&mut self) -> impl Iterator<Item = &mut QueryDataset> { pub fn using_datasets_mut(&mut self) -> impl Iterator<Item = &mut QueryDataset> {
self.using_datasets.iter_mut().filter_map(|q| q.as_mut()) self.using_datasets
.iter_mut()
.filter_map(std::option::Option::as_mut)
} }
} }

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

@ -10,14 +10,14 @@ use std::collections::HashMap;
use std::convert::Infallible; use std::convert::Infallible;
use std::iter::empty; use std::iter::empty;
pub(crate) struct DatasetView { pub struct DatasetView {
storage: Storage, storage: Storage,
extra: RefCell<HashMap<StrHash, String>>, extra: RefCell<HashMap<StrHash, String>>,
dataset: EncodedDatasetSpec, dataset: EncodedDatasetSpec,
} }
impl DatasetView { impl DatasetView {
pub fn new(storage: Storage, dataset: &QueryDataset) -> Result<Self, EvaluationError> { pub fn new(storage: Storage, dataset: &QueryDataset) -> Self {
let dataset = EncodedDatasetSpec { let dataset = EncodedDatasetSpec {
default: dataset default: dataset
.default_graph_graphs() .default_graph_graphs()
@ -26,11 +26,11 @@ impl DatasetView {
.available_named_graphs() .available_named_graphs()
.map(|graphs| graphs.iter().map(|g| g.as_ref().into()).collect::<Vec<_>>()), .map(|graphs| graphs.iter().map(|g| g.as_ref().into()).collect::<Vec<_>>()),
}; };
Ok(Self { Self {
storage, storage,
extra: RefCell::new(HashMap::default()), extra: RefCell::new(HashMap::default()),
dataset, dataset,
}) }
} }
fn store_encoded_quads_for_pattern( fn store_encoded_quads_for_pattern(

2
lib/src/sparql/error.rs
Unescape View File

@ -106,7 +106,7 @@ impl From<io::Error> for EvaluationError {
} }
} }
impl<E: Into<EvaluationError>> From<DecoderError<E>> for EvaluationError { impl<E: Into<Self>> From<DecoderError<E>> for EvaluationError {
fn from(error: DecoderError<E>) -> Self { fn from(error: DecoderError<E>) -> Self {
match error { match error {
DecoderError::Store(error) => error.into(), DecoderError::Store(error) => error.into(),

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

@ -33,7 +33,7 @@ const REGEX_SIZE_LIMIT: usize = 1_000_000;
type EncodedTuplesIterator = Box<dyn Iterator<Item = Result<EncodedTuple, EvaluationError>>>; type EncodedTuplesIterator = Box<dyn Iterator<Item = Result<EncodedTuple, EvaluationError>>>;
#[derive(Clone)] #[derive(Clone)]
pub(crate) struct SimpleEvaluator { pub struct SimpleEvaluator {
dataset: Rc<DatasetView>, dataset: Rc<DatasetView>,
base_iri: Option<Rc<Iri<String>>>, base_iri: Option<Rc<Iri<String>>>,
now: DateTime, now: DateTime,
@ -58,11 +58,9 @@ impl SimpleEvaluator {
&self, &self,
plan: &PlanNode, plan: &PlanNode,
variables: Rc<Vec<Variable>>, variables: Rc<Vec<Variable>>,
) -> Result<QueryResults, EvaluationError> { ) -> QueryResults {
let iter = self.eval_plan(plan, EncodedTuple::with_capacity(variables.len())); let iter = self.eval_plan(plan, EncodedTuple::with_capacity(variables.len()));
Ok(QueryResults::Solutions( QueryResults::Solutions(self.decode_bindings(iter, variables))
self.decode_bindings(iter, variables),
))
} }
pub fn evaluate_ask_plan(&self, plan: &PlanNode) -> Result<QueryResults, EvaluationError> { pub fn evaluate_ask_plan(&self, plan: &PlanNode) -> Result<QueryResults, EvaluationError> {
@ -78,9 +76,9 @@ impl SimpleEvaluator {
&self, &self,
plan: &PlanNode, plan: &PlanNode,
template: Vec<TripleTemplate>, template: Vec<TripleTemplate>,
) -> Result<QueryResults, EvaluationError> { ) -> QueryResults {
let from = EncodedTuple::with_capacity(plan.maybe_bound_variables().len()); let from = EncodedTuple::with_capacity(plan.maybe_bound_variables().len());
Ok(QueryResults::Graph(QueryTripleIter { QueryResults::Graph(QueryTripleIter {
iter: Box::new(ConstructIterator { iter: Box::new(ConstructIterator {
eval: self.clone(), eval: self.clone(),
iter: self.eval_plan(plan, from), iter: self.eval_plan(plan, from),
@ -88,18 +86,18 @@ impl SimpleEvaluator {
buffered_results: Vec::default(), buffered_results: Vec::default(),
bnodes: Vec::default(), bnodes: Vec::default(),
}), }),
})) })
} }
pub fn evaluate_describe_plan(&self, plan: &PlanNode) -> Result<QueryResults, EvaluationError> { pub fn evaluate_describe_plan(&self, plan: &PlanNode) -> QueryResults {
let from = EncodedTuple::with_capacity(plan.maybe_bound_variables().len()); let from = EncodedTuple::with_capacity(plan.maybe_bound_variables().len());
Ok(QueryResults::Graph(QueryTripleIter { QueryResults::Graph(QueryTripleIter {
iter: Box::new(DescribeIterator { iter: Box::new(DescribeIterator {
eval: self.clone(), eval: self.clone(),
iter: self.eval_plan(plan, from), iter: self.eval_plan(plan, from),
quads: Box::new(empty()), quads: Box::new(empty()),
}), }),
})) })
} }
pub fn eval_plan(&self, node: &PlanNode, from: EncodedTuple) -> EncodedTuplesIterator { pub fn eval_plan(&self, node: &PlanNode, from: EncodedTuple) -> EncodedTuplesIterator {
@ -114,7 +112,7 @@ impl SimpleEvaluator {
.. ..
} => { } => {
match self.evaluate_service(service_name, graph_pattern, variables.clone(), &from) { match self.evaluate_service(service_name, graph_pattern, variables.clone(), &from) {
Ok(result) => Box::new(result.flat_map(move |binding| { Ok(result) => Box::new(result.filter_map(move |binding| {
binding binding
.map(|binding| binding.combine_with(&from)) .map(|binding| binding.combine_with(&from))
.transpose() .transpose()
@ -274,7 +272,7 @@ impl SimpleEvaluator {
//TODO: dumb implementation //TODO: dumb implementation
let right: Vec<_> = self let right: Vec<_> = self
.eval_plan(right, from.clone()) .eval_plan(right, from.clone())
.filter_map(|result| result.ok()) .filter_map(std::result::Result::ok)
.collect(); .collect();
Box::new(AntiJoinIterator { Box::new(AntiJoinIterator {
left_iter: self.eval_plan(left, from), left_iter: self.eval_plan(left, from),
@ -986,17 +984,19 @@ impl SimpleEvaluator {
PlanExpression::Not(e) => self PlanExpression::Not(e) => self
.to_bool(&self.eval_expression(e, tuple)?) .to_bool(&self.eval_expression(e, tuple)?)
.map(|v| (!v).into()), .map(|v| (!v).into()),
PlanExpression::Str(e) => Some(self.build_string_literal_from_id( PlanExpression::Str(e) | PlanExpression::StringCast(e) => {
Some(Self::build_string_literal_from_id(
self.to_string_id(&self.eval_expression(e, tuple)?)?, self.to_string_id(&self.eval_expression(e, tuple)?)?,
)), ))
}
PlanExpression::Lang(e) => match self.eval_expression(e, tuple)? { PlanExpression::Lang(e) => match self.eval_expression(e, tuple)? {
EncodedTerm::SmallSmallLangStringLiteral { language, .. } EncodedTerm::SmallSmallLangStringLiteral { language, .. }
| EncodedTerm::BigSmallLangStringLiteral { language, .. } => { | EncodedTerm::BigSmallLangStringLiteral { language, .. } => {
Some(self.build_string_literal_from_id(language.into())) Some(Self::build_string_literal_from_id(language.into()))
} }
EncodedTerm::SmallBigLangStringLiteral { language_id, .. } EncodedTerm::SmallBigLangStringLiteral { language_id, .. }
| EncodedTerm::BigBigLangStringLiteral { language_id, .. } => { | EncodedTerm::BigBigLangStringLiteral { language_id, .. } => {
Some(self.build_string_literal_from_id(language_id.into())) Some(Self::build_string_literal_from_id(language_id.into()))
} }
e if e.is_literal() => Some(self.build_string_literal("")), e if e.is_literal() => Some(self.build_string_literal("")),
_ => None, _ => None,
@ -1129,7 +1129,7 @@ impl SimpleEvaluator {
.char_indices() .char_indices()
.skip(starting_location.checked_sub(1)?) .skip(starting_location.checked_sub(1)?)
.peekable(); .peekable();
let result = if let Some((start_position, _)) = start_iter.peek().cloned() { let result = if let Some((start_position, _)) = start_iter.peek().copied() {
if let Some(length) = length { if let Some(length) = length {
let mut end_iter = start_iter.skip(length).peekable(); let mut end_iter = start_iter.skip(length).peekable();
if let Some((end_position, _)) = end_iter.peek() { if let Some((end_position, _)) = end_iter.peek() {
@ -1355,8 +1355,8 @@ impl SimpleEvaluator {
} }
} }
PlanExpression::StrLang(lexical_form, lang_tag) => { PlanExpression::StrLang(lexical_form, lang_tag) => {
Some(self.build_lang_string_literal_from_id( Some(Self::build_lang_string_literal_from_id(
self.to_simple_string_id(&self.eval_expression(lexical_form, tuple)?)?, Self::to_simple_string_id(&self.eval_expression(lexical_form, tuple)?)?,
self.build_language_id(&self.eval_expression(lang_tag, tuple)?)?, self.build_language_id(&self.eval_expression(lang_tag, tuple)?)?,
)) ))
} }
@ -1569,9 +1569,6 @@ impl SimpleEvaluator {
} }
_ => None, _ => None,
}, },
PlanExpression::StringCast(e) => Some(self.build_string_literal_from_id(
self.to_string_id(&self.eval_expression(e, tuple)?)?,
)),
} }
} }
@ -1592,9 +1589,9 @@ impl SimpleEvaluator {
fn to_string_id(&self, term: &EncodedTerm) -> Option<SmallStringOrId> { fn to_string_id(&self, term: &EncodedTerm) -> Option<SmallStringOrId> {
match term { match term {
EncodedTerm::DefaultGraph => None,
EncodedTerm::NamedNode { iri_id } => Some((*iri_id).into()), EncodedTerm::NamedNode { iri_id } => Some((*iri_id).into()),
EncodedTerm::NumericalBlankNode { .. } EncodedTerm::DefaultGraph
| EncodedTerm::NumericalBlankNode { .. }
| EncodedTerm::SmallBlankNode { .. } | EncodedTerm::SmallBlankNode { .. }
| EncodedTerm::BigBlankNode { .. } | EncodedTerm::BigBlankNode { .. }
| EncodedTerm::Triple(_) => None, | EncodedTerm::Triple(_) => None,
@ -1639,7 +1636,7 @@ impl SimpleEvaluator {
} }
} }
fn to_simple_string_id(&self, term: &EncodedTerm) -> Option<SmallStringOrId> { fn to_simple_string_id(term: &EncodedTerm) -> Option<SmallStringOrId> {
match term { match term {
EncodedTerm::SmallStringLiteral(value) => Some((*value).into()), EncodedTerm::SmallStringLiteral(value) => Some((*value).into()),
EncodedTerm::BigStringLiteral { value_id } => Some((*value_id).into()), EncodedTerm::BigStringLiteral { value_id } => Some((*value_id).into()),
@ -1700,10 +1697,10 @@ impl SimpleEvaluator {
} }
fn build_string_literal(&self, value: &str) -> EncodedTerm { fn build_string_literal(&self, value: &str) -> EncodedTerm {
self.build_string_literal_from_id(self.build_string_id(value)) Self::build_string_literal_from_id(self.build_string_id(value))
} }
fn build_string_literal_from_id(&self, id: SmallStringOrId) -> EncodedTerm { fn build_string_literal_from_id(id: SmallStringOrId) -> EncodedTerm {
match id { match id {
SmallStringOrId::Small(value) => EncodedTerm::SmallStringLiteral(value), SmallStringOrId::Small(value) => EncodedTerm::SmallStringLiteral(value),
SmallStringOrId::Big(value_id) => EncodedTerm::BigStringLiteral { value_id }, SmallStringOrId::Big(value_id) => EncodedTerm::BigStringLiteral { value_id },
@ -1711,11 +1708,10 @@ impl SimpleEvaluator {
} }
fn build_lang_string_literal(&self, value: &str, language_id: SmallStringOrId) -> EncodedTerm { fn build_lang_string_literal(&self, value: &str, language_id: SmallStringOrId) -> EncodedTerm {
self.build_lang_string_literal_from_id(self.build_string_id(value), language_id) Self::build_lang_string_literal_from_id(self.build_string_id(value), language_id)
} }
fn build_lang_string_literal_from_id( fn build_lang_string_literal_from_id(
&self,
value_id: SmallStringOrId, value_id: SmallStringOrId,
language_id: SmallStringOrId, language_id: SmallStringOrId,
) -> EncodedTerm { ) -> EncodedTerm {
@ -1797,8 +1793,7 @@ impl SimpleEvaluator {
'x' => { 'x' => {
regex_builder.ignore_whitespace(true); regex_builder.ignore_whitespace(true);
} }
'q' => (), //TODO: implement _ => (), //TODO: implement q
_ => (),
} }
} }
} }
@ -2311,115 +2306,115 @@ impl NumericBinaryOperands {
fn new(a: &EncodedTerm, b: &EncodedTerm) -> Option<Self> { fn new(a: &EncodedTerm, b: &EncodedTerm) -> Option<Self> {
match (a, b) { match (a, b) {
(EncodedTerm::FloatLiteral(v1), EncodedTerm::FloatLiteral(v2)) => { (EncodedTerm::FloatLiteral(v1), EncodedTerm::FloatLiteral(v2)) => {
Some(NumericBinaryOperands::Float(*v1, *v2)) Some(Self::Float(*v1, *v2))
} }
(EncodedTerm::FloatLiteral(v1), EncodedTerm::DoubleLiteral(v2)) => { (EncodedTerm::FloatLiteral(v1), EncodedTerm::DoubleLiteral(v2)) => {
Some(NumericBinaryOperands::Double((*v1).into(), *v2)) Some(Self::Double((*v1).into(), *v2))
} }
(EncodedTerm::FloatLiteral(v1), EncodedTerm::IntegerLiteral(v2)) => { (EncodedTerm::FloatLiteral(v1), EncodedTerm::IntegerLiteral(v2)) => {
Some(NumericBinaryOperands::Float(*v1, *v2 as f32)) Some(Self::Float(*v1, *v2 as f32))
} }
(EncodedTerm::FloatLiteral(v1), EncodedTerm::DecimalLiteral(v2)) => { (EncodedTerm::FloatLiteral(v1), EncodedTerm::DecimalLiteral(v2)) => {
Some(NumericBinaryOperands::Float(*v1, v2.to_f32())) Some(Self::Float(*v1, v2.to_f32()))
} }
(EncodedTerm::DoubleLiteral(v1), EncodedTerm::FloatLiteral(v2)) => { (EncodedTerm::DoubleLiteral(v1), EncodedTerm::FloatLiteral(v2)) => {
Some(NumericBinaryOperands::Double(*v1, (*v2).into())) Some(Self::Double(*v1, (*v2).into()))
} }
(EncodedTerm::DoubleLiteral(v1), EncodedTerm::DoubleLiteral(v2)) => { (EncodedTerm::DoubleLiteral(v1), EncodedTerm::DoubleLiteral(v2)) => {
Some(NumericBinaryOperands::Double(*v1, *v2)) Some(Self::Double(*v1, *v2))
} }
(EncodedTerm::DoubleLiteral(v1), EncodedTerm::IntegerLiteral(v2)) => { (EncodedTerm::DoubleLiteral(v1), EncodedTerm::IntegerLiteral(v2)) => {
Some(NumericBinaryOperands::Double(*v1, *v2 as f64)) Some(Self::Double(*v1, *v2 as f64))
} }
(EncodedTerm::DoubleLiteral(v1), EncodedTerm::DecimalLiteral(v2)) => { (EncodedTerm::DoubleLiteral(v1), EncodedTerm::DecimalLiteral(v2)) => {
Some(NumericBinaryOperands::Double(*v1, v2.to_f64())) Some(Self::Double(*v1, v2.to_f64()))
} }
(EncodedTerm::IntegerLiteral(v1), EncodedTerm::FloatLiteral(v2)) => { (EncodedTerm::IntegerLiteral(v1), EncodedTerm::FloatLiteral(v2)) => {
Some(NumericBinaryOperands::Float(*v1 as f32, *v2)) Some(Self::Float(*v1 as f32, *v2))
} }
(EncodedTerm::IntegerLiteral(v1), EncodedTerm::DoubleLiteral(v2)) => { (EncodedTerm::IntegerLiteral(v1), EncodedTerm::DoubleLiteral(v2)) => {
Some(NumericBinaryOperands::Double(*v1 as f64, *v2)) Some(Self::Double(*v1 as f64, *v2))
} }
(EncodedTerm::IntegerLiteral(v1), EncodedTerm::IntegerLiteral(v2)) => { (EncodedTerm::IntegerLiteral(v1), EncodedTerm::IntegerLiteral(v2)) => {
Some(NumericBinaryOperands::Integer(*v1, *v2)) Some(Self::Integer(*v1, *v2))
} }
(EncodedTerm::IntegerLiteral(v1), EncodedTerm::DecimalLiteral(v2)) => { (EncodedTerm::IntegerLiteral(v1), EncodedTerm::DecimalLiteral(v2)) => {
Some(NumericBinaryOperands::Decimal(Decimal::from(*v1), *v2)) Some(Self::Decimal(Decimal::from(*v1), *v2))
} }
(EncodedTerm::DecimalLiteral(v1), EncodedTerm::FloatLiteral(v2)) => { (EncodedTerm::DecimalLiteral(v1), EncodedTerm::FloatLiteral(v2)) => {
Some(NumericBinaryOperands::Float(v1.to_f32(), *v2)) Some(Self::Float(v1.to_f32(), *v2))
} }
(EncodedTerm::DecimalLiteral(v1), EncodedTerm::DoubleLiteral(v2)) => { (EncodedTerm::DecimalLiteral(v1), EncodedTerm::DoubleLiteral(v2)) => {
Some(NumericBinaryOperands::Double(v1.to_f64(), *v2)) Some(Self::Double(v1.to_f64(), *v2))
} }
(EncodedTerm::DecimalLiteral(v1), EncodedTerm::IntegerLiteral(v2)) => { (EncodedTerm::DecimalLiteral(v1), EncodedTerm::IntegerLiteral(v2)) => {
Some(NumericBinaryOperands::Decimal(*v1, Decimal::from(*v2))) Some(Self::Decimal(*v1, Decimal::from(*v2)))
} }
(EncodedTerm::DecimalLiteral(v1), EncodedTerm::DecimalLiteral(v2)) => { (EncodedTerm::DecimalLiteral(v1), EncodedTerm::DecimalLiteral(v2)) => {
Some(NumericBinaryOperands::Decimal(*v1, *v2)) Some(Self::Decimal(*v1, *v2))
} }
(EncodedTerm::DurationLiteral(v1), EncodedTerm::DurationLiteral(v2)) => { (EncodedTerm::DurationLiteral(v1), EncodedTerm::DurationLiteral(v2)) => {
Some(NumericBinaryOperands::Duration(*v1, *v2)) Some(Self::Duration(*v1, *v2))
} }
(EncodedTerm::DurationLiteral(v1), EncodedTerm::YearMonthDurationLiteral(v2)) => { (EncodedTerm::DurationLiteral(v1), EncodedTerm::YearMonthDurationLiteral(v2)) => {
Some(NumericBinaryOperands::Duration(*v1, (*v2).into())) Some(Self::Duration(*v1, (*v2).into()))
} }
(EncodedTerm::DurationLiteral(v1), EncodedTerm::DayTimeDurationLiteral(v2)) => { (EncodedTerm::DurationLiteral(v1), EncodedTerm::DayTimeDurationLiteral(v2)) => {
Some(NumericBinaryOperands::Duration(*v1, (*v2).into())) Some(Self::Duration(*v1, (*v2).into()))
} }
(EncodedTerm::YearMonthDurationLiteral(v1), EncodedTerm::DurationLiteral(v2)) => { (EncodedTerm::YearMonthDurationLiteral(v1), EncodedTerm::DurationLiteral(v2)) => {
Some(NumericBinaryOperands::Duration((*v1).into(), *v2)) Some(Self::Duration((*v1).into(), *v2))
} }
( (
EncodedTerm::YearMonthDurationLiteral(v1), EncodedTerm::YearMonthDurationLiteral(v1),
EncodedTerm::YearMonthDurationLiteral(v2), EncodedTerm::YearMonthDurationLiteral(v2),
) => Some(NumericBinaryOperands::YearMonthDuration(*v1, *v2)), ) => Some(Self::YearMonthDuration(*v1, *v2)),
( (
EncodedTerm::YearMonthDurationLiteral(v1), EncodedTerm::YearMonthDurationLiteral(v1),
EncodedTerm::DayTimeDurationLiteral(v2), EncodedTerm::DayTimeDurationLiteral(v2),
) => Some(NumericBinaryOperands::Duration((*v1).into(), (*v2).into())), ) => Some(Self::Duration((*v1).into(), (*v2).into())),
(EncodedTerm::DayTimeDurationLiteral(v1), EncodedTerm::DurationLiteral(v2)) => { (EncodedTerm::DayTimeDurationLiteral(v1), EncodedTerm::DurationLiteral(v2)) => {
Some(NumericBinaryOperands::Duration((*v1).into(), *v2)) Some(Self::Duration((*v1).into(), *v2))
} }
( (
EncodedTerm::DayTimeDurationLiteral(v1), EncodedTerm::DayTimeDurationLiteral(v1),
EncodedTerm::YearMonthDurationLiteral(v2), EncodedTerm::YearMonthDurationLiteral(v2),
) => Some(NumericBinaryOperands::Duration((*v1).into(), (*v2).into())), ) => Some(Self::Duration((*v1).into(), (*v2).into())),
(EncodedTerm::DayTimeDurationLiteral(v1), EncodedTerm::DayTimeDurationLiteral(v2)) => { (EncodedTerm::DayTimeDurationLiteral(v1), EncodedTerm::DayTimeDurationLiteral(v2)) => {
Some(NumericBinaryOperands::DayTimeDuration(*v1, *v2)) Some(Self::DayTimeDuration(*v1, *v2))
} }
(EncodedTerm::DateTimeLiteral(v1), EncodedTerm::DateTimeLiteral(v2)) => { (EncodedTerm::DateTimeLiteral(v1), EncodedTerm::DateTimeLiteral(v2)) => {
Some(NumericBinaryOperands::DateTime(*v1, *v2)) Some(Self::DateTime(*v1, *v2))
} }
(EncodedTerm::DateLiteral(v1), EncodedTerm::DateLiteral(v2)) => { (EncodedTerm::DateLiteral(v1), EncodedTerm::DateLiteral(v2)) => {
Some(NumericBinaryOperands::Date(*v1, *v2)) Some(Self::Date(*v1, *v2))
} }
(EncodedTerm::TimeLiteral(v1), EncodedTerm::TimeLiteral(v2)) => { (EncodedTerm::TimeLiteral(v1), EncodedTerm::TimeLiteral(v2)) => {
Some(NumericBinaryOperands::Time(*v1, *v2)) Some(Self::Time(*v1, *v2))
} }
(EncodedTerm::DateTimeLiteral(v1), EncodedTerm::DurationLiteral(v2)) => { (EncodedTerm::DateTimeLiteral(v1), EncodedTerm::DurationLiteral(v2)) => {
Some(NumericBinaryOperands::DateTimeDuration(*v1, *v2)) Some(Self::DateTimeDuration(*v1, *v2))
} }
(EncodedTerm::DateTimeLiteral(v1), EncodedTerm::YearMonthDurationLiteral(v2)) => { (EncodedTerm::DateTimeLiteral(v1), EncodedTerm::YearMonthDurationLiteral(v2)) => {
Some(NumericBinaryOperands::DateTimeYearMonthDuration(*v1, *v2)) Some(Self::DateTimeYearMonthDuration(*v1, *v2))
} }
(EncodedTerm::DateTimeLiteral(v1), EncodedTerm::DayTimeDurationLiteral(v2)) => { (EncodedTerm::DateTimeLiteral(v1), EncodedTerm::DayTimeDurationLiteral(v2)) => {
Some(NumericBinaryOperands::DateTimeDayTimeDuration(*v1, *v2)) Some(Self::DateTimeDayTimeDuration(*v1, *v2))
} }
(EncodedTerm::DateLiteral(v1), EncodedTerm::DurationLiteral(v2)) => { (EncodedTerm::DateLiteral(v1), EncodedTerm::DurationLiteral(v2)) => {
Some(NumericBinaryOperands::DateDuration(*v1, *v2)) Some(Self::DateDuration(*v1, *v2))
} }
(EncodedTerm::DateLiteral(v1), EncodedTerm::YearMonthDurationLiteral(v2)) => { (EncodedTerm::DateLiteral(v1), EncodedTerm::YearMonthDurationLiteral(v2)) => {
Some(NumericBinaryOperands::DateYearMonthDuration(*v1, *v2)) Some(Self::DateYearMonthDuration(*v1, *v2))
} }
(EncodedTerm::DateLiteral(v1), EncodedTerm::DayTimeDurationLiteral(v2)) => { (EncodedTerm::DateLiteral(v1), EncodedTerm::DayTimeDurationLiteral(v2)) => {
Some(NumericBinaryOperands::DateDayTimeDuration(*v1, *v2)) Some(Self::DateDayTimeDuration(*v1, *v2))
} }
(EncodedTerm::TimeLiteral(v1), EncodedTerm::DurationLiteral(v2)) => { (EncodedTerm::TimeLiteral(v1), EncodedTerm::DurationLiteral(v2)) => {
Some(NumericBinaryOperands::TimeDuration(*v1, *v2)) Some(Self::TimeDuration(*v1, *v2))
} }
(EncodedTerm::TimeLiteral(v1), EncodedTerm::DayTimeDurationLiteral(v2)) => { (EncodedTerm::TimeLiteral(v1), EncodedTerm::DayTimeDurationLiteral(v2)) => {
Some(NumericBinaryOperands::TimeDayTimeDuration(*v1, *v2)) Some(Self::TimeDayTimeDuration(*v1, *v2))
} }
_ => None, _ => None,
} }

31
lib/src/sparql/http/simple.rs
Unescape View File

@ -18,6 +18,7 @@ impl Client {
Self {} Self {}
} }
#[allow(clippy::unused_self)]
pub fn request( pub fn request(
&self, &self,
request: &Request<Option<Vec<u8>>>, request: &Request<Option<Vec<u8>>>,
@ -48,8 +49,8 @@ impl Client {
match scheme { match scheme {
"http" => { "http" => {
let mut stream = TcpStream::connect((host, port))?; let mut stream = TcpStream::connect((host, port))?;
self.encode(request, &mut stream)?; Self::encode(request, &mut stream)?;
self.decode(stream) Self::decode(stream)
} }
"https" => { "https" => {
let connector = let connector =
@ -58,8 +59,8 @@ impl Client {
let mut stream = connector let mut stream = connector
.connect(host, stream) .connect(host, stream)
.map_err(|e| io::Error::new(io::ErrorKind::Other, e))?; .map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;
self.encode(request, &mut stream)?; Self::encode(request, &mut stream)?;
self.decode(stream) Self::decode(stream)
} }
_ => Err(invalid_input_error(format!( _ => Err(invalid_input_error(format!(
"Not supported URL scheme: {}", "Not supported URL scheme: {}",
@ -68,11 +69,7 @@ impl Client {
} }
} }
fn encode( fn encode(request: &Request<Option<Vec<u8>>>, mut writer: &mut impl Write) -> io::Result<()> {
&self,
request: &Request<Option<Vec<u8>>>,
mut writer: &mut impl Write,
) -> io::Result<()> {
if request.headers().contains_key(CONTENT_LENGTH) { if request.headers().contains_key(CONTENT_LENGTH) {
return Err(invalid_input_error( return Err(invalid_input_error(
"content-length header is set by the client library", "content-length header is set by the client library",
@ -136,7 +133,7 @@ impl Client {
Ok(()) Ok(())
} }
fn decode<'a>(&self, reader: impl Read + 'a) -> io::Result<Response<Box<dyn BufRead + 'a>>> { fn decode<'a>(reader: impl Read + 'a) -> io::Result<Response<Box<dyn BufRead + 'a>>> {
let mut reader = BufReader::new(reader); let mut reader = BufReader::new(reader);
// Let's read the headers // Let's read the headers
@ -313,7 +310,7 @@ mod tests {
#[test] #[test]
fn encode_get_request() -> io::Result<()> { fn encode_get_request() -> io::Result<()> {
let mut buffer = Vec::new(); let mut buffer = Vec::new();
Client::new().encode( Client::encode(
&Request::builder() &Request::builder()
.method(Method::GET) .method(Method::GET)
.uri("http://example.com/foo/bar?query#fragment") .uri("http://example.com/foo/bar?query#fragment")
@ -332,7 +329,7 @@ mod tests {
#[test] #[test]
fn encode_post_request() -> io::Result<()> { fn encode_post_request() -> io::Result<()> {
let mut buffer = Vec::new(); let mut buffer = Vec::new();
Client::new().encode( Client::encode(
&Request::builder() &Request::builder()
.method(Method::POST) .method(Method::POST)
.uri("http://example.com/foo/bar?query#fragment") .uri("http://example.com/foo/bar?query#fragment")
@ -350,9 +347,7 @@ mod tests {
#[test] #[test]
fn decode_response_without_payload() -> io::Result<()> { fn decode_response_without_payload() -> io::Result<()> {
let response = Client::new() let response = Client::decode(Cursor::new("HTTP/1.1 404 Not Found\r\n\r\n")).unwrap();
.decode(Cursor::new("HTTP/1.1 404 Not Found\r\n\r\n"))
.unwrap();
assert_eq!(response.status(), StatusCode::NOT_FOUND); assert_eq!(response.status(), StatusCode::NOT_FOUND);
let mut buf = String::new(); let mut buf = String::new();
response.into_body().read_to_string(&mut buf)?; response.into_body().read_to_string(&mut buf)?;
@ -362,7 +357,7 @@ mod tests {
#[test] #[test]
fn decode_response_with_fixed_payload() -> io::Result<()> { fn decode_response_with_fixed_payload() -> io::Result<()> {
let response = Client::new().decode(Cursor::new( let response = Client::decode(Cursor::new(
"HTTP/1.1 200 OK\r\ncontent-type: text/plain\r\ncontent-length:8\r\n\r\ntestbody", "HTTP/1.1 200 OK\r\ncontent-type: text/plain\r\ncontent-length:8\r\n\r\ntestbody",
))?; ))?;
assert_eq!(response.status(), StatusCode::OK); assert_eq!(response.status(), StatusCode::OK);
@ -383,7 +378,7 @@ mod tests {
#[test] #[test]
fn decode_response_with_chunked_payload() -> io::Result<()> { fn decode_response_with_chunked_payload() -> io::Result<()> {
let response = Client::new().decode(Cursor::new( let response = Client::decode(Cursor::new(
"HTTP/1.1 200 OK\r\ncontent-type: text/plain\r\ntransfer-encoding:chunked\r\n\r\n4\r\nWiki\r\n5\r\npedia\r\nE\r\n in\r\n\r\nchunks.\r\n0\r\n\r\n", "HTTP/1.1 200 OK\r\ncontent-type: text/plain\r\ntransfer-encoding:chunked\r\n\r\n4\r\nWiki\r\n5\r\npedia\r\nE\r\n in\r\n\r\nchunks.\r\n0\r\n\r\n",
))?; ))?;
assert_eq!(response.status(), StatusCode::OK); assert_eq!(response.status(), StatusCode::OK);
@ -404,7 +399,7 @@ mod tests {
#[test] #[test]
fn decode_response_with_trailer() -> io::Result<()> { fn decode_response_with_trailer() -> io::Result<()> {
let response = Client::new().decode(Cursor::new( let response = Client::decode(Cursor::new(
"HTTP/1.1 200 OK\r\ncontent-type: text/plain\r\ntransfer-encoding:chunked\r\n\r\n4\r\nWiki\r\n5\r\npedia\r\nE\r\n in\r\n\r\nchunks.\r\n0\r\ntest: foo\r\n\r\n", "HTTP/1.1 200 OK\r\ncontent-type: text/plain\r\ntransfer-encoding:chunked\r\n\r\n4\r\nWiki\r\n5\r\npedia\r\nE\r\n in\r\n\r\nchunks.\r\n0\r\ntest: foo\r\n\r\n",
))?; ))?;
assert_eq!(response.status(), StatusCode::OK); assert_eq!(response.status(), StatusCode::OK);

16
lib/src/sparql/mod.rs
Unescape View File

@ -40,14 +40,14 @@ pub(crate) fn evaluate_query(
query: impl TryInto<Query, Error = impl Into<EvaluationError>>, query: impl TryInto<Query, Error = impl Into<EvaluationError>>,
options: QueryOptions, options: QueryOptions,
) -> Result<QueryResults, EvaluationError> { ) -> Result<QueryResults, EvaluationError> {
let query = query.try_into().map_err(|e| e.into())?; let query = query.try_into().map_err(std::convert::Into::into)?;
let dataset = DatasetView::new(storage, &query.dataset)?; let dataset = DatasetView::new(storage, &query.dataset);
match query.inner { match query.inner {
spargebra::Query::Select { spargebra::Query::Select {
pattern, base_iri, .. pattern, base_iri, ..
} => { } => {
let (plan, variables) = PlanBuilder::build(&dataset, &pattern)?; let (plan, variables) = PlanBuilder::build(&dataset, &pattern)?;
SimpleEvaluator::new( Ok(SimpleEvaluator::new(
Rc::new(dataset), Rc::new(dataset),
base_iri.map(Rc::new), base_iri.map(Rc::new),
options.service_handler, options.service_handler,
@ -60,7 +60,7 @@ pub(crate) fn evaluate_query(
.map(|v| Variable::new_unchecked(v.name)) .map(|v| Variable::new_unchecked(v.name))
.collect(), .collect(),
), ),
) ))
} }
spargebra::Query::Ask { spargebra::Query::Ask {
pattern, base_iri, .. pattern, base_iri, ..
@ -81,23 +81,23 @@ pub(crate) fn evaluate_query(
} => { } => {
let (plan, variables) = PlanBuilder::build(&dataset, &pattern)?; let (plan, variables) = PlanBuilder::build(&dataset, &pattern)?;
let construct = PlanBuilder::build_graph_template(&dataset, &template, variables); let construct = PlanBuilder::build_graph_template(&dataset, &template, variables);
SimpleEvaluator::new( Ok(SimpleEvaluator::new(
Rc::new(dataset), Rc::new(dataset),
base_iri.map(Rc::new), base_iri.map(Rc::new),
options.service_handler, options.service_handler,
) )
.evaluate_construct_plan(&plan, construct) .evaluate_construct_plan(&plan, construct))
} }
spargebra::Query::Describe { spargebra::Query::Describe {
pattern, base_iri, .. pattern, base_iri, ..
} => { } => {
let (plan, _) = PlanBuilder::build(&dataset, &pattern)?; let (plan, _) = PlanBuilder::build(&dataset, &pattern)?;
SimpleEvaluator::new( Ok(SimpleEvaluator::new(
Rc::new(dataset), Rc::new(dataset),
base_iri.map(Rc::new), base_iri.map(Rc::new),
options.service_handler, options.service_handler,
) )
.evaluate_describe_plan(&plan) .evaluate_describe_plan(&plan))
} }
} }
} }

16
lib/src/sparql/model.rs
Unescape View File

@ -109,7 +109,7 @@ impl QueryResults {
impl From<QuerySolutionIter> for QueryResults { impl From<QuerySolutionIter> for QueryResults {
#[inline] #[inline]
fn from(value: QuerySolutionIter) -> Self { fn from(value: QuerySolutionIter) -> Self {
QueryResults::Solutions(value) Self::Solutions(value)
} }
} }
@ -193,13 +193,13 @@ impl QueryResultsFormat {
if let Some(base_type) = media_type.split(';').next() { if let Some(base_type) = media_type.split(';').next() {
match base_type { match base_type {
"application/sparql-results+xml" | "application/xml" | "text/xml" => { "application/sparql-results+xml" | "application/xml" | "text/xml" => {
Some(QueryResultsFormat::Xml) Some(Self::Xml)
} }
"application/sparql-results+json" | "application/json" | "text/json" => { "application/sparql-results+json" | "application/json" | "text/json" => {
Some(QueryResultsFormat::Json) Some(Self::Json)
} }
"text/csv" => Some(QueryResultsFormat::Csv), "text/csv" => Some(Self::Csv),
"text/tab-separated-values" | "text/tsv" => Some(QueryResultsFormat::Tsv), "text/tab-separated-values" | "text/tsv" => Some(Self::Tsv),
_ => None, _ => None,
} }
} else { } else {
@ -287,7 +287,7 @@ impl QuerySolution {
/// ``` /// ```
#[inline] #[inline]
pub fn get(&self, index: impl VariableSolutionIndex) -> Option<&Term> { pub fn get(&self, index: impl VariableSolutionIndex) -> Option<&Term> {
self.values.get(index.index(self)?).and_then(|e| e.as_ref()) self.values.get(index.index(self)?).and_then(std::option::Option::as_ref)
} }
/// The number of variables which could be bound /// The number of variables which could be bound
@ -314,7 +314,7 @@ impl QuerySolution {
/// Returns an iterator over all values, bound or not /// Returns an iterator over all values, bound or not
#[inline] #[inline]
pub fn values(&self) -> impl Iterator<Item = Option<&Term>> { pub fn values(&self) -> impl Iterator<Item = Option<&Term>> {
self.values.iter().map(|v| v.as_ref()) self.values.iter().map(std::option::Option::as_ref)
} }
} }
@ -425,7 +425,7 @@ impl Variable {
/// [`Variable::new()`] is a safe version of this constructor and should be used for untrusted data. /// [`Variable::new()`] is a safe version of this constructor and should be used for untrusted data.
#[inline] #[inline]
pub fn new_unchecked(name: impl Into<String>) -> Self { pub fn new_unchecked(name: impl Into<String>) -> Self {
Variable { name: name.into() } Self { name: name.into() }
} }
#[inline] #[inline]

234
lib/src/sparql/plan.rs
Unescape View File

@ -13,71 +13,71 @@ pub enum PlanNode {
Service { Service {
service_name: PatternValue, service_name: PatternValue,
variables: Rc<Vec<Variable>>, variables: Rc<Vec<Variable>>,
child: Rc<PlanNode>, child: Rc<Self>,
graph_pattern: Rc<GraphPattern>, graph_pattern: Rc<GraphPattern>,
silent: bool, silent: bool,
}, },
QuadPatternJoin { QuadPatternJoin {
child: Rc<PlanNode>, child: Rc<Self>,
subject: PatternValue, subject: PatternValue,
predicate: PatternValue, predicate: PatternValue,
object: PatternValue, object: PatternValue,
graph_name: PatternValue, graph_name: PatternValue,
}, },
PathPatternJoin { PathPatternJoin {
child: Rc<PlanNode>, child: Rc<Self>,
subject: PatternValue, subject: PatternValue,
path: Rc<PlanPropertyPath>, path: Rc<PlanPropertyPath>,
object: PatternValue, object: PatternValue,
graph_name: PatternValue, graph_name: PatternValue,
}, },
Join { Join {
left: Rc<PlanNode>, left: Rc<Self>,
right: Rc<PlanNode>, right: Rc<Self>,
}, },
AntiJoin { AntiJoin {
left: Rc<PlanNode>, left: Rc<Self>,
right: Rc<PlanNode>, right: Rc<Self>,
}, },
Filter { Filter {
child: Rc<PlanNode>, child: Rc<Self>,
expression: Rc<PlanExpression>, expression: Rc<PlanExpression>,
}, },
Union { Union {
children: Vec<Rc<PlanNode>>, children: Vec<Rc<Self>>,
}, },
LeftJoin { LeftJoin {
left: Rc<PlanNode>, left: Rc<Self>,
right: Rc<PlanNode>, right: Rc<Self>,
possible_problem_vars: Rc<Vec<usize>>, //Variables that should not be part of the entry of the left join possible_problem_vars: Rc<Vec<usize>>, //Variables that should not be part of the entry of the left join
}, },
Extend { Extend {
child: Rc<PlanNode>, child: Rc<Self>,
position: usize, position: usize,
expression: Rc<PlanExpression>, expression: Rc<PlanExpression>,
}, },
Sort { Sort {
child: Rc<PlanNode>, child: Rc<Self>,
by: Vec<Comparator>, by: Vec<Comparator>,
}, },
HashDeduplicate { HashDeduplicate {
child: Rc<PlanNode>, child: Rc<Self>,
}, },
Skip { Skip {
child: Rc<PlanNode>, child: Rc<Self>,
count: usize, count: usize,
}, },
Limit { Limit {
child: Rc<PlanNode>, child: Rc<Self>,
count: usize, count: usize,
}, },
Project { Project {
child: Rc<PlanNode>, child: Rc<Self>,
mapping: Rc<Vec<(usize, usize)>>, // pairs of (variable key in child, variable key in output) mapping: Rc<Vec<(usize, usize)>>, // pairs of (variable key in child, variable key in output)
}, },
Aggregate { Aggregate {
// By definition the group by key are the range 0..key_mapping.len() // By definition the group by key are the range 0..key_mapping.len()
child: Rc<PlanNode>, child: Rc<Self>,
key_mapping: Rc<Vec<(usize, usize)>>, // aggregate key pairs of (variable key in child, variable key in output) key_mapping: Rc<Vec<(usize, usize)>>, // aggregate key pairs of (variable key in child, variable key in output)
aggregates: Rc<Vec<(PlanAggregation, usize)>>, aggregates: Rc<Vec<(PlanAggregation, usize)>>,
}, },
@ -212,109 +212,109 @@ pub enum PlanExpression {
Constant(EncodedTerm), Constant(EncodedTerm),
Variable(usize), Variable(usize),
Exists(Rc<PlanNode>), Exists(Rc<PlanNode>),
Or(Box<PlanExpression>, Box<PlanExpression>), Or(Box<Self>, Box<Self>),
And(Box<PlanExpression>, Box<PlanExpression>), And(Box<Self>, Box<Self>),
Equal(Box<PlanExpression>, Box<PlanExpression>), Equal(Box<Self>, Box<Self>),
Greater(Box<PlanExpression>, Box<PlanExpression>), Greater(Box<Self>, Box<Self>),
GreaterOrEqual(Box<PlanExpression>, Box<PlanExpression>), GreaterOrEqual(Box<Self>, Box<Self>),
Less(Box<PlanExpression>, Box<PlanExpression>), Less(Box<Self>, Box<Self>),
LessOrEqual(Box<PlanExpression>, Box<PlanExpression>), LessOrEqual(Box<Self>, Box<Self>),
In(Box<PlanExpression>, Vec<PlanExpression>), In(Box<Self>, Vec<Self>),
Add(Box<PlanExpression>, Box<PlanExpression>), Add(Box<Self>, Box<Self>),
Subtract(Box<PlanExpression>, Box<PlanExpression>), Subtract(Box<Self>, Box<Self>),
Multiply(Box<PlanExpression>, Box<PlanExpression>), Multiply(Box<Self>, Box<Self>),
Divide(Box<PlanExpression>, Box<PlanExpression>), Divide(Box<Self>, Box<Self>),
UnaryPlus(Box<PlanExpression>), UnaryPlus(Box<Self>),
UnaryMinus(Box<PlanExpression>), UnaryMinus(Box<Self>),
Not(Box<PlanExpression>), Not(Box<Self>),
Str(Box<PlanExpression>), Str(Box<Self>),
Lang(Box<PlanExpression>), Lang(Box<Self>),
LangMatches(Box<PlanExpression>, Box<PlanExpression>), LangMatches(Box<Self>, Box<Self>),
Datatype(Box<PlanExpression>), Datatype(Box<Self>),
Bound(usize), Bound(usize),
Iri(Box<PlanExpression>), Iri(Box<Self>),
BNode(Option<Box<PlanExpression>>), BNode(Option<Box<Self>>),
Rand, Rand,
Abs(Box<PlanExpression>), Abs(Box<Self>),
Ceil(Box<PlanExpression>), Ceil(Box<Self>),
Floor(Box<PlanExpression>), Floor(Box<Self>),
Round(Box<PlanExpression>), Round(Box<Self>),
Concat(Vec<PlanExpression>), Concat(Vec<Self>),
SubStr( SubStr(
Box<PlanExpression>, Box<Self>,
Box<PlanExpression>, Box<Self>,
Option<Box<PlanExpression>>, Option<Box<Self>>,
), ),
StrLen(Box<PlanExpression>), StrLen(Box<Self>),
Replace( Replace(
Box<PlanExpression>, Box<Self>,
Box<PlanExpression>, Box<Self>,
Box<PlanExpression>, Box<Self>,
Option<Box<PlanExpression>>, Option<Box<Self>>,
), ),
UCase(Box<PlanExpression>), UCase(Box<Self>),
LCase(Box<PlanExpression>), LCase(Box<Self>),
EncodeForUri(Box<PlanExpression>), EncodeForUri(Box<Self>),
Contains(Box<PlanExpression>, Box<PlanExpression>), Contains(Box<Self>, Box<Self>),
StrStarts(Box<PlanExpression>, Box<PlanExpression>), StrStarts(Box<Self>, Box<Self>),
StrEnds(Box<PlanExpression>, Box<PlanExpression>), StrEnds(Box<Self>, Box<Self>),
StrBefore(Box<PlanExpression>, Box<PlanExpression>), StrBefore(Box<Self>, Box<Self>),
StrAfter(Box<PlanExpression>, Box<PlanExpression>), StrAfter(Box<Self>, Box<Self>),
Year(Box<PlanExpression>), Year(Box<Self>),
Month(Box<PlanExpression>), Month(Box<Self>),
Day(Box<PlanExpression>), Day(Box<Self>),
Hours(Box<PlanExpression>), Hours(Box<Self>),
Minutes(Box<PlanExpression>), Minutes(Box<Self>),
Seconds(Box<PlanExpression>), Seconds(Box<Self>),
Timezone(Box<PlanExpression>), Timezone(Box<Self>),
Tz(Box<PlanExpression>), Tz(Box<Self>),
Now, Now,
Uuid, Uuid,
StrUuid, StrUuid,
Md5(Box<PlanExpression>), Md5(Box<Self>),
Sha1(Box<PlanExpression>), Sha1(Box<Self>),
Sha256(Box<PlanExpression>), Sha256(Box<Self>),
Sha384(Box<PlanExpression>), Sha384(Box<Self>),
Sha512(Box<PlanExpression>), Sha512(Box<Self>),
Coalesce(Vec<PlanExpression>), Coalesce(Vec<Self>),
If( If(
Box<PlanExpression>, Box<Self>,
Box<PlanExpression>, Box<Self>,
Box<PlanExpression>, Box<Self>,
), ),
StrLang(Box<PlanExpression>, Box<PlanExpression>), StrLang(Box<Self>, Box<Self>),
StrDt(Box<PlanExpression>, Box<PlanExpression>), StrDt(Box<Self>, Box<Self>),
SameTerm(Box<PlanExpression>, Box<PlanExpression>), SameTerm(Box<Self>, Box<Self>),
IsIri(Box<PlanExpression>), IsIri(Box<Self>),
IsBlank(Box<PlanExpression>), IsBlank(Box<Self>),
IsLiteral(Box<PlanExpression>), IsLiteral(Box<Self>),
IsNumeric(Box<PlanExpression>), IsNumeric(Box<Self>),
Regex( Regex(
Box<PlanExpression>, Box<Self>,
Box<PlanExpression>, Box<Self>,
Option<Box<PlanExpression>>, Option<Box<Self>>,
), ),
Triple( Triple(
Box<PlanExpression>, Box<Self>,
Box<PlanExpression>, Box<Self>,
Box<PlanExpression>, Box<Self>,
), ),
Subject(Box<PlanExpression>), Subject(Box<Self>),
Predicate(Box<PlanExpression>), Predicate(Box<Self>),
Object(Box<PlanExpression>), Object(Box<Self>),
IsTriple(Box<PlanExpression>), IsTriple(Box<Self>),
BooleanCast(Box<PlanExpression>), BooleanCast(Box<Self>),
DoubleCast(Box<PlanExpression>), DoubleCast(Box<Self>),
FloatCast(Box<PlanExpression>), FloatCast(Box<Self>),
DecimalCast(Box<PlanExpression>), DecimalCast(Box<Self>),
IntegerCast(Box<PlanExpression>), IntegerCast(Box<Self>),
DateCast(Box<PlanExpression>), DateCast(Box<Self>),
TimeCast(Box<PlanExpression>), TimeCast(Box<Self>),
DateTimeCast(Box<PlanExpression>), DateTimeCast(Box<Self>),
DurationCast(Box<PlanExpression>), DurationCast(Box<Self>),
YearMonthDurationCast(Box<PlanExpression>), YearMonthDurationCast(Box<Self>),
DayTimeDurationCast(Box<PlanExpression>), DayTimeDurationCast(Box<Self>),
StringCast(Box<PlanExpression>), StringCast(Box<Self>),
} }
impl PlanExpression { impl PlanExpression {
@ -458,12 +458,12 @@ pub enum PlanAggregationFunction {
#[derive(Eq, PartialEq, Debug, Clone, Hash)] #[derive(Eq, PartialEq, Debug, Clone, Hash)]
pub enum PlanPropertyPath { pub enum PlanPropertyPath {
Path(EncodedTerm), Path(EncodedTerm),
Reverse(Rc<PlanPropertyPath>), Reverse(Rc<Self>),
Sequence(Rc<PlanPropertyPath>, Rc<PlanPropertyPath>), Sequence(Rc<Self>, Rc<Self>),
Alternative(Rc<PlanPropertyPath>, Rc<PlanPropertyPath>), Alternative(Rc<Self>, Rc<Self>),
ZeroOrMore(Rc<PlanPropertyPath>), ZeroOrMore(Rc<Self>),
OneOrMore(Rc<PlanPropertyPath>), OneOrMore(Rc<Self>),
ZeroOrOne(Rc<PlanPropertyPath>), ZeroOrOne(Rc<Self>),
NegatedPropertySet(Rc<Vec<EncodedTerm>>), NegatedPropertySet(Rc<Vec<EncodedTerm>>),
} }
@ -529,9 +529,9 @@ impl EncodedTuple {
} }
} }
pub fn combine_with(&self, other: &EncodedTuple) -> Option<Self> { pub fn combine_with(&self, other: &Self) -> Option<Self> {
if self.inner.len() < other.inner.len() { if self.inner.len() < other.inner.len() {
let mut result = other.inner.to_owned(); let mut result = other.inner.clone();
for (key, self_value) in self.inner.iter().enumerate() { for (key, self_value) in self.inner.iter().enumerate() {
if let Some(self_value) = self_value { if let Some(self_value) = self_value {
match other.inner[key] { match other.inner[key] {
@ -544,9 +544,9 @@ impl EncodedTuple {
} }
} }
} }
Some(EncodedTuple { inner: result }) Some(Self { inner: result })
} else { } else {
let mut result = self.inner.to_owned(); let mut result = self.inner.clone();
for (key, other_value) in other.inner.iter().enumerate() { for (key, other_value) in other.inner.iter().enumerate() {
if let Some(other_value) = other_value { if let Some(other_value) = other_value {
match self.inner[key] { match self.inner[key] {
@ -559,7 +559,7 @@ impl EncodedTuple {
} }
} }
} }
Some(EncodedTuple { inner: result }) Some(Self { inner: result })
} }
} }
} }

13
lib/src/sparql/plan_builder.rs
Unescape View File

@ -10,7 +10,7 @@ use spargebra::term::*;
use std::collections::{BTreeSet, HashSet}; use std::collections::{BTreeSet, HashSet};
use std::rc::Rc; use std::rc::Rc;
pub(crate) struct PlanBuilder<'a> { pub struct PlanBuilder<'a> {
dataset: &'a DatasetView, dataset: &'a DatasetView,
} }
@ -920,7 +920,7 @@ impl<'a> PlanBuilder<'a> {
separator, separator,
} => Ok(PlanAggregation { } => Ok(PlanAggregation {
function: PlanAggregationFunction::GroupConcat { function: PlanAggregationFunction::GroupConcat {
separator: Rc::new(separator.clone().unwrap_or_else(|| " ".to_string())), separator: Rc::new(separator.clone().unwrap_or_else(|| " ".to_owned())),
}, },
parameter: Some(self.build_for_expression(expr, variables, graph_name)?), parameter: Some(self.build_for_expression(expr, variables, graph_name)?),
distinct: *distinct, distinct: *distinct,
@ -1027,7 +1027,7 @@ impl<'a> PlanBuilder<'a> {
match from_value { match from_value {
PatternValue::Constant(v) => PatternValue::Constant(v.clone()), PatternValue::Constant(v) => PatternValue::Constant(v.clone()),
PatternValue::Variable(from_id) => { PatternValue::Variable(from_id) => {
PatternValue::Variable(self.convert_variable_id(*from_id, from, to)) PatternValue::Variable(Self::convert_variable_id(*from_id, from, to))
} }
PatternValue::Triple(triple) => PatternValue::Triple(Box::new(TriplePatternValue { PatternValue::Triple(triple) => PatternValue::Triple(Box::new(TriplePatternValue {
subject: self.convert_pattern_value_id(&triple.subject, from, to), subject: self.convert_pattern_value_id(&triple.subject, from, to),
@ -1037,12 +1037,7 @@ impl<'a> PlanBuilder<'a> {
} }
} }
fn convert_variable_id( fn convert_variable_id(from_id: usize, from: &[Variable], to: &mut Vec<Variable>) -> usize {
&self,
from_id: usize,
from: &[Variable],
to: &mut Vec<Variable>,
) -> usize {
if let Some(to_id) = to.iter().enumerate().find_map(|(to_id, var)| { if let Some(to_id) = to.iter().enumerate().find_map(|(to_id, var)| {
if *var == from[from_id] { if *var == from[from_id] {
Some(to_id) Some(to_id)

166
lib/src/sparql/update.rs
Unescape View File

@ -29,7 +29,7 @@ use std::collections::HashMap;
use std::io; use std::io;
use std::rc::Rc; use std::rc::Rc;
pub(crate) struct SimpleUpdateEvaluator<'a> { pub struct SimpleUpdateEvaluator<'a> {
storage: &'a Storage, storage: &'a Storage,
base_iri: Option<Rc<Iri<String>>>, base_iri: Option<Rc<Iri<String>>>,
options: UpdateOptions, options: UpdateOptions,
@ -95,7 +95,7 @@ impl<'a> SimpleUpdateEvaluator<'a> {
fn eval_insert_data(&mut self, data: &[Quad]) -> Result<(), EvaluationError> { fn eval_insert_data(&mut self, data: &[Quad]) -> Result<(), EvaluationError> {
let mut bnodes = HashMap::new(); let mut bnodes = HashMap::new();
for quad in data { for quad in data {
let quad = self.convert_quad(quad, &mut bnodes); let quad = Self::convert_quad(quad, &mut bnodes);
self.storage.insert(quad.as_ref())?; self.storage.insert(quad.as_ref())?;
} }
Ok(()) Ok(())
@ -103,7 +103,7 @@ impl<'a> SimpleUpdateEvaluator<'a> {
fn eval_delete_data(&mut self, data: &[GroundQuad]) -> Result<(), EvaluationError> { fn eval_delete_data(&mut self, data: &[GroundQuad]) -> Result<(), EvaluationError> {
for quad in data { for quad in data {
let quad = self.convert_ground_quad(quad); let quad = Self::convert_ground_quad(quad);
self.storage.remove(quad.as_ref())?; self.storage.remove(quad.as_ref())?;
} }
Ok(()) Ok(())
@ -116,7 +116,7 @@ impl<'a> SimpleUpdateEvaluator<'a> {
using: &QueryDataset, using: &QueryDataset,
algebra: &GraphPattern, algebra: &GraphPattern,
) -> Result<(), EvaluationError> { ) -> Result<(), EvaluationError> {
let dataset = Rc::new(DatasetView::new(self.storage.clone(), using)?); let dataset = Rc::new(DatasetView::new(self.storage.clone(), using));
let (plan, variables) = PlanBuilder::build(dataset.as_ref(), algebra)?; let (plan, variables) = PlanBuilder::build(dataset.as_ref(), algebra)?;
let evaluator = SimpleEvaluator::new( let evaluator = SimpleEvaluator::new(
dataset.clone(), dataset.clone(),
@ -128,7 +128,7 @@ impl<'a> SimpleUpdateEvaluator<'a> {
let tuple = tuple?; let tuple = tuple?;
for quad in delete { for quad in delete {
if let Some(quad) = if let Some(quad) =
self.convert_ground_quad_pattern(quad, &variables, &tuple, &dataset)? Self::convert_ground_quad_pattern(quad, &variables, &tuple, &dataset)?
{ {
self.storage.remove(quad.as_ref())?; self.storage.remove(quad.as_ref())?;
// Hack to make sure the triple terms are still available for an insert // Hack to make sure the triple terms are still available for an insert
@ -139,7 +139,7 @@ impl<'a> SimpleUpdateEvaluator<'a> {
} }
for quad in insert { for quad in insert {
if let Some(quad) = if let Some(quad) =
self.convert_quad_pattern(quad, &variables, &tuple, &dataset, &mut bnodes)? Self::convert_quad_pattern(quad, &variables, &tuple, &dataset, &mut bnodes)?
{ {
self.storage.insert(quad.as_ref())?; self.storage.insert(quad.as_ref())?;
} }
@ -254,61 +254,56 @@ impl<'a> SimpleUpdateEvaluator<'a> {
} }
} }
fn convert_quad(&self, quad: &Quad, bnodes: &mut HashMap<BlankNode, OxBlankNode>) -> OxQuad { fn convert_quad(quad: &Quad, bnodes: &mut HashMap<BlankNode, OxBlankNode>) -> OxQuad {
OxQuad { OxQuad {
subject: match &quad.subject { subject: match &quad.subject {
Subject::NamedNode(subject) => self.convert_named_node(subject).into(), Subject::NamedNode(subject) => Self::convert_named_node(subject).into(),
Subject::BlankNode(subject) => self.convert_blank_node(subject, bnodes).into(), Subject::BlankNode(subject) => Self::convert_blank_node(subject, bnodes).into(),
Subject::Triple(subject) => self.convert_triple(subject, bnodes).into(), Subject::Triple(subject) => Self::convert_triple(subject, bnodes).into(),
}, },
predicate: self.convert_named_node(&quad.predicate), predicate: Self::convert_named_node(&quad.predicate),
object: match &quad.object { object: match &quad.object {
Term::NamedNode(object) => self.convert_named_node(object).into(), Term::NamedNode(object) => Self::convert_named_node(object).into(),
Term::BlankNode(object) => self.convert_blank_node(object, bnodes).into(), Term::BlankNode(object) => Self::convert_blank_node(object, bnodes).into(),
Term::Literal(object) => self.convert_literal(object).into(), Term::Literal(object) => Self::convert_literal(object).into(),
Term::Triple(subject) => self.convert_triple(subject, bnodes).into(), Term::Triple(subject) => Self::convert_triple(subject, bnodes).into(),
}, },
graph_name: match &quad.graph_name { graph_name: match &quad.graph_name {
GraphName::NamedNode(graph_name) => self.convert_named_node(graph_name).into(), GraphName::NamedNode(graph_name) => Self::convert_named_node(graph_name).into(),
GraphName::DefaultGraph => OxGraphName::DefaultGraph, GraphName::DefaultGraph => OxGraphName::DefaultGraph,
}, },
} }
} }
fn convert_triple( fn convert_triple(triple: &Triple, bnodes: &mut HashMap<BlankNode, OxBlankNode>) -> OxTriple {
&self,
triple: &Triple,
bnodes: &mut HashMap<BlankNode, OxBlankNode>,
) -> OxTriple {
OxTriple { OxTriple {
subject: match &triple.subject { subject: match &triple.subject {
Subject::NamedNode(subject) => self.convert_named_node(subject).into(), Subject::NamedNode(subject) => Self::convert_named_node(subject).into(),
Subject::BlankNode(subject) => self.convert_blank_node(subject, bnodes).into(), Subject::BlankNode(subject) => Self::convert_blank_node(subject, bnodes).into(),
Subject::Triple(subject) => self.convert_triple(subject, bnodes).into(), Subject::Triple(subject) => Self::convert_triple(subject, bnodes).into(),
}, },
predicate: self.convert_named_node(&triple.predicate), predicate: Self::convert_named_node(&triple.predicate),
object: match &triple.object { object: match &triple.object {
Term::NamedNode(object) => self.convert_named_node(object).into(), Term::NamedNode(object) => Self::convert_named_node(object).into(),
Term::BlankNode(object) => self.convert_blank_node(object, bnodes).into(), Term::BlankNode(object) => Self::convert_blank_node(object, bnodes).into(),
Term::Literal(object) => self.convert_literal(object).into(), Term::Literal(object) => Self::convert_literal(object).into(),
Term::Triple(subject) => self.convert_triple(subject, bnodes).into(), Term::Triple(subject) => Self::convert_triple(subject, bnodes).into(),
}, },
} }
} }
fn convert_named_node(&self, node: &NamedNode) -> OxNamedNode { fn convert_named_node(node: &NamedNode) -> OxNamedNode {
OxNamedNode::new_unchecked(&node.iri) OxNamedNode::new_unchecked(&node.iri)
} }
fn convert_blank_node( fn convert_blank_node(
&self,
node: &BlankNode, node: &BlankNode,
bnodes: &mut HashMap<BlankNode, OxBlankNode>, bnodes: &mut HashMap<BlankNode, OxBlankNode>,
) -> OxBlankNode { ) -> OxBlankNode {
bnodes.entry(node.clone()).or_default().clone() bnodes.entry(node.clone()).or_default().clone()
} }
fn convert_literal(&self, literal: &Literal) -> OxLiteral { fn convert_literal(literal: &Literal) -> OxLiteral {
match literal { match literal {
Literal::Simple { value } => OxLiteral::new_simple_literal(value), Literal::Simple { value } => OxLiteral::new_simple_literal(value),
Literal::LanguageTaggedString { value, language } => { Literal::LanguageTaggedString { value, language } => {
@ -320,42 +315,41 @@ impl<'a> SimpleUpdateEvaluator<'a> {
} }
} }
fn convert_ground_quad(&self, quad: &GroundQuad) -> OxQuad { fn convert_ground_quad(quad: &GroundQuad) -> OxQuad {
OxQuad { OxQuad {
subject: match &quad.subject { subject: match &quad.subject {
GroundSubject::NamedNode(subject) => self.convert_named_node(subject).into(), GroundSubject::NamedNode(subject) => Self::convert_named_node(subject).into(),
GroundSubject::Triple(subject) => self.convert_ground_triple(subject).into(), GroundSubject::Triple(subject) => Self::convert_ground_triple(subject).into(),
}, },
predicate: self.convert_named_node(&quad.predicate), predicate: Self::convert_named_node(&quad.predicate),
object: match &quad.object { object: match &quad.object {
GroundTerm::NamedNode(object) => self.convert_named_node(object).into(), GroundTerm::NamedNode(object) => Self::convert_named_node(object).into(),
GroundTerm::Literal(object) => self.convert_literal(object).into(), GroundTerm::Literal(object) => Self::convert_literal(object).into(),
GroundTerm::Triple(subject) => self.convert_ground_triple(subject).into(), GroundTerm::Triple(subject) => Self::convert_ground_triple(subject).into(),
}, },
graph_name: match &quad.graph_name { graph_name: match &quad.graph_name {
GraphName::NamedNode(graph_name) => self.convert_named_node(graph_name).into(), GraphName::NamedNode(graph_name) => Self::convert_named_node(graph_name).into(),
GraphName::DefaultGraph => OxGraphName::DefaultGraph, GraphName::DefaultGraph => OxGraphName::DefaultGraph,
}, },
} }
} }
fn convert_ground_triple(&self, triple: &GroundTriple) -> OxTriple { fn convert_ground_triple(triple: &GroundTriple) -> OxTriple {
OxTriple { OxTriple {
subject: match &triple.subject { subject: match &triple.subject {
GroundSubject::NamedNode(subject) => self.convert_named_node(subject).into(), GroundSubject::NamedNode(subject) => Self::convert_named_node(subject).into(),
GroundSubject::Triple(subject) => self.convert_ground_triple(subject).into(), GroundSubject::Triple(subject) => Self::convert_ground_triple(subject).into(),
}, },
predicate: self.convert_named_node(&triple.predicate), predicate: Self::convert_named_node(&triple.predicate),
object: match &triple.object { object: match &triple.object {
GroundTerm::NamedNode(object) => self.convert_named_node(object).into(), GroundTerm::NamedNode(object) => Self::convert_named_node(object).into(),
GroundTerm::Literal(object) => self.convert_literal(object).into(), GroundTerm::Literal(object) => Self::convert_literal(object).into(),
GroundTerm::Triple(subject) => self.convert_ground_triple(subject).into(), GroundTerm::Triple(subject) => Self::convert_ground_triple(subject).into(),
}, },
} }
} }
fn convert_quad_pattern( fn convert_quad_pattern(
&self,
quad: &QuadPattern, quad: &QuadPattern,
variables: &[Variable], variables: &[Variable],
values: &EncodedTuple, values: &EncodedTuple,
@ -363,7 +357,7 @@ impl<'a> SimpleUpdateEvaluator<'a> {
bnodes: &mut HashMap<BlankNode, OxBlankNode>, bnodes: &mut HashMap<BlankNode, OxBlankNode>,
) -> Result<Option<OxQuad>, EvaluationError> { ) -> Result<Option<OxQuad>, EvaluationError> {
Ok(Some(OxQuad { Ok(Some(OxQuad {
subject: match self.convert_term_or_var( subject: match Self::convert_term_or_var(
&quad.subject, &quad.subject,
variables, variables,
values, values,
@ -376,21 +370,21 @@ impl<'a> SimpleUpdateEvaluator<'a> {
Some(OxTerm::Literal(_)) | None => return Ok(None), Some(OxTerm::Literal(_)) | None => return Ok(None),
}, },
predicate: if let Some(predicate) = predicate: if let Some(predicate) =
self.convert_named_node_or_var(&quad.predicate, variables, values, dataset)? Self::convert_named_node_or_var(&quad.predicate, variables, values, dataset)?
{ {
predicate predicate
} else { } else {
return Ok(None); return Ok(None);
}, },
object: if let Some(object) = object: if let Some(object) =
self.convert_term_or_var(&quad.object, variables, values, dataset, bnodes)? Self::convert_term_or_var(&quad.object, variables, values, dataset, bnodes)?
{ {
object object
} else { } else {
return Ok(None); return Ok(None);
}, },
graph_name: if let Some(graph_name) = graph_name: if let Some(graph_name) =
self.convert_graph_name_or_var(&quad.graph_name, variables, values, dataset)? Self::convert_graph_name_or_var(&quad.graph_name, variables, values, dataset)?
{ {
graph_name graph_name
} else { } else {
@ -400,7 +394,6 @@ impl<'a> SimpleUpdateEvaluator<'a> {
} }
fn convert_term_or_var( fn convert_term_or_var(
&self,
term: &TermPattern, term: &TermPattern,
variables: &[Variable], variables: &[Variable],
values: &EncodedTuple, values: &EncodedTuple,
@ -408,47 +401,43 @@ impl<'a> SimpleUpdateEvaluator<'a> {
bnodes: &mut HashMap<BlankNode, OxBlankNode>, bnodes: &mut HashMap<BlankNode, OxBlankNode>,
) -> Result<Option<OxTerm>, EvaluationError> { ) -> Result<Option<OxTerm>, EvaluationError> {
Ok(match term { Ok(match term {
TermPattern::NamedNode(term) => Some(self.convert_named_node(term).into()), TermPattern::NamedNode(term) => Some(Self::convert_named_node(term).into()),
TermPattern::BlankNode(bnode) => Some(self.convert_blank_node(bnode, bnodes).into()), TermPattern::BlankNode(bnode) => Some(Self::convert_blank_node(bnode, bnodes).into()),
TermPattern::Literal(term) => Some(self.convert_literal(term).into()), TermPattern::Literal(term) => Some(Self::convert_literal(term).into()),
TermPattern::Triple(triple) => self TermPattern::Triple(triple) => {
.convert_triple_pattern(triple, variables, values, dataset, bnodes)? Self::convert_triple_pattern(triple, variables, values, dataset, bnodes)?
.map(|t| t.into()), .map(|t| t.into())
TermPattern::Variable(v) => self }
.lookup_variable(v, variables, values) TermPattern::Variable(v) => Self::lookup_variable(v, variables, values)
.map(|node| dataset.decode_term(&node)) .map(|node| dataset.decode_term(&node))
.transpose()?, .transpose()?,
}) })
} }
fn convert_named_node_or_var( fn convert_named_node_or_var(
&self,
term: &NamedNodePattern, term: &NamedNodePattern,
variables: &[Variable], variables: &[Variable],
values: &EncodedTuple, values: &EncodedTuple,
dataset: &DatasetView, dataset: &DatasetView,
) -> Result<Option<OxNamedNode>, EvaluationError> { ) -> Result<Option<OxNamedNode>, EvaluationError> {
Ok(match term { Ok(match term {
NamedNodePattern::NamedNode(term) => Some(self.convert_named_node(term)), NamedNodePattern::NamedNode(term) => Some(Self::convert_named_node(term)),
NamedNodePattern::Variable(v) => self NamedNodePattern::Variable(v) => Self::lookup_variable(v, variables, values)
.lookup_variable(v, variables, values)
.map(|node| dataset.decode_named_node(&node)) .map(|node| dataset.decode_named_node(&node))
.transpose()?, .transpose()?,
}) })
} }
fn convert_graph_name_or_var( fn convert_graph_name_or_var(
&self,
term: &GraphNamePattern, term: &GraphNamePattern,
variables: &[Variable], variables: &[Variable],
values: &EncodedTuple, values: &EncodedTuple,
dataset: &DatasetView, dataset: &DatasetView,
) -> Result<Option<OxGraphName>, EvaluationError> { ) -> Result<Option<OxGraphName>, EvaluationError> {
match term { match term {
GraphNamePattern::NamedNode(term) => Ok(Some(self.convert_named_node(term).into())), GraphNamePattern::NamedNode(term) => Ok(Some(Self::convert_named_node(term).into())),
GraphNamePattern::DefaultGraph => Ok(Some(OxGraphName::DefaultGraph)), GraphNamePattern::DefaultGraph => Ok(Some(OxGraphName::DefaultGraph)),
GraphNamePattern::Variable(v) => self GraphNamePattern::Variable(v) => Self::lookup_variable(v, variables, values)
.lookup_variable(v, variables, values)
.map(|node| { .map(|node| {
Ok(if node == EncodedTerm::DefaultGraph { Ok(if node == EncodedTerm::DefaultGraph {
OxGraphName::DefaultGraph OxGraphName::DefaultGraph
@ -461,7 +450,6 @@ impl<'a> SimpleUpdateEvaluator<'a> {
} }
fn convert_triple_pattern( fn convert_triple_pattern(
&self,
triple: &TriplePattern, triple: &TriplePattern,
variables: &[Variable], variables: &[Variable],
values: &EncodedTuple, values: &EncodedTuple,
@ -469,7 +457,7 @@ impl<'a> SimpleUpdateEvaluator<'a> {
bnodes: &mut HashMap<BlankNode, OxBlankNode>, bnodes: &mut HashMap<BlankNode, OxBlankNode>,
) -> Result<Option<OxTriple>, EvaluationError> { ) -> Result<Option<OxTriple>, EvaluationError> {
Ok(Some(OxTriple { Ok(Some(OxTriple {
subject: match self.convert_term_or_var( subject: match Self::convert_term_or_var(
&triple.subject, &triple.subject,
variables, variables,
values, values,
@ -482,14 +470,14 @@ impl<'a> SimpleUpdateEvaluator<'a> {
Some(OxTerm::Literal(_)) | None => return Ok(None), Some(OxTerm::Literal(_)) | None => return Ok(None),
}, },
predicate: if let Some(predicate) = predicate: if let Some(predicate) =
self.convert_named_node_or_var(&triple.predicate, variables, values, dataset)? Self::convert_named_node_or_var(&triple.predicate, variables, values, dataset)?
{ {
predicate predicate
} else { } else {
return Ok(None); return Ok(None);
}, },
object: if let Some(object) = object: if let Some(object) =
self.convert_term_or_var(&triple.object, variables, values, dataset, bnodes)? Self::convert_term_or_var(&triple.object, variables, values, dataset, bnodes)?
{ {
object object
} else { } else {
@ -499,14 +487,13 @@ impl<'a> SimpleUpdateEvaluator<'a> {
} }
fn convert_ground_quad_pattern( fn convert_ground_quad_pattern(
&self,
quad: &GroundQuadPattern, quad: &GroundQuadPattern,
variables: &[Variable], variables: &[Variable],
values: &EncodedTuple, values: &EncodedTuple,
dataset: &DatasetView, dataset: &DatasetView,
) -> Result<Option<OxQuad>, EvaluationError> { ) -> Result<Option<OxQuad>, EvaluationError> {
Ok(Some(OxQuad { Ok(Some(OxQuad {
subject: match self.convert_ground_term_or_var( subject: match Self::convert_ground_term_or_var(
&quad.subject, &quad.subject,
variables, variables,
values, values,
@ -518,21 +505,21 @@ impl<'a> SimpleUpdateEvaluator<'a> {
Some(OxTerm::Literal(_)) | None => return Ok(None), Some(OxTerm::Literal(_)) | None => return Ok(None),
}, },
predicate: if let Some(predicate) = predicate: if let Some(predicate) =
self.convert_named_node_or_var(&quad.predicate, variables, values, dataset)? Self::convert_named_node_or_var(&quad.predicate, variables, values, dataset)?
{ {
predicate predicate
} else { } else {
return Ok(None); return Ok(None);
}, },
object: if let Some(object) = object: if let Some(object) =
self.convert_ground_term_or_var(&quad.object, variables, values, dataset)? Self::convert_ground_term_or_var(&quad.object, variables, values, dataset)?
{ {
object object
} else { } else {
return Ok(None); return Ok(None);
}, },
graph_name: if let Some(graph_name) = graph_name: if let Some(graph_name) =
self.convert_graph_name_or_var(&quad.graph_name, variables, values, dataset)? Self::convert_graph_name_or_var(&quad.graph_name, variables, values, dataset)?
{ {
graph_name graph_name
} else { } else {
@ -542,34 +529,32 @@ impl<'a> SimpleUpdateEvaluator<'a> {
} }
fn convert_ground_term_or_var( fn convert_ground_term_or_var(
&self,
term: &GroundTermPattern, term: &GroundTermPattern,
variables: &[Variable], variables: &[Variable],
values: &EncodedTuple, values: &EncodedTuple,
dataset: &DatasetView, dataset: &DatasetView,
) -> Result<Option<OxTerm>, EvaluationError> { ) -> Result<Option<OxTerm>, EvaluationError> {
Ok(match term { Ok(match term {
GroundTermPattern::NamedNode(term) => Some(self.convert_named_node(term).into()), GroundTermPattern::NamedNode(term) => Some(Self::convert_named_node(term).into()),
GroundTermPattern::Literal(term) => Some(self.convert_literal(term).into()), GroundTermPattern::Literal(term) => Some(Self::convert_literal(term).into()),
GroundTermPattern::Triple(triple) => self GroundTermPattern::Triple(triple) => {
.convert_ground_triple_pattern(triple, variables, values, dataset)? Self::convert_ground_triple_pattern(triple, variables, values, dataset)?
.map(|t| t.into()), .map(|t| t.into())
GroundTermPattern::Variable(v) => self }
.lookup_variable(v, variables, values) GroundTermPattern::Variable(v) => Self::lookup_variable(v, variables, values)
.map(|node| dataset.decode_term(&node)) .map(|node| dataset.decode_term(&node))
.transpose()?, .transpose()?,
}) })
} }
fn convert_ground_triple_pattern( fn convert_ground_triple_pattern(
&self,
triple: &GroundTriplePattern, triple: &GroundTriplePattern,
variables: &[Variable], variables: &[Variable],
values: &EncodedTuple, values: &EncodedTuple,
dataset: &DatasetView, dataset: &DatasetView,
) -> Result<Option<OxTriple>, EvaluationError> { ) -> Result<Option<OxTriple>, EvaluationError> {
Ok(Some(OxTriple { Ok(Some(OxTriple {
subject: match self.convert_ground_term_or_var( subject: match Self::convert_ground_term_or_var(
&triple.subject, &triple.subject,
variables, variables,
values, values,
@ -581,14 +566,14 @@ impl<'a> SimpleUpdateEvaluator<'a> {
Some(OxTerm::Literal(_)) | None => return Ok(None), Some(OxTerm::Literal(_)) | None => return Ok(None),
}, },
predicate: if let Some(predicate) = predicate: if let Some(predicate) =
self.convert_named_node_or_var(&triple.predicate, variables, values, dataset)? Self::convert_named_node_or_var(&triple.predicate, variables, values, dataset)?
{ {
predicate predicate
} else { } else {
return Ok(None); return Ok(None);
}, },
object: if let Some(object) = object: if let Some(object) =
self.convert_ground_term_or_var(&triple.object, variables, values, dataset)? Self::convert_ground_term_or_var(&triple.object, variables, values, dataset)?
{ {
object object
} else { } else {
@ -598,7 +583,6 @@ impl<'a> SimpleUpdateEvaluator<'a> {
} }
fn lookup_variable( fn lookup_variable(
&self,
v: &Variable, v: &Variable,
variables: &[Variable], variables: &[Variable],
values: &EncodedTuple, values: &EncodedTuple,

8
lib/src/sparql/xml_results.rs
Unescape View File

@ -235,7 +235,7 @@ pub fn read_xml_results(source: impl BufRead + 'static) -> io::Result<QueryResul
State::Head => { State::Head => {
if event.name() == b"variable" { if event.name() == b"variable" {
let name = event.attributes() let name = event.attributes()
.filter_map(|attr| attr.ok()) .filter_map(std::result::Result::ok)
.find(|attr| attr.key == b"name") .find(|attr| attr.key == b"name")
.ok_or_else(|| invalid_data_error("No name attribute found for the <variable> tag"))?; .ok_or_else(|| invalid_data_error("No name attribute found for the <variable> tag"))?;
variables.push(name.unescape_and_decode_value(&reader).map_err(map_xml_error)?); variables.push(name.unescape_and_decode_value(&reader).map_err(map_xml_error)?);
@ -283,7 +283,7 @@ pub fn read_xml_results(source: impl BufRead + 'static) -> io::Result<QueryResul
State::Head => { State::Head => {
if event.name() == b"variable" { if event.name() == b"variable" {
let name = event.attributes() let name = event.attributes()
.filter_map(|v| v.ok()) .filter_map(std::result::Result::ok)
.find(|attr| attr.key == b"name") .find(|attr| attr.key == b"name")
.ok_or_else(|| invalid_data_error("No name attribute found for the <variable> tag"))?; .ok_or_else(|| invalid_data_error("No name attribute found for the <variable> tag"))?;
variables.push(name.unescape_and_decode_value(&reader).map_err(map_xml_error)?); variables.push(name.unescape_and_decode_value(&reader).map_err(map_xml_error)?);
@ -405,7 +405,7 @@ impl<R: BufRead> ResultsIterator<R> {
if event.name() == b"binding" { if event.name() == b"binding" {
match event match event
.attributes() .attributes()
.filter_map(|v| v.ok()) .filter_map(std::result::Result::ok)
.find(|attr| attr.key == b"name") .find(|attr| attr.key == b"name")
{ {
Some(attr) => { Some(attr) => {
@ -614,7 +614,7 @@ impl<R: BufRead> ResultsIterator<R> {
); );
} }
} }
_ => (), State::End => (),
}, },
Event::Eof => return Ok(None), Event::Eof => return Ok(None),
_ => (), _ => (),

11
lib/src/storage/io.rs
Unescape View File

@ -9,7 +9,7 @@ use crate::storage::StorageLike;
use std::io; use std::io;
use std::io::{BufRead, Write}; use std::io::{BufRead, Write};
pub(crate) fn load_graph<S: StorageLike>( pub fn load_graph<S: StorageLike>(
store: &S, store: &S,
reader: impl BufRead, reader: impl BufRead,
format: GraphFormat, format: GraphFormat,
@ -49,7 +49,7 @@ pub fn dump_graph(
writer.finish() writer.finish()
} }
pub(crate) fn load_dataset<S: StorageLike>( pub fn load_dataset<S: StorageLike>(
store: &S, store: &S,
reader: impl BufRead, reader: impl BufRead,
format: DatasetFormat, format: DatasetFormat,
@ -89,11 +89,10 @@ pub enum StoreOrParseError<S> {
Parse(io::Error), Parse(io::Error),
} }
impl From<StoreOrParseError<io::Error>> for io::Error { impl From<StoreOrParseError<Self>> for io::Error {
fn from(error: StoreOrParseError<io::Error>) -> Self { fn from(error: StoreOrParseError<Self>) -> Self {
match error { match error {
StoreOrParseError::Store(error) => error, StoreOrParseError::Store(error) | StoreOrParseError::Parse(error) => error,
StoreOrParseError::Parse(error) => error,
} }
} }
} }

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

@ -23,9 +23,9 @@ use crate::storage::numeric_encoder::{EncodedQuad, EncodedTerm, StrHash, StrLook
use std::convert::TryInto; use std::convert::TryInto;
mod binary_encoder; mod binary_encoder;
pub(crate) mod io; pub mod io;
pub(crate) mod numeric_encoder; pub mod numeric_encoder;
pub(crate) mod small_string; pub mod small_string;
/// Low level storage primitives /// Low level storage primitives
#[derive(Clone)] #[derive(Clone)]
@ -430,43 +430,42 @@ impl Storage {
} }
fn spog_quads(&self, prefix: Vec<u8>) -> DecodingQuadIterator { fn spog_quads(&self, prefix: Vec<u8>) -> DecodingQuadIterator {
self.inner_quads(&self.spog, prefix, QuadEncoding::Spog) Self::inner_quads(&self.spog, prefix, QuadEncoding::Spog)
} }
fn posg_quads(&self, prefix: Vec<u8>) -> DecodingQuadIterator { fn posg_quads(&self, prefix: Vec<u8>) -> DecodingQuadIterator {
self.inner_quads(&self.posg, prefix, QuadEncoding::Posg) Self::inner_quads(&self.posg, prefix, QuadEncoding::Posg)
} }
fn ospg_quads(&self, prefix: Vec<u8>) -> DecodingQuadIterator { fn ospg_quads(&self, prefix: Vec<u8>) -> DecodingQuadIterator {
self.inner_quads(&self.ospg, prefix, QuadEncoding::Ospg) Self::inner_quads(&self.ospg, prefix, QuadEncoding::Ospg)
} }
fn gspo_quads(&self, prefix: Vec<u8>) -> DecodingQuadIterator { fn gspo_quads(&self, prefix: Vec<u8>) -> DecodingQuadIterator {
self.inner_quads(&self.gspo, prefix, QuadEncoding::Gspo) Self::inner_quads(&self.gspo, prefix, QuadEncoding::Gspo)
} }
fn gpos_quads(&self, prefix: Vec<u8>) -> DecodingQuadIterator { fn gpos_quads(&self, prefix: Vec<u8>) -> DecodingQuadIterator {
self.inner_quads(&self.gpos, prefix, QuadEncoding::Gpos) Self::inner_quads(&self.gpos, prefix, QuadEncoding::Gpos)
} }
fn gosp_quads(&self, prefix: Vec<u8>) -> DecodingQuadIterator { fn gosp_quads(&self, prefix: Vec<u8>) -> DecodingQuadIterator {
self.inner_quads(&self.gosp, prefix, QuadEncoding::Gosp) Self::inner_quads(&self.gosp, prefix, QuadEncoding::Gosp)
} }
fn dspo_quads(&self, prefix: Vec<u8>) -> DecodingQuadIterator { fn dspo_quads(&self, prefix: Vec<u8>) -> DecodingQuadIterator {
self.inner_quads(&self.dspo, prefix, QuadEncoding::Dspo) Self::inner_quads(&self.dspo, prefix, QuadEncoding::Dspo)
} }
fn dpos_quads(&self, prefix: Vec<u8>) -> DecodingQuadIterator { fn dpos_quads(&self, prefix: Vec<u8>) -> DecodingQuadIterator {
self.inner_quads(&self.dpos, prefix, QuadEncoding::Dpos) Self::inner_quads(&self.dpos, prefix, QuadEncoding::Dpos)
} }
fn dosp_quads(&self, prefix: Vec<u8>) -> DecodingQuadIterator { fn dosp_quads(&self, prefix: Vec<u8>) -> DecodingQuadIterator {
self.inner_quads(&self.dosp, prefix, QuadEncoding::Dosp) Self::inner_quads(&self.dosp, prefix, QuadEncoding::Dosp)
} }
fn inner_quads( fn inner_quads(
&self,
tree: &Tree, tree: &Tree,
prefix: impl AsRef<[u8]>, prefix: impl AsRef<[u8]>,
encoding: QuadEncoding, encoding: QuadEncoding,
@ -959,7 +958,7 @@ impl<T> From<Sled2TransactionError<T>> for TransactionError<T> {
} }
} }
impl<T: Into<std::io::Error>> From<TransactionError<T>> for std::io::Error { impl<T: Into<Self>> From<TransactionError<T>> for std::io::Error {
fn from(e: TransactionError<T>) -> Self { fn from(e: TransactionError<T>) -> Self {
match e { match e {
TransactionError::Abort(e) => e.into(), TransactionError::Abort(e) => e.into(),
@ -1005,8 +1004,8 @@ impl From<UnabortableTransactionError> for EvaluationError {
} }
} }
impl From<StoreOrParseError<UnabortableTransactionError>> for UnabortableTransactionError { impl From<StoreOrParseError<Self>> for UnabortableTransactionError {
fn from(e: StoreOrParseError<UnabortableTransactionError>) -> Self { fn from(e: StoreOrParseError<Self>) -> Self {
match e { match e {
StoreOrParseError::Store(e) => e, StoreOrParseError::Store(e) => e,
StoreOrParseError::Parse(e) => Self::Storage(e), StoreOrParseError::Parse(e) => Self::Storage(e),
@ -1066,11 +1065,9 @@ impl<T> From<UnabortableTransactionError> for ConflictableTransactionError<T> {
impl<T> From<ConflictableTransactionError<T>> for Sled2ConflictableTransactionError<T> { impl<T> From<ConflictableTransactionError<T>> for Sled2ConflictableTransactionError<T> {
fn from(e: ConflictableTransactionError<T>) -> Self { fn from(e: ConflictableTransactionError<T>) -> Self {
match e { match e {
ConflictableTransactionError::Abort(e) => Sled2ConflictableTransactionError::Abort(e), ConflictableTransactionError::Abort(e) => Self::Abort(e),
ConflictableTransactionError::Conflict => Sled2ConflictableTransactionError::Conflict, ConflictableTransactionError::Conflict => Self::Conflict,
ConflictableTransactionError::Storage(e) => { ConflictableTransactionError::Storage(e) => Self::Storage(e.into()),
Sled2ConflictableTransactionError::Storage(e.into())
}
} }
} }
} }
@ -1163,7 +1160,7 @@ impl<'a> TermEncoder for StorageTransaction<'a> {
} }
} }
pub(crate) trait StorageLike: StrLookup { pub trait StorageLike: StrLookup {
fn insert(&self, quad: QuadRef<'_>) -> Result<bool, Self::Error>; fn insert(&self, quad: QuadRef<'_>) -> Result<bool, Self::Error>;
fn remove(&self, quad: QuadRef<'_>) -> Result<bool, Self::Error>; fn remove(&self, quad: QuadRef<'_>) -> Result<bool, Self::Error>;

41
lib/src/storage/numeric_encoder.rs
Unescape View File

@ -465,20 +465,20 @@ impl From<LiteralRef<'_>> for EncodedTerm {
literal.language().map(|language| { literal.language().map(|language| {
if let Ok(value) = SmallString::try_from(value) { if let Ok(value) = SmallString::try_from(value) {
if let Ok(language) = SmallString::try_from(language) { if let Ok(language) = SmallString::try_from(language) {
EncodedTerm::SmallSmallLangStringLiteral { value, language } Self::SmallSmallLangStringLiteral { value, language }
} else { } else {
EncodedTerm::SmallBigLangStringLiteral { Self::SmallBigLangStringLiteral {
value, value,
language_id: StrHash::new(language), language_id: StrHash::new(language),
} }
} }
} else if let Ok(language) = SmallString::try_from(language) { } else if let Ok(language) = SmallString::try_from(language) {
EncodedTerm::BigSmallLangStringLiteral { Self::BigSmallLangStringLiteral {
value_id: StrHash::new(value), value_id: StrHash::new(value),
language, language,
} }
} else { } else {
EncodedTerm::BigBigLangStringLiteral { Self::BigBigLangStringLiteral {
value_id: StrHash::new(value), value_id: StrHash::new(value),
language_id: StrHash::new(language), language_id: StrHash::new(language),
} }
@ -489,9 +489,9 @@ impl From<LiteralRef<'_>> for EncodedTerm {
"http://www.w3.org/2001/XMLSchema#string" => { "http://www.w3.org/2001/XMLSchema#string" => {
let value = value; let value = value;
Some(if let Ok(value) = SmallString::try_from(value) { Some(if let Ok(value) = SmallString::try_from(value) {
EncodedTerm::SmallStringLiteral(value) Self::SmallStringLiteral(value)
} else { } else {
EncodedTerm::BigStringLiteral { Self::BigStringLiteral {
value_id: StrHash::new(value), value_id: StrHash::new(value),
} }
}) })
@ -534,12 +534,12 @@ impl From<LiteralRef<'_>> for EncodedTerm {
Some(term) => term, Some(term) => term,
None => { None => {
if let Ok(value) = SmallString::try_from(value) { if let Ok(value) = SmallString::try_from(value) {
EncodedTerm::SmallTypedLiteral { Self::SmallTypedLiteral {
value, value,
datatype_id: StrHash::new(datatype), datatype_id: StrHash::new(datatype),
} }
} else { } else {
EncodedTerm::BigTypedLiteral { Self::BigTypedLiteral {
value_id: StrHash::new(value), value_id: StrHash::new(value),
datatype_id: StrHash::new(datatype), datatype_id: StrHash::new(datatype),
} }
@ -584,14 +584,14 @@ impl From<GraphNameRef<'_>> for EncodedTerm {
match name { match name {
GraphNameRef::NamedNode(named_node) => named_node.into(), GraphNameRef::NamedNode(named_node) => named_node.into(),
GraphNameRef::BlankNode(blank_node) => blank_node.into(), GraphNameRef::BlankNode(blank_node) => blank_node.into(),
GraphNameRef::DefaultGraph => EncodedTerm::DefaultGraph, GraphNameRef::DefaultGraph => Self::DefaultGraph,
} }
} }
} }
impl From<TripleRef<'_>> for EncodedTerm { impl From<TripleRef<'_>> for EncodedTerm {
fn from(triple: TripleRef<'_>) -> Self { fn from(triple: TripleRef<'_>) -> Self {
EncodedTerm::Triple(Rc::new(triple.into())) Self::Triple(Rc::new(triple.into()))
} }
} }
@ -614,7 +614,7 @@ impl EncodedTriple {
impl From<TripleRef<'_>> for EncodedTriple { impl From<TripleRef<'_>> for EncodedTriple {
fn from(triple: TripleRef<'_>) -> Self { fn from(triple: TripleRef<'_>) -> Self {
EncodedTriple { Self {
subject: triple.subject.into(), subject: triple.subject.into(),
predicate: triple.predicate.into(), predicate: triple.predicate.into(),
object: triple.object.into(), object: triple.object.into(),
@ -648,7 +648,7 @@ impl EncodedQuad {
impl From<QuadRef<'_>> for EncodedQuad { impl From<QuadRef<'_>> for EncodedQuad {
fn from(quad: QuadRef<'_>) -> Self { fn from(quad: QuadRef<'_>) -> Self {
EncodedQuad { Self {
subject: quad.subject.into(), subject: quad.subject.into(),
predicate: quad.predicate.into(), predicate: quad.predicate.into(),
object: quad.object.into(), object: quad.object.into(),
@ -723,15 +723,16 @@ pub fn insert_term_values<E, F: Fn(&StrHash, &str) -> Result<(), E> + Copy>(
(TermRef::BlankNode(node), EncodedTerm::BigBlankNode { id_id }) => { (TermRef::BlankNode(node), EncodedTerm::BigBlankNode { id_id }) => {
insert_str(id_id, node.as_str())?; insert_str(id_id, node.as_str())?;
} }
(TermRef::Literal(literal), EncodedTerm::BigStringLiteral { value_id }) => {
insert_str(value_id, literal.value())?;
}
(TermRef::Literal(literal), EncodedTerm::SmallBigLangStringLiteral { language_id, .. }) => { (TermRef::Literal(literal), EncodedTerm::SmallBigLangStringLiteral { language_id, .. }) => {
if let Some(language) = literal.language() { if let Some(language) = literal.language() {
insert_str(language_id, language)?; insert_str(language_id, language)?;
} }
} }
(TermRef::Literal(literal), EncodedTerm::BigSmallLangStringLiteral { value_id, .. }) => { (
TermRef::Literal(literal),
EncodedTerm::BigSmallLangStringLiteral { value_id, .. }
| EncodedTerm::BigStringLiteral { value_id },
) => {
insert_str(value_id, literal.value())?; insert_str(value_id, literal.value())?;
} }
( (
@ -784,15 +785,13 @@ pub fn remove_term_values<E, F: Fn(&StrHash) -> Result<(), E> + Copy>(
EncodedTerm::BigBlankNode { id_id } => { EncodedTerm::BigBlankNode { id_id } => {
remove_str(id_id)?; remove_str(id_id)?;
} }
EncodedTerm::BigStringLiteral { value_id } => { EncodedTerm::BigStringLiteral { value_id }
| EncodedTerm::BigSmallLangStringLiteral { value_id, .. } => {
remove_str(value_id)?; remove_str(value_id)?;
} }
EncodedTerm::SmallBigLangStringLiteral { language_id, .. } => { EncodedTerm::SmallBigLangStringLiteral { language_id, .. } => {
remove_str(language_id)?; remove_str(language_id)?;
} }
EncodedTerm::BigSmallLangStringLiteral { value_id, .. } => {
remove_str(value_id)?;
}
EncodedTerm::BigBigLangStringLiteral { EncodedTerm::BigBigLangStringLiteral {
value_id, value_id,
language_id, language_id,
@ -1094,7 +1093,7 @@ impl<E: Error + 'static> Error for DecoderError<E> {
} }
} }
impl<E: Into<io::Error>> From<DecoderError<E>> for io::Error { impl<E: Into<Self>> From<DecoderError<E>> for io::Error {
fn from(e: DecoderError<E>) -> Self { fn from(e: DecoderError<E>) -> Self {
match e { match e {
DecoderError::Store(e) => e.into(), DecoderError::Store(e) => e.into(),

6
lib/src/storage/small_string.rs
Unescape View File

@ -23,12 +23,12 @@ impl SmallString {
} }
#[inline] #[inline]
pub fn from_utf8(bytes: &[u8]) -> Result<SmallString, BadSmallStringError> { pub fn from_utf8(bytes: &[u8]) -> Result<Self, BadSmallStringError> {
Self::from_str(str::from_utf8(bytes).map_err(BadSmallStringError::BadUtf8)?) Self::from_str(str::from_utf8(bytes).map_err(BadSmallStringError::BadUtf8)?)
} }
#[inline] #[inline]
pub fn from_be_bytes(bytes: [u8; 16]) -> Result<SmallString, BadSmallStringError> { pub fn from_be_bytes(bytes: [u8; 16]) -> Result<Self, BadSmallStringError> {
// We check that it is valid UTF-8 // We check that it is valid UTF-8
str::from_utf8(&bytes.as_ref()[..bytes[15].into()]) str::from_utf8(&bytes.as_ref()[..bytes[15].into()])
.map_err(BadSmallStringError::BadUtf8)?; .map_err(BadSmallStringError::BadUtf8)?;
@ -105,7 +105,7 @@ impl fmt::Display for SmallString {
impl PartialEq for SmallString { impl PartialEq for SmallString {
#[inline] #[inline]
fn eq(&self, other: &Self) -> bool { fn eq(&self, other: &Self) -> bool {
self.as_str().eq(other.deref()) self.as_str().eq(&**other)
} }
} }

6
lib/src/store.rs
Unescape View File

@ -230,7 +230,7 @@ impl Store {
) -> Result<(), EvaluationError> { ) -> Result<(), EvaluationError> {
evaluate_update( evaluate_update(
&self.storage, &self.storage,
update.try_into().map_err(|e| e.into())?, update.try_into().map_err(std::convert::Into::into)?,
options, options,
) )
} }
@ -880,7 +880,7 @@ fn store() -> io::Result<()> {
Quad::new( Quad::new(
main_s.clone(), main_s.clone(),
main_p.clone(), main_p.clone(),
Literal::from(200000000), Literal::from(200_000_000),
GraphName::DefaultGraph, GraphName::DefaultGraph,
), ),
]; ];
@ -895,7 +895,7 @@ fn store() -> io::Result<()> {
Quad::new( Quad::new(
main_s.clone(), main_s.clone(),
main_p.clone(), main_p.clone(),
Literal::from(200000000), Literal::from(200_000_000),
GraphName::DefaultGraph, GraphName::DefaultGraph,
), ),
named_quad.clone(), named_quad.clone(),

2
server/src/main.rs
Unescape View File

@ -63,7 +63,7 @@ pub async fn main() -> Result<()> {
}?; }?;
println!("Listening for requests at http://{}", &bind); println!("Listening for requests at http://{}", &bind);
http_server(&bind, move |request| handle_request(request, store.clone())).await http_server(bind, move |request| handle_request(request, store.clone())).await
} }
async fn handle_request(request: Request, store: Store) -> Result<Response> { async fn handle_request(request: Request, store: Store) -> Result<Response> {

2
spargebra/Cargo.toml
Unescape View File

@ -5,7 +5,7 @@ authors = ["Tpt <thomas@pellissier-tanon.fr>"]
license = "MIT OR Apache-2.0" license = "MIT OR Apache-2.0"
readme = "README.md" readme = "README.md"
keywords = ["SPARQL"] keywords = ["SPARQL"]
repository = "https://github.com/oxigraph/oxigraph/tree/master/spargebra" repository = "https://github.com/oxigraph/oxigraph/tree/v0.3/spargebra"
homepage = "https://oxigraph.org/" homepage = "https://oxigraph.org/"
description = """ description = """
A SPARQL parser A SPARQL parser

106
spargebra/src/algebra.rs
Unescape View File

@ -9,12 +9,12 @@ use std::fmt;
#[derive(Eq, PartialEq, Debug, Clone, Hash)] #[derive(Eq, PartialEq, Debug, Clone, Hash)]
pub enum PropertyPathExpression { pub enum PropertyPathExpression {
NamedNode(NamedNode), NamedNode(NamedNode),
Reverse(Box<PropertyPathExpression>), Reverse(Box<Self>),
Sequence(Box<PropertyPathExpression>, Box<PropertyPathExpression>), Sequence(Box<Self>, Box<Self>),
Alternative(Box<PropertyPathExpression>, Box<PropertyPathExpression>), Alternative(Box<Self>, Box<Self>),
ZeroOrMore(Box<PropertyPathExpression>), ZeroOrMore(Box<Self>),
OneOrMore(Box<PropertyPathExpression>), OneOrMore(Box<Self>),
ZeroOrOne(Box<PropertyPathExpression>), ZeroOrOne(Box<Self>),
NegatedPropertySet(Vec<NamedNode>), NegatedPropertySet(Vec<NamedNode>),
} }
@ -75,7 +75,7 @@ impl<'a> fmt::Display for SparqlPropertyPath<'a> {
impl From<NamedNode> for PropertyPathExpression { impl From<NamedNode> for PropertyPathExpression {
fn from(p: NamedNode) -> Self { fn from(p: NamedNode) -> Self {
PropertyPathExpression::NamedNode(p) Self::NamedNode(p)
} }
} }
@ -86,45 +86,45 @@ pub enum Expression {
Literal(Literal), Literal(Literal),
Variable(Variable), Variable(Variable),
/// [Logical-or](https://www.w3.org/TR/sparql11-query/#func-logical-or) /// [Logical-or](https://www.w3.org/TR/sparql11-query/#func-logical-or)
Or(Box<Expression>, Box<Expression>), Or(Box<Self>, Box<Self>),
/// [Logical-and](https://www.w3.org/TR/sparql11-query/#func-logical-and) /// [Logical-and](https://www.w3.org/TR/sparql11-query/#func-logical-and)
And(Box<Expression>, Box<Expression>), And(Box<Self>, Box<Self>),
/// [RDFterm-equal](https://www.w3.org/TR/sparql11-query/#func-RDFterm-equal) and all the XSD equalities /// [RDFterm-equal](https://www.w3.org/TR/sparql11-query/#func-RDFterm-equal) and all the XSD equalities
Equal(Box<Expression>, Box<Expression>), Equal(Box<Self>, Box<Self>),
/// [sameTerm](https://www.w3.org/TR/sparql11-query/#func-sameTerm) /// [sameTerm](https://www.w3.org/TR/sparql11-query/#func-sameTerm)
SameTerm(Box<Expression>, Box<Expression>), SameTerm(Box<Self>, Box<Self>),
/// [op:numeric-greater-than](https://www.w3.org/TR/xpath-functions/#func-numeric-greater-than) and other XSD greater than operators /// [op:numeric-greater-than](https://www.w3.org/TR/xpath-functions/#func-numeric-greater-than) and other XSD greater than operators
Greater(Box<Expression>, Box<Expression>), Greater(Box<Self>, Box<Self>),
GreaterOrEqual(Box<Expression>, Box<Expression>), GreaterOrEqual(Box<Self>, Box<Self>),
/// [op:numeric-less-than](https://www.w3.org/TR/xpath-functions/#func-numeric-less-than) and other XSD greater than operators /// [op:numeric-less-than](https://www.w3.org/TR/xpath-functions/#func-numeric-less-than) and other XSD greater than operators
Less(Box<Expression>, Box<Expression>), Less(Box<Self>, Box<Self>),
LessOrEqual(Box<Expression>, Box<Expression>), LessOrEqual(Box<Self>, Box<Self>),
/// [IN](https://www.w3.org/TR/sparql11-query/#func-in) /// [IN](https://www.w3.org/TR/sparql11-query/#func-in)
In(Box<Expression>, Vec<Expression>), In(Box<Self>, Vec<Self>),
/// [op:numeric-add](https://www.w3.org/TR/xpath-functions/#func-numeric-add) and other XSD additions /// [op:numeric-add](https://www.w3.org/TR/xpath-functions/#func-numeric-add) and other XSD additions
Add(Box<Expression>, Box<Expression>), Add(Box<Self>, Box<Self>),
/// [op:numeric-subtract](https://www.w3.org/TR/xpath-functions/#func-numeric-subtract) and other XSD subtractions /// [op:numeric-subtract](https://www.w3.org/TR/xpath-functions/#func-numeric-subtract) and other XSD subtractions
Subtract(Box<Expression>, Box<Expression>), Subtract(Box<Self>, Box<Self>),
/// [op:numeric-multiply](https://www.w3.org/TR/xpath-functions/#func-numeric-multiply) and other XSD multiplications /// [op:numeric-multiply](https://www.w3.org/TR/xpath-functions/#func-numeric-multiply) and other XSD multiplications
Multiply(Box<Expression>, Box<Expression>), Multiply(Box<Self>, Box<Self>),
/// [op:numeric-divide](https://www.w3.org/TR/xpath-functions/#func-numeric-divide) and other XSD divides /// [op:numeric-divide](https://www.w3.org/TR/xpath-functions/#func-numeric-divide) and other XSD divides
Divide(Box<Expression>, Box<Expression>), Divide(Box<Self>, Box<Self>),
/// [op:numeric-unary-plus](https://www.w3.org/TR/xpath-functions/#func-numeric-unary-plus) and other XSD unary plus /// [op:numeric-unary-plus](https://www.w3.org/TR/xpath-functions/#func-numeric-unary-plus) and other XSD unary plus
UnaryPlus(Box<Expression>), UnaryPlus(Box<Self>),
/// [op:numeric-unary-minus](https://www.w3.org/TR/xpath-functions/#func-numeric-unary-minus) and other XSD unary minus /// [op:numeric-unary-minus](https://www.w3.org/TR/xpath-functions/#func-numeric-unary-minus) and other XSD unary minus
UnaryMinus(Box<Expression>), UnaryMinus(Box<Self>),
/// [fn:not](https://www.w3.org/TR/xpath-functions/#func-not) /// [fn:not](https://www.w3.org/TR/xpath-functions/#func-not)
Not(Box<Expression>), Not(Box<Self>),
/// [EXISTS](https://www.w3.org/TR/sparql11-query/#func-filter-exists) /// [EXISTS](https://www.w3.org/TR/sparql11-query/#func-filter-exists)
Exists(Box<GraphPattern>), Exists(Box<GraphPattern>),
/// [BOUND](https://www.w3.org/TR/sparql11-query/#func-bound) /// [BOUND](https://www.w3.org/TR/sparql11-query/#func-bound)
Bound(Variable), Bound(Variable),
/// [IF](https://www.w3.org/TR/sparql11-query/#func-if) /// [IF](https://www.w3.org/TR/sparql11-query/#func-if)
If(Box<Expression>, Box<Expression>, Box<Expression>), If(Box<Self>, Box<Self>, Box<Self>),
/// [COALESCE](https://www.w3.org/TR/sparql11-query/#func-coalesce) /// [COALESCE](https://www.w3.org/TR/sparql11-query/#func-coalesce)
Coalesce(Vec<Expression>), Coalesce(Vec<Self>),
/// A regular function call /// A regular function call
FunctionCall(Function, Vec<Expression>), FunctionCall(Function, Vec<Self>),
} }
impl fmt::Display for Expression { impl fmt::Display for Expression {
@ -178,19 +178,19 @@ impl fmt::Display for Expression {
impl From<NamedNode> for Expression { impl From<NamedNode> for Expression {
fn from(p: NamedNode) -> Self { fn from(p: NamedNode) -> Self {
Expression::NamedNode(p) Self::NamedNode(p)
} }
} }
impl From<Literal> for Expression { impl From<Literal> for Expression {
fn from(p: Literal) -> Self { fn from(p: Literal) -> Self {
Expression::Literal(p) Self::Literal(p)
} }
} }
impl From<Variable> for Expression { impl From<Variable> for Expression {
fn from(v: Variable) -> Self { fn from(v: Variable) -> Self {
Expression::Variable(v) Self::Variable(v)
} }
} }
@ -450,41 +450,29 @@ pub enum GraphPattern {
object: TermPattern, object: TermPattern,
}, },
/// [Join](https://www.w3.org/TR/sparql11-query/#defn_algJoin) /// [Join](https://www.w3.org/TR/sparql11-query/#defn_algJoin)
Join { Join { left: Box<Self>, right: Box<Self> },
left: Box<GraphPattern>,
right: Box<GraphPattern>,
},
/// [LeftJoin](https://www.w3.org/TR/sparql11-query/#defn_algLeftJoin) /// [LeftJoin](https://www.w3.org/TR/sparql11-query/#defn_algLeftJoin)
LeftJoin { LeftJoin {
left: Box<GraphPattern>, left: Box<Self>,
right: Box<GraphPattern>, right: Box<Self>,
expr: Option<Expression>, expr: Option<Expression>,
}, },
/// [Filter](https://www.w3.org/TR/sparql11-query/#defn_algFilter) /// [Filter](https://www.w3.org/TR/sparql11-query/#defn_algFilter)
Filter { Filter { expr: Expression, inner: Box<Self> },
expr: Expression,
inner: Box<GraphPattern>,
},
/// [Union](https://www.w3.org/TR/sparql11-query/#defn_algUnion) /// [Union](https://www.w3.org/TR/sparql11-query/#defn_algUnion)
Union { Union { left: Box<Self>, right: Box<Self> },
left: Box<GraphPattern>,
right: Box<GraphPattern>,
},
Graph { Graph {
graph_name: NamedNodePattern, graph_name: NamedNodePattern,
inner: Box<GraphPattern>, inner: Box<Self>,
}, },
/// [Extend](https://www.w3.org/TR/sparql11-query/#defn_extend) /// [Extend](https://www.w3.org/TR/sparql11-query/#defn_extend)
Extend { Extend {
inner: Box<GraphPattern>, inner: Box<Self>,
var: Variable, var: Variable,
expr: Expression, expr: Expression,
}, },
/// [Minus](https://www.w3.org/TR/sparql11-query/#defn_algMinus) /// [Minus](https://www.w3.org/TR/sparql11-query/#defn_algMinus)
Minus { Minus { left: Box<Self>, right: Box<Self> },
left: Box<GraphPattern>,
right: Box<GraphPattern>,
},
/// A table used to provide inline values /// A table used to provide inline values
Table { Table {
variables: Vec<Variable>, variables: Vec<Variable>,
@ -492,34 +480,34 @@ pub enum GraphPattern {
}, },
/// [OrderBy](https://www.w3.org/TR/sparql11-query/#defn_algOrdered) /// [OrderBy](https://www.w3.org/TR/sparql11-query/#defn_algOrdered)
OrderBy { OrderBy {
inner: Box<GraphPattern>, inner: Box<Self>,
condition: Vec<OrderComparator>, condition: Vec<OrderComparator>,
}, },
/// [Project](https://www.w3.org/TR/sparql11-query/#defn_algProjection) /// [Project](https://www.w3.org/TR/sparql11-query/#defn_algProjection)
Project { Project {
inner: Box<GraphPattern>, inner: Box<Self>,
projection: Vec<Variable>, projection: Vec<Variable>,
}, },
/// [Distinct](https://www.w3.org/TR/sparql11-query/#defn_algDistinct) /// [Distinct](https://www.w3.org/TR/sparql11-query/#defn_algDistinct)
Distinct { inner: Box<GraphPattern> }, Distinct { inner: Box<Self> },
/// [Reduced](https://www.w3.org/TR/sparql11-query/#defn_algReduced) /// [Reduced](https://www.w3.org/TR/sparql11-query/#defn_algReduced)
Reduced { inner: Box<GraphPattern> }, Reduced { inner: Box<Self> },
/// [Slice](https://www.w3.org/TR/sparql11-query/#defn_algSlice) /// [Slice](https://www.w3.org/TR/sparql11-query/#defn_algSlice)
Slice { Slice {
inner: Box<GraphPattern>, inner: Box<Self>,
start: usize, start: usize,
length: Option<usize>, length: Option<usize>,
}, },
/// [Group](https://www.w3.org/TR/sparql11-federated-query/#aggregateAlgebra) /// [Group](https://www.w3.org/TR/sparql11-federated-query/#aggregateAlgebra)
Group { Group {
inner: Box<GraphPattern>, inner: Box<Self>,
by: Vec<Variable>, by: Vec<Variable>,
aggregates: Vec<(Variable, AggregationFunction)>, aggregates: Vec<(Variable, AggregationFunction)>,
}, },
/// [Service](https://www.w3.org/TR/sparql11-federated-query/#defn_evalService) /// [Service](https://www.w3.org/TR/sparql11-federated-query/#defn_evalService)
Service { Service {
name: NamedNodePattern, name: NamedNodePattern,
pattern: Box<GraphPattern>, pattern: Box<Self>,
silent: bool, silent: bool,
}, },
} }
@ -643,7 +631,7 @@ impl fmt::Display for GraphPattern {
impl Default for GraphPattern { impl Default for GraphPattern {
fn default() -> Self { fn default() -> Self {
GraphPattern::Bgp(Vec::default()) Self::Bgp(Vec::default())
} }
} }
@ -685,7 +673,6 @@ impl GraphPattern {
left.add_visible_variables(vars); left.add_visible_variables(vars);
right.add_visible_variables(vars); right.add_visible_variables(vars);
} }
GraphPattern::Filter { inner, .. } => inner.add_visible_variables(vars),
GraphPattern::Graph { graph_name, inner } => { GraphPattern::Graph { graph_name, inner } => {
if let NamedNodePattern::Variable(ref g) = graph_name { if let NamedNodePattern::Variable(ref g) = graph_name {
vars.insert(g); vars.insert(g);
@ -706,7 +693,8 @@ impl GraphPattern {
} }
GraphPattern::Table { variables, .. } => vars.extend(variables), GraphPattern::Table { variables, .. } => vars.extend(variables),
GraphPattern::Project { projection, .. } => vars.extend(projection.iter()), GraphPattern::Project { projection, .. } => vars.extend(projection.iter()),
GraphPattern::OrderBy { inner, .. } GraphPattern::Filter { inner, .. }
| GraphPattern::OrderBy { inner, .. }
| GraphPattern::Distinct { inner } | GraphPattern::Distinct { inner }
| GraphPattern::Reduced { inner } | GraphPattern::Reduced { inner }
| GraphPattern::Slice { inner, .. } => inner.add_visible_variables(vars), | GraphPattern::Slice { inner, .. } => inner.add_visible_variables(vars),

8
spargebra/src/parser.rs
Unescape View File

@ -126,7 +126,7 @@ enum VariableOrPropertyPath {
impl From<Variable> for VariableOrPropertyPath { impl From<Variable> for VariableOrPropertyPath {
fn from(var: Variable) -> Self { fn from(var: Variable) -> Self {
VariableOrPropertyPath::Variable(var) Self::Variable(var)
} }
} }
@ -141,7 +141,7 @@ impl From<NamedNodePattern> for VariableOrPropertyPath {
impl From<PropertyPathExpression> for VariableOrPropertyPath { impl From<PropertyPathExpression> for VariableOrPropertyPath {
fn from(path: PropertyPathExpression) -> Self { fn from(path: PropertyPathExpression) -> Self {
VariableOrPropertyPath::PropertyPath(path) Self::PropertyPath(path)
} }
} }
@ -287,7 +287,7 @@ enum TripleOrPathPattern {
impl From<TriplePattern> for TripleOrPathPattern { impl From<TriplePattern> for TripleOrPathPattern {
fn from(tp: TriplePattern) -> Self { fn from(tp: TriplePattern) -> Self {
TripleOrPathPattern::Triple(tp) Self::Triple(tp)
} }
} }
@ -306,7 +306,7 @@ impl From<AnnotatedTerm> for AnnotatedTermPath {
.map(|(p, o)| { .map(|(p, o)| {
( (
p.into(), p.into(),
o.into_iter().map(AnnotatedTermPath::from).collect(), o.into_iter().map(Self::from).collect(),
) )
}) })
.collect(), .collect(),

4
spargebra/src/term.rs
Unescape View File

@ -537,7 +537,7 @@ impl TryFrom<GraphNamePattern> for GraphName {
fn try_from(pattern: GraphNamePattern) -> Result<Self, ()> { fn try_from(pattern: GraphNamePattern) -> Result<Self, ()> {
match pattern { match pattern {
GraphNamePattern::NamedNode(t) => Ok(t.into()), GraphNamePattern::NamedNode(t) => Ok(t.into()),
GraphNamePattern::DefaultGraph => Ok(GraphName::DefaultGraph), GraphNamePattern::DefaultGraph => Ok(Self::DefaultGraph),
GraphNamePattern::Variable(_) => Err(()), GraphNamePattern::Variable(_) => Err(()),
} }
} }
@ -1099,7 +1099,7 @@ impl TryFrom<QuadPattern> for GroundQuadPattern {
#[inline] #[inline]
fn try_from(pattern: QuadPattern) -> Result<Self, ()> { fn try_from(pattern: QuadPattern) -> Result<Self, ()> {
Ok(GroundQuadPattern { Ok(Self {
subject: pattern.subject.try_into()?, subject: pattern.subject.try_into()?,
predicate: pattern.predicate, predicate: pattern.predicate,
object: pattern.object.try_into()?, object: pattern.object.try_into()?,

8
wikibase/src/main.rs
Unescape View File

@ -95,7 +95,7 @@ pub async fn main() -> Result<()> {
} }
}) })
.collect::<Vec<_>>(); .collect::<Vec<_>>();
let slot = matches.value_of("slot").clone(); let slot = matches.value_of("slot");
let store = if let Some(file) = file { let store = if let Some(file) = file {
Store::open(file) Store::open(file)
@ -105,8 +105,8 @@ pub async fn main() -> Result<()> {
let repo = store.clone(); let repo = store.clone();
let mut loader = WikibaseLoader::new( let mut loader = WikibaseLoader::new(
repo, repo,
&mediawiki_api, mediawiki_api,
&mediawiki_base_url, mediawiki_base_url,
&namespaces, &namespaces,
slot.as_deref(), slot.as_deref(),
Duration::new(10, 0), Duration::new(10, 0),
@ -119,7 +119,7 @@ pub async fn main() -> Result<()> {
println!("Listening for requests at http://{}", &bind); println!("Listening for requests at http://{}", &bind);
http_server(&bind, move |request| handle_request(request, store.clone())).await http_server(bind, move |request| handle_request(request, store.clone())).await
} }
async fn handle_request(request: Request, store: Store) -> Result<Response> { async fn handle_request(request: Request, store: Store) -> Result<Response> {

Write Preview
Loading…
Cancel
Save