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

Improves Clippy lint list

Browse Source
pull/489/head
Tpt 2 years ago committed by Thomas Tanon
parent a2d8bcaaa3
commit 7175784356
35 changed files with 457 additions and 469 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. 68
      .cargo/config.toml
  2. 2
      js/src/model.rs
  3. 8
      js/src/store.rs
  4. 4
      lib/oxrdf/src/dataset.rs
  5. 9
      lib/oxrdf/src/interning.rs
  6. 1
      lib/oxrdf/src/lib.rs
  7. 2
      lib/oxsdatatypes/src/decimal.rs
  8. 6
      lib/oxsdatatypes/src/duration.rs
  9. 10
      lib/oxsdatatypes/src/integer.rs
  10. 2
      lib/oxsdatatypes/src/lib.rs
  11. 14
      lib/sparesults/src/csv.rs
  12. 4
      lib/sparesults/src/lib.rs
  13. 3
      lib/sparesults/src/solution.rs
  14. 22
      lib/sparesults/src/xml.rs
  15. 1
      lib/spargebra/src/lib.rs
  16. 19
      lib/spargebra/src/parser.rs
  17. 12
      lib/src/io/error.rs
  18. 2
      lib/src/lib.rs
  19. 2
      lib/src/sparql/dataset.rs
  20. 366
      lib/src/sparql/eval.rs
  21. 7
      lib/src/sparql/model.rs
  22. 26
      lib/src/sparql/plan.rs
  23. 165
      lib/src/sparql/plan_builder.rs
  24. 17
      lib/src/sparql/update.rs
  25. 27
      lib/src/storage/backend/fallback.rs
  26. 60
      lib/src/storage/backend/rocksdb.rs
  27. 5
      lib/src/storage/mod.rs
  28. 4
      lib/src/store.rs
  29. 2
      lib/tests/store.rs
  30. 12
      python/src/io.rs
  31. 2
      python/src/sparql.rs
  32. 8
      python/src/store.rs
  33. 6
      server/src/main.rs
  34. 2
      testsuite/src/manifest.rs
  35. 26
      testsuite/src/sparql_evaluator.rs

68
.cargo/config.toml
Unescape View File

@ -2,94 +2,124 @@
rustflags = [ rustflags = [
"-Wtrivial-casts", "-Wtrivial-casts",
"-Wtrivial-numeric-casts", "-Wtrivial-numeric-casts",
"-Wunsafe_code", "-Wunsafe-code",
"-Wunused-lifetimes", "-Wunused-lifetimes",
"-Wunused-qualifications", "-Wunused-qualifications",
# TODO: 1.63+ "-Wclippy::as-underscore",
# TODO: 1.65+ ""-Wclippy::bool-to-int-with-if",
"-Wclippy::borrow-as-ptr",
"-Wclippy::case-sensitive-file-extension-comparisons",
"-Wclippy::cast-lossless", "-Wclippy::cast-lossless",
"-Wclippy::cast-possible-truncation", "-Wclippy::cast-possible-truncation",
"-Wclippy::cast-possible-wrap", "-Wclippy::cast-possible-wrap",
"-Wclippy::cast-precision-loss", "-Wclippy::cast-precision-loss",
"-Wclippy::cast-ptr-alignment",
"-Wclippy::cast-sign-loss", "-Wclippy::cast-sign-loss",
"-Wclippy::checked-conversions", "-Wclippy::checked-conversions",
"-Wclippy::clone-on-ref-ptr",
"-Wclippy::cloned-instead-of-copied", "-Wclippy::cloned-instead-of-copied",
"-Wclippy::copy-iterator", "-Wclippy::copy-iterator",
"-Wclippy::dbg-macro", "-Wclippy::dbg-macro",
"-Wclippy::debug-assert-with-mut-call",
"-Wclippy::decimal-literal-representation", "-Wclippy::decimal-literal-representation",
"-Wclippy::empty-line-after-outer-attr", "-Wclippy::default-trait-access",
"-Wclippy::default-union-representation",
# TODO: 1.61+ "-Wclippy::deref-by-slicing",
# TODO: 1.63+ "-Wclippy::doc-link-with-quotes",
# TODO: 1.62+ "-Wclippy::empty-drop",
"-Wclippy::empty-enum", "-Wclippy::empty-enum",
# TODO: on major version "-Wclippy::empty-structs-with-brackets",
"-Wclippy::enum-glob-use", "-Wclippy::enum-glob-use",
"-Wclippy::exit",
"-Wclippy::expect-used", "-Wclippy::expect-used",
"-Wclippy::expl-impl-clone-on-copy", "-Wclippy::expl-impl-clone-on-copy",
"-Wclippy::explicit-deref-methods", "-Wclippy::explicit-deref-methods",
"-Wclippy::explicit-into-iter-loop", "-Wclippy::explicit-into-iter-loop",
"-Wclippy::explicit-iter-loop", "-Wclippy::explicit-iter-loop",
"-Wclippy::fallible-impl-from",
"-Wclippy::filter-map-next", "-Wclippy::filter-map-next",
"-Wclippy::flat-map-option", "-Wclippy::flat-map-option",
"-Wclippy::fn-to-numeric-cast-any",
# TODO: 1.62+ "-Wclippy::format-push-string",
"-Wclippy::from-iter-instead-of-collect", "-Wclippy::from-iter-instead-of-collect",
"-Wclippy::get-unwrap", "-Wclippy::get-unwrap",
"-Wclippy::if-not-else", "-Wclippy::if-not-else",
"-Wclippy::if-then-some-else-none",
"-Wclippy::implicit-clone", "-Wclippy::implicit-clone",
"-Wclippy::implicit-saturating-sub",
"-Wclippy::imprecise-flops",
"-Wclippy::inconsistent-struct-constructor", "-Wclippy::inconsistent-struct-constructor",
"-Wclippy::index-refutable-slice",
"-Wclippy::inefficient-to-string", "-Wclippy::inefficient-to-string",
"-Wclippy::inline-always", "-Wclippy::inline-always",
"-Wclippy::inline-asm-x86-att-syntax",
"-Wclippy::inline-asm-x86-intel-syntax",
"-Wclippy::invalid-upcast-comparisons", "-Wclippy::invalid-upcast-comparisons",
"-Wclippy::items-after-statements", "-Wclippy::items-after-statements",
"-Wclippy::large-digit-groups", "-Wclippy::large-digit-groups",
# TODO: 1.68+ "-Wclippy::large-futures",
"-Wclippy::large-stack-arrays", "-Wclippy::large-stack-arrays",
"-Wclippy::large-types-passed-by-value", "-Wclippy::large-types-passed-by-value",
"-Wclippy::let-underscore-must-use", "-Wclippy::let-underscore-must-use",
"-Wclippy::let-unit-value", "-Wclippy::let-unit-value",
"-Wclippy::linkedlist", "-Wclippy::linkedlist",
"-Wclippy::lossy-float-literal",
"-Wclippy::macro-use-imports", "-Wclippy::macro-use-imports",
"-Wclippy::manual-assert",
# TODO: 1.65+ "-Wclippy::manual-instant-elapsed",
# TODO: 1.67+ "-Wclippy::manual-let-else",
"-Wclippy::manual-ok-or", "-Wclippy::manual-ok-or",
"-Wclippy::map-flatten", # TODO: 1.65+ "-Wclippy::manual-string-new",
"-Wclippy::many-single-char-names",
"-Wclippy::map-unwrap-or", "-Wclippy::map-unwrap-or",
"-Wclippy::match-bool", "-Wclippy::match-bool",
"-Wclippy::match-same-arms", "-Wclippy::match-same-arms",
"-Wclippy::match-wildcard-for-single-variants", "-Wclippy::match-wildcard-for-single-variants",
"-Wclippy::maybe-infinite-iter", "-Wclippy::maybe-infinite-iter",
"-Wclippy::mem-forget", "-Wclippy::mem-forget",
# TODO: 1.63+ "-Wclippy::mismatching-type-param-order",
"-Wclippy::multiple-inherent-impl", "-Wclippy::multiple-inherent-impl",
"-Wclippy::mut-mut", "-Wclippy::mut-mut",
"-Wclippy::mutex-integer", "-Wclippy::mutex-atomic",
"-Wclippy::naive-bytecount", "-Wclippy::naive-bytecount",
"-Wclippy::needless-bitwise-bool", "-Wclippy::needless-bitwise-bool",
"-Wclippy::needless-continue", "-Wclippy::needless-continue",
"-Wclippy::needless-pass-by-value", "-Wclippy::needless-pass-by-value",
"-Wclippy::no-effect-underscore-binding",
# TODO: 1.69+ "-Wclippy::no-mangle-with-rust-abi",
"-Wclippy::non-ascii-literal", "-Wclippy::non-ascii-literal",
"-Wclippy::nonstandard-macro-braces",
"-Wclippy::path-buf-push-overwrite",
"-Wclippy::print-stderr", "-Wclippy::print-stderr",
"-Wclippy::print-stdout", "-Wclippy::print-stdout",
"-Wclippy::ptr-as-ptr",
"-Wclippy::range-minus-one", "-Wclippy::range-minus-one",
"-Wclippy::range-plus-one", "-Wclippy::range-plus-one",
"-Wclippy::rc-buffer",
"-Wclippy::rc-mutex", "-Wclippy::rc-mutex",
"-Wclippy::enum-variant-names", "-Wclippy::redundant-closure-for-method-calls",
"-Wclippy::redundant-else", "-Wclippy::redundant-else",
"-Wclippy::redundant-pub-crate", "-Wclippy::redundant-feature-names",
"-Wclippy::ref-binding-to-reference", "-Wclippy::ref-binding-to-reference",
"-Wclippy::ref-option-ref", "-Wclippy::ref-option-ref",
"-Wclippy::rest-pat-in-fully-bound-structs", "-Wclippy::rest-pat-in-fully-bound-structs",
"-Wclippy::return-self-not-must-use",
"-Wclippy::same-functions-in-if-condition", "-Wclippy::same-functions-in-if-condition",
# TODO: strange failure on 1.60 "-Wclippy::same-name-method",
# TODO: 1.68+ "-Wclippy::semicolon-outside-block",
"-Wclippy::single-match-else",
"-Wclippy::stable-sort-primitive",
"-Wclippy::str-to-string", "-Wclippy::str-to-string",
"-Wclippy::string-add", "-Wclippy::string-add",
"-Wclippy::string-add-assign", "-Wclippy::string-add-assign",
"-Wclippy::string-lit-as-bytes", "-Wclippy::string-lit-as-bytes",
"-Wclippy::string-to-string", "-Wclippy::string-to-string",
"-Wclippy::suboptimal-flops", # TODO: 1.67+ "-Wclippy::suspicious-xor-used-as-pow",
"-Wclippy::suspicious-operation-groupings",
"-Wclippy::todo", "-Wclippy::todo",
"-Wclippy::trait-duplication-in-bounds",
"-Wclippy::transmute-ptr-to-ptr", "-Wclippy::transmute-ptr-to-ptr",
"-Wclippy::trivial-regex",
"-Wclippy::trivially-copy-pass-by-ref", "-Wclippy::trivially-copy-pass-by-ref",
"-Wclippy::type-repetition-in-bounds", "-Wclippy::try-err",
"-Wclippy::unicode-not-nfc", "-Wclippy::unicode-not-nfc",
"-Wclippy::unimplemented", "-Wclippy::unimplemented",
# TODO: 1.66+ "-Wclippy::uninlined-format-args",
# TODO: 1.70+ "-Wclippy::unnecessary-box-returns",
# TODO: 1.61+ "-Wclippy::unnecessary-join",
# TODO: 1.67+ "-Wclippy::unnecessary-safety-comment",
# TODO: 1.67+ "-Wclippy::unnecessary-safety-doc",
"-Wclippy::unnecessary-self-imports", "-Wclippy::unnecessary-self-imports",
"-Wclippy::unnecessary-wraps", "-Wclippy::unnecessary-wraps",
"-Wclippy::unneeded-field-pattern", "-Wclippy::unneeded-field-pattern",
@ -99,13 +129,9 @@ rustflags = [
"-Wclippy::unused-async", "-Wclippy::unused-async",
"-Wclippy::unused-self", "-Wclippy::unused-self",
"-Wclippy::use-debug", "-Wclippy::use-debug",
"-Wclippy::use-self",
"-Wclippy::used-underscore-binding", "-Wclippy::used-underscore-binding",
"-Wclippy::useless-let-if-seq",
"-Wclippy::useless-transmute",
"-Wclippy::verbose-bit-mask", "-Wclippy::verbose-bit-mask",
"-Wclippy::verbose-file-reads", "-Wclippy::verbose-file-reads",
"-Wclippy::wildcard-dependencies", "-Wclippy::wildcard-dependencies",
"-Wclippy::zero-sized-map-values", "-Wclippy::zero-sized-map-values",
"-Wclippy::wrong-self-convention",
] ]

2
js/src/model.rs
Unescape View File

@ -19,7 +19,7 @@ thread_local! {
#[wasm_bindgen(js_name = namedNode)] #[wasm_bindgen(js_name = namedNode)]
pub fn named_node(value: String) -> Result<JsNamedNode, JsValue> { pub fn named_node(value: String) -> Result<JsNamedNode, JsValue> {
NamedNode::new(value) NamedNode::new(value)
.map(|v| v.into()) .map(Into::into)
.map_err(|v| UriError::new(&v.to_string()).into()) .map_err(|v| UriError::new(&v.to_string()).into())
} }

8
js/src/store.rs
Unescape View File

@ -76,28 +76,28 @@ impl JsStore {
None None
} }
.as_ref() .as_ref()
.map(|t: &NamedOrBlankNode| t.into()), .map(<&Subject>::into),
if let Some(predicate) = FROM_JS.with(|c| c.to_optional_term(predicate))? { if let Some(predicate) = FROM_JS.with(|c| c.to_optional_term(predicate))? {
Some(NamedNode::try_from(predicate)?) Some(NamedNode::try_from(predicate)?)
} else { } else {
None None
} }
.as_ref() .as_ref()
.map(|t: &NamedNode| t.into()), .map(<&NamedNode>::into),
if let Some(object) = FROM_JS.with(|c| c.to_optional_term(object))? { if let Some(object) = FROM_JS.with(|c| c.to_optional_term(object))? {
Some(object.try_into()?) Some(object.try_into()?)
} else { } else {
None None
} }
.as_ref() .as_ref()
.map(|t: &Term| t.into()), .map(<&Term>::into),
if let Some(graph_name) = FROM_JS.with(|c| c.to_optional_term(graph_name))? { if let Some(graph_name) = FROM_JS.with(|c| c.to_optional_term(graph_name))? {
Some(graph_name.try_into()?) Some(graph_name.try_into()?)
} else { } else {
None None
} }
.as_ref() .as_ref()
.map(|t: &GraphName| t.into()), .map(<&GraphName>::into),
) )
.map(|v| v.map(|v| JsQuad::from(v).into())) .map(|v| v.map(|v| JsQuad::from(v).into()))
.collect::<Result<Vec<_>, _>>() .collect::<Result<Vec<_>, _>>()

4
lib/oxrdf/src/dataset.rs
Unescape View File

@ -705,9 +705,7 @@ impl Dataset {
InternedTerm, InternedTerm,
InternedGraphName, InternedGraphName,
)> { )> {
let b_prime = partition let b_prime = partition.iter().find_map(|(_, b)| (b.len() > 1).then(|| b));
.iter()
.find_map(|(_, b)| if b.len() > 1 { Some(b) } else { None });
if let Some(b_prime) = b_prime { if let Some(b_prime) = b_prime {
b_prime b_prime
.iter() .iter()

9
lib/oxrdf/src/interning.rs
Unescape View File

@ -463,11 +463,10 @@ impl InternedTriple {
predicate: InternedNamedNode::encoded_from(triple.predicate, interner)?, predicate: InternedNamedNode::encoded_from(triple.predicate, interner)?,
object: InternedTerm::encoded_from(triple.object, interner)?, object: InternedTerm::encoded_from(triple.object, interner)?,
}; };
if interner.triples.contains_key(&interned_triple) { interner
Some(interned_triple) .triples
} else { .contains_key(&interned_triple)
None .then(|| interned_triple)
}
} }
pub fn next(&self) -> Self { pub fn next(&self) -> Self {

1
lib/oxrdf/src/lib.rs
Unescape View File

@ -1,5 +1,4 @@
#![doc = include_str!("../README.md")] #![doc = include_str!("../README.md")]
#![deny(unsafe_code)]
#![doc(test(attr(deny(warnings))))] #![doc(test(attr(deny(warnings))))]
#![cfg_attr(docsrs, feature(doc_auto_cfg))] #![cfg_attr(docsrs, feature(doc_auto_cfg))]
#![doc(html_favicon_url = "https://raw.githubusercontent.com/oxigraph/oxigraph/main/logo.svg")] #![doc(html_favicon_url = "https://raw.githubusercontent.com/oxigraph/oxigraph/main/logo.svg")]

2
lib/oxsdatatypes/src/decimal.rs
Unescape View File

@ -380,7 +380,7 @@ impl FromStr for Decimal {
}; };
let mut value = 0_i128; let mut value = 0_i128;
let with_before_dot = input.first().map_or(false, |c| c.is_ascii_digit()); let with_before_dot = input.first().map_or(false, u8::is_ascii_digit);
while let Some(c) = input.first() { while let Some(c) = input.first() {
if c.is_ascii_digit() { if c.is_ascii_digit() {
value = value value = value

6
lib/oxsdatatypes/src/duration.rs
Unescape View File

@ -170,8 +170,10 @@ impl fmt::Display for Duration {
let h = (s_int % 86400) / 3600; let h = (s_int % 86400) / 3600;
let m = (s_int % 3600) / 60; let m = (s_int % 3600) / 60;
let s = ss let s = ss
.checked_sub(Decimal::try_from(d * 86400 + h * 3600 + m * 60).unwrap()) .checked_sub(
.unwrap(); //could not fail Decimal::try_from(d * 86400 + h * 3600 + m * 60).map_err(|_| fmt::Error)?,
)
.ok_or(fmt::Error)?;
if d != 0 { if d != 0 {
write!(f, "{d}D")?; write!(f, "{d}D")?;

10
lib/oxsdatatypes/src/integer.rs
Unescape View File

@ -258,9 +258,9 @@ mod tests {
assert!(Integer::try_from(Float::from(f32::MIN)).is_err()); assert!(Integer::try_from(Float::from(f32::MIN)).is_err());
assert!(Integer::try_from(Float::from(f32::MAX)).is_err()); assert!(Integer::try_from(Float::from(f32::MAX)).is_err());
assert!( assert!(
Integer::try_from(Float::from(1_672_507_302_466.)) Integer::try_from(Float::from(1_672_507_300_000.))
.unwrap() .unwrap()
.checked_sub(Integer::from_str("1672507302466")?) .checked_sub(Integer::from_str("1672507300000")?)
.unwrap() .unwrap()
.abs() .abs()
< Integer::from(1_000_000) < Integer::from(1_000_000)
@ -283,12 +283,12 @@ mod tests {
Some(Integer::from_str("-123")?) Some(Integer::from_str("-123")?)
); );
assert!( assert!(
Integer::try_from(Double::from(1_672_507_302_466.)) Integer::try_from(Double::from(1_672_507_300_000.))
.unwrap() .unwrap()
.checked_sub(Integer::from_str("1672507302466").unwrap()) .checked_sub(Integer::from_str("1672507300000").unwrap())
.unwrap() .unwrap()
.abs() .abs()
< Integer::from(1) < Integer::from(10)
); );
assert!(Integer::try_from(Double::from(f64::NAN)).is_err()); assert!(Integer::try_from(Double::from(f64::NAN)).is_err());
assert!(Integer::try_from(Double::from(f64::INFINITY)).is_err()); assert!(Integer::try_from(Double::from(f64::INFINITY)).is_err());

2
lib/oxsdatatypes/src/lib.rs
Unescape View File

@ -1,9 +1,9 @@
#![doc = include_str!("../README.md")] #![doc = include_str!("../README.md")]
#![deny(unsafe_code)]
#![doc(test(attr(deny(warnings))))] #![doc(test(attr(deny(warnings))))]
#![cfg_attr(docsrs, feature(doc_auto_cfg))] #![cfg_attr(docsrs, feature(doc_auto_cfg))]
#![doc(html_favicon_url = "https://raw.githubusercontent.com/oxigraph/oxigraph/main/logo.svg")] #![doc(html_favicon_url = "https://raw.githubusercontent.com/oxigraph/oxigraph/main/logo.svg")]
#![doc(html_logo_url = "https://raw.githubusercontent.com/oxigraph/oxigraph/main/logo.svg")] #![doc(html_logo_url = "https://raw.githubusercontent.com/oxigraph/oxigraph/main/logo.svg")]
#![allow(clippy::return_self_not_must_use)]
mod boolean; mod boolean;
mod date_time; mod date_time;

14
lib/sparesults/src/csv.rs
Unescape View File

@ -160,7 +160,7 @@ fn write_tsv_term<'a>(term: impl Into<TermRef<'a>>, sink: &mut impl Write) -> io
let value = literal.value(); let value = literal.value();
if let Some(language) = literal.language() { if let Some(language) = literal.language() {
write_tsv_quoted_str(value, sink)?; write_tsv_quoted_str(value, sink)?;
write!(sink, "@{}", language) write!(sink, "@{language}")
} else { } else {
match literal.datatype() { match literal.datatype() {
xsd::BOOLEAN if is_turtle_boolean(value) => sink.write_all(value.as_bytes()), xsd::BOOLEAN if is_turtle_boolean(value) => sink.write_all(value.as_bytes()),
@ -216,7 +216,7 @@ fn is_turtle_integer(value: &str) -> bool {
} else if let Some(v) = value.strip_prefix(b"-") { } else if let Some(v) = value.strip_prefix(b"-") {
value = v; value = v;
} }
!value.is_empty() && value.iter().all(|c| c.is_ascii_digit()) !value.is_empty() && value.iter().all(u8::is_ascii_digit)
} }
fn is_turtle_decimal(value: &str) -> bool { fn is_turtle_decimal(value: &str) -> bool {
@ -227,7 +227,7 @@ fn is_turtle_decimal(value: &str) -> bool {
} else if let Some(v) = value.strip_prefix(b"-") { } else if let Some(v) = value.strip_prefix(b"-") {
value = v; value = v;
} }
while value.first().map_or(false, |c| c.is_ascii_digit()) { while value.first().map_or(false, u8::is_ascii_digit) {
value = &value[1..]; value = &value[1..];
} }
if let Some(v) = value.strip_prefix(b".") { if let Some(v) = value.strip_prefix(b".") {
@ -235,7 +235,7 @@ fn is_turtle_decimal(value: &str) -> bool {
} else { } else {
return false; return false;
} }
!value.is_empty() && value.iter().all(|c| c.is_ascii_digit()) !value.is_empty() && value.iter().all(u8::is_ascii_digit)
} }
fn is_turtle_double(value: &str) -> bool { fn is_turtle_double(value: &str) -> bool {
@ -248,14 +248,14 @@ fn is_turtle_double(value: &str) -> bool {
value = v; value = v;
} }
let mut with_before = false; let mut with_before = false;
while value.first().map_or(false, |c| c.is_ascii_digit()) { while value.first().map_or(false, u8::is_ascii_digit) {
value = &value[1..]; value = &value[1..];
with_before = true; with_before = true;
} }
let mut with_after = false; let mut with_after = false;
if let Some(v) = value.strip_prefix(b".") { if let Some(v) = value.strip_prefix(b".") {
value = v; value = v;
while value.first().map_or(false, |c| c.is_ascii_digit()) { while value.first().map_or(false, u8::is_ascii_digit) {
value = &value[1..]; value = &value[1..];
with_after = true; with_after = true;
} }
@ -272,7 +272,7 @@ fn is_turtle_double(value: &str) -> bool {
} else if let Some(v) = value.strip_prefix(b"-") { } else if let Some(v) = value.strip_prefix(b"-") {
value = v; value = v;
} }
(with_before || with_after) && !value.is_empty() && value.iter().all(|c| c.is_ascii_digit()) (with_before || with_after) && !value.is_empty() && value.iter().all(u8::is_ascii_digit)
} }
pub enum TsvQueryResultsReader<R: BufRead> { pub enum TsvQueryResultsReader<R: BufRead> {

4
lib/sparesults/src/lib.rs
Unescape View File

@ -1,5 +1,4 @@
#![doc = include_str!("../README.md")] #![doc = include_str!("../README.md")]
#![deny(unsafe_code)]
#![doc(test(attr(deny(warnings))))] #![doc(test(attr(deny(warnings))))]
#![cfg_attr(docsrs, feature(doc_auto_cfg))] #![cfg_attr(docsrs, feature(doc_auto_cfg))]
#![doc(html_favicon_url = "https://raw.githubusercontent.com/oxigraph/oxigraph/main/logo.svg")] #![doc(html_favicon_url = "https://raw.githubusercontent.com/oxigraph/oxigraph/main/logo.svg")]
@ -276,6 +275,7 @@ pub enum QueryResultsReader<R: BufRead> {
/// } /// }
/// # Result::<(),sparesults::ParseError>::Ok(()) /// # Result::<(),sparesults::ParseError>::Ok(())
/// ``` /// ```
#[allow(clippy::rc_buffer)]
pub struct SolutionsReader<R: BufRead> { pub struct SolutionsReader<R: BufRead> {
variables: Rc<Vec<Variable>>, variables: Rc<Vec<Variable>>,
solutions: SolutionsReaderKind<R>, solutions: SolutionsReaderKind<R>,
@ -318,7 +318,7 @@ impl<R: BufRead> Iterator for SolutionsReader<R> {
SolutionsReaderKind::Tsv(reader) => reader.read_next(), SolutionsReaderKind::Tsv(reader) => reader.read_next(),
} }
.transpose()? .transpose()?
.map(|values| (self.variables.clone(), values).into()), .map(|values| (Rc::clone(&self.variables), values).into()),
) )
} }
} }

3
lib/sparesults/src/solution.rs
Unescape View File

@ -18,6 +18,7 @@ use std::rc::Rc;
/// assert_eq!(solution.get("foo"), Some(&Literal::from(1).into())); // Get the value of the variable ?foo if it exists (here yes). /// assert_eq!(solution.get("foo"), Some(&Literal::from(1).into())); // Get the value of the variable ?foo if it exists (here yes).
/// assert_eq!(solution.get(1), None); // Get the value of the second column if it exists (here no). /// assert_eq!(solution.get(1), None); // Get the value of the second column if it exists (here no).
/// ``` /// ```
#[allow(clippy::rc_buffer)]
pub struct QuerySolution { pub struct QuerySolution {
variables: Rc<Vec<Variable>>, variables: Rc<Vec<Variable>>,
values: Vec<Option<Term>>, values: Vec<Option<Term>>,
@ -69,7 +70,7 @@ impl QuerySolution {
/// ``` /// ```
#[inline] #[inline]
pub fn is_empty(&self) -> bool { pub fn is_empty(&self) -> bool {
self.values.iter().all(|v| v.is_none()) self.values.iter().all(Option::is_none)
} }
/// Returns an iterator over bound variables. /// Returns an iterator over bound variables.

22
lib/sparesults/src/xml.rs
Unescape View File

@ -482,20 +482,31 @@ impl<R: BufRead> XmlSolutionsReader<R> {
} }
state = State::Triple; state = State::Triple;
} }
State::Uri => state = self.stack.pop().unwrap(), State::Uri => {
state = self
.stack
.pop()
.ok_or_else(|| SyntaxError::msg("Empty stack"))?
}
State::BNode => { State::BNode => {
if term.is_none() { if term.is_none() {
//We default to a random bnode //We default to a random bnode
term = Some(BlankNode::default().into()) term = Some(BlankNode::default().into())
} }
state = self.stack.pop().unwrap() state = self
.stack
.pop()
.ok_or_else(|| SyntaxError::msg("Empty stack"))?
} }
State::Literal => { State::Literal => {
if term.is_none() { if term.is_none() {
//We default to the empty literal //We default to the empty literal
term = Some(build_literal("", lang.take(), datatype.take())?.into()) term = Some(build_literal("", lang.take(), datatype.take())?.into())
} }
state = self.stack.pop().unwrap(); state = self
.stack
.pop()
.ok_or_else(|| SyntaxError::msg("Empty stack"))?;
} }
State::Triple => { State::Triple => {
#[cfg(feature = "rdf-star")] #[cfg(feature = "rdf-star")]
@ -530,7 +541,10 @@ impl<R: BufRead> XmlSolutionsReader<R> {
) )
.into(), .into(),
); );
state = self.stack.pop().unwrap(); state = self
.stack
.pop()
.ok_or_else(|| SyntaxError::msg("Empty stack"))?;
} else { } else {
return Err( return Err(
SyntaxError::msg("A <triple> should contain a <subject>, a <predicate> and an <object>").into() SyntaxError::msg("A <triple> should contain a <subject>, a <predicate> and an <object>").into()

1
lib/spargebra/src/lib.rs
Unescape View File

@ -1,5 +1,4 @@
#![doc = include_str!("../README.md")] #![doc = include_str!("../README.md")]
#![deny(unsafe_code)]
#![doc(test(attr(deny(warnings))))] #![doc(test(attr(deny(warnings))))]
#![cfg_attr(docsrs, feature(doc_auto_cfg))] #![cfg_attr(docsrs, feature(doc_auto_cfg))]
#![doc(html_favicon_url = "https://raw.githubusercontent.com/oxigraph/oxigraph/main/logo.svg")] #![doc(html_favicon_url = "https://raw.githubusercontent.com/oxigraph/oxigraph/main/logo.svg")]

19
lib/spargebra/src/parser.rs
Unescape View File

@ -352,7 +352,7 @@ impl<F, T: From<F>> From<FocusedTriplePattern<F>> for FocusedTripleOrPathPattern
fn from(input: FocusedTriplePattern<F>) -> Self { fn from(input: FocusedTriplePattern<F>) -> Self {
Self { Self {
focus: input.focus.into(), focus: input.focus.into(),
patterns: input.patterns.into_iter().map(|p| p.into()).collect(), patterns: input.patterns.into_iter().map(Into::into).collect(),
} }
} }
} }
@ -736,7 +736,7 @@ impl ParserState {
let aggregates = self.aggregates.last_mut().ok_or("Unexpected aggregate")?; let aggregates = self.aggregates.last_mut().ok_or("Unexpected aggregate")?;
Ok(aggregates Ok(aggregates
.iter() .iter()
.find_map(|(v, a)| if a == &agg { Some(v) } else { None }) .find_map(|(v, a)| (a == &agg).then(|| v))
.cloned() .cloned()
.unwrap_or_else(|| { .unwrap_or_else(|| {
let new_var = variable(); let new_var = variable();
@ -884,13 +884,14 @@ impl<'a> Iterator for UnescapeCharsIterator<'a> {
} }
match self.iter.next()? { match self.iter.next()? {
'\\' => match self.iter.next() { '\\' => match self.iter.next() {
Some(ch) => match self.replacement.get(ch) { Some(ch) => {
Some(replace) => Some(replace), if let Some(replace) = self.replacement.get(ch) {
None => { Some(replace)
} else {
self.buffer = Some(ch); self.buffer = Some(ch);
Some('\\') Some('\\')
} }
}, }
None => Some('\\'), None => Some('\\'),
}, },
c => Some(c), c => Some(c),
@ -1590,7 +1591,7 @@ parser! {
//[74] //[74]
rule ConstructTriples() -> Vec<TriplePattern> = p:ConstructTriples_item() ** ("." _) "."? { rule ConstructTriples() -> Vec<TriplePattern> = p:ConstructTriples_item() ** ("." _) "."? {
p.into_iter().flat_map(|c| c.into_iter()).collect() p.into_iter().flatten().collect()
} }
rule ConstructTriples_item() -> Vec<TriplePattern> = t:TriplesSameSubject() _ { t } rule ConstructTriples_item() -> Vec<TriplePattern> = t:TriplesSameSubject() _ { t }
@ -1701,7 +1702,7 @@ parser! {
//[83] //[83]
rule PropertyListPathNotEmpty() -> FocusedTripleOrPathPattern<Vec<(VariableOrPropertyPath,Vec<AnnotatedTermPath>)>> = hp:(VerbPath() / VerbSimple()) _ ho:ObjectListPath() _ t:PropertyListPathNotEmpty_item()* { rule PropertyListPathNotEmpty() -> FocusedTripleOrPathPattern<Vec<(VariableOrPropertyPath,Vec<AnnotatedTermPath>)>> = hp:(VerbPath() / VerbSimple()) _ ho:ObjectListPath() _ t:PropertyListPathNotEmpty_item()* {
t.into_iter().flat_map(|e| e.into_iter()).fold(FocusedTripleOrPathPattern { t.into_iter().flatten().fold(FocusedTripleOrPathPattern {
focus: vec![(hp, ho.focus)], focus: vec![(hp, ho.focus)],
patterns: ho.patterns patterns: ho.patterns
}, |mut a, b| { }, |mut a, b| {
@ -2036,7 +2037,7 @@ parser! {
//[121] //[121]
rule BuiltInCall() -> Expression = rule BuiltInCall() -> Expression =
a:Aggregate() {? state.new_aggregation(a).map(|v| v.into()) } / a:Aggregate() {? state.new_aggregation(a).map(Into::into) } /
i("STR") _ "(" _ e:Expression() _ ")" { Expression::FunctionCall(Function::Str, vec![e]) } / i("STR") _ "(" _ e:Expression() _ ")" { Expression::FunctionCall(Function::Str, vec![e]) } /
i("LANG") _ "(" _ e:Expression() _ ")" { Expression::FunctionCall(Function::Lang, vec![e]) } / i("LANG") _ "(" _ e:Expression() _ ")" { Expression::FunctionCall(Function::Lang, vec![e]) } /
i("LANGMATCHES") _ "(" _ a:Expression() _ "," _ b:Expression() _ ")" { Expression::FunctionCall(Function::LangMatches, vec![a, b]) } / i("LANGMATCHES") _ "(" _ a:Expression() _ "," _ b:Expression() _ ")" { Expression::FunctionCall(Function::LangMatches, vec![a, b]) } /

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

@ -45,12 +45,14 @@ impl Error for ParseError {
} }
} }
#[allow(clippy::fallible_impl_from)]
impl From<TurtleError> for ParseError { impl From<TurtleError> for ParseError {
#[inline] #[inline]
fn from(error: TurtleError) -> Self { fn from(error: TurtleError) -> Self {
let error = io::Error::from(error); let error = io::Error::from(error);
if error.get_ref().map_or(false, |e| e.is::<TurtleError>()) { if error.get_ref().map_or(
false,
<(dyn Error + Send + Sync + 'static)>::is::<TurtleError>,
) {
Self::Syntax(SyntaxError { Self::Syntax(SyntaxError {
inner: SyntaxErrorKind::Turtle(*error.into_inner().unwrap().downcast().unwrap()), inner: SyntaxErrorKind::Turtle(*error.into_inner().unwrap().downcast().unwrap()),
}) })
@ -60,12 +62,14 @@ impl From<TurtleError> for ParseError {
} }
} }
#[allow(clippy::fallible_impl_from)]
impl From<RdfXmlError> for ParseError { impl From<RdfXmlError> for ParseError {
#[inline] #[inline]
fn from(error: RdfXmlError) -> Self { fn from(error: RdfXmlError) -> Self {
let error = io::Error::from(error); let error = io::Error::from(error);
if error.get_ref().map_or(false, |e| e.is::<RdfXmlError>()) { if error.get_ref().map_or(
false,
<(dyn Error + Send + Sync + 'static)>::is::<RdfXmlError>,
) {
Self::Syntax(SyntaxError { Self::Syntax(SyntaxError {
inner: SyntaxErrorKind::RdfXml(*error.into_inner().unwrap().downcast().unwrap()), inner: SyntaxErrorKind::RdfXml(*error.into_inner().unwrap().downcast().unwrap()),
}) })

2
lib/src/lib.rs
Unescape View File

@ -3,7 +3,7 @@
#![doc(html_logo_url = "https://raw.githubusercontent.com/oxigraph/oxigraph/main/logo.svg")] #![doc(html_logo_url = "https://raw.githubusercontent.com/oxigraph/oxigraph/main/logo.svg")]
#![cfg_attr(docsrs, feature(doc_auto_cfg))] #![cfg_attr(docsrs, feature(doc_auto_cfg))]
#![doc(test(attr(deny(warnings))))] #![doc(test(attr(deny(warnings))))]
#![deny(unsafe_code)] #![allow(clippy::return_self_not_must_use)]
pub mod io; pub mod io;
pub mod sparql; pub mod sparql;

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

@ -40,7 +40,7 @@ impl DatasetView {
) -> impl Iterator<Item = Result<EncodedQuad, EvaluationError>> + 'static { ) -> impl Iterator<Item = Result<EncodedQuad, EvaluationError>> + 'static {
self.reader self.reader
.quads_for_pattern(subject, predicate, object, graph_name) .quads_for_pattern(subject, predicate, object, graph_name)
.map(|t| t.map_err(|e| e.into())) .map(|t| t.map_err(Into::into))
} }
#[allow(clippy::needless_collect)] #[allow(clippy::needless_collect)]

366
lib/src/sparql/eval.rs
View File

File diff suppressed because it is too large Load Diff

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

@ -160,6 +160,7 @@ impl<R: BufRead + 'static> From<QueryResultsReader<R>> for QueryResults {
/// } /// }
/// # Result::<_,Box<dyn std::error::Error>>::Ok(()) /// # Result::<_,Box<dyn std::error::Error>>::Ok(())
/// ``` /// ```
#[allow(clippy::rc_buffer)]
pub struct QuerySolutionIter { pub struct QuerySolutionIter {
variables: Rc<Vec<Variable>>, variables: Rc<Vec<Variable>>,
iter: Box<dyn Iterator<Item = Result<QuerySolution, EvaluationError>>>, iter: Box<dyn Iterator<Item = Result<QuerySolution, EvaluationError>>>,
@ -171,8 +172,10 @@ impl QuerySolutionIter {
iter: impl Iterator<Item = Result<Vec<Option<Term>>, EvaluationError>> + 'static, iter: impl Iterator<Item = Result<Vec<Option<Term>>, EvaluationError>> + 'static,
) -> Self { ) -> Self {
Self { Self {
variables: variables.clone(), variables: Rc::clone(&variables),
iter: Box::new(iter.map(move |t| t.map(|values| (variables.clone(), values).into()))), iter: Box::new(
iter.map(move |t| t.map(|values| (Rc::clone(&variables), values).into())),
),
} }
} }

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

@ -22,7 +22,7 @@ pub enum PlanNode {
}, },
Service { Service {
service_name: PatternValue, service_name: PatternValue,
variables: Rc<Vec<Variable>>, variables: Rc<[Variable]>,
child: Rc<Self>, child: Rc<Self>,
graph_pattern: Rc<GraphPattern>, graph_pattern: Rc<GraphPattern>,
silent: bool, silent: bool,
@ -71,7 +71,7 @@ pub enum PlanNode {
ForLoopLeftJoin { ForLoopLeftJoin {
left: Rc<Self>, left: Rc<Self>,
right: Rc<Self>, 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<[usize]>, //Variables that should not be part of the entry of the left join
}, },
Extend { Extend {
child: Rc<Self>, child: Rc<Self>,
@ -99,13 +99,13 @@ pub enum PlanNode {
}, },
Project { Project {
child: Rc<Self>, child: Rc<Self>,
mapping: Rc<Vec<(PlanVariable, PlanVariable)>>, // pairs of (variable key in child, variable key in output) mapping: Rc<[(PlanVariable, PlanVariable)]>, // 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<Self>, child: Rc<Self>,
key_variables: Rc<Vec<PlanVariable>>, key_variables: Rc<[PlanVariable]>,
aggregates: Rc<Vec<(PlanAggregation, PlanVariable)>>, aggregates: Rc<[(PlanAggregation, PlanVariable)]>,
}, },
} }
@ -236,7 +236,10 @@ impl PlanNode {
match self { match self {
Self::StaticBindings { encoded_tuples, .. } => { Self::StaticBindings { encoded_tuples, .. } => {
let mut variables = BTreeMap::default(); // value true iff always bound let mut variables = BTreeMap::default(); // value true iff always bound
let max_tuple_length = encoded_tuples.iter().map(|t| t.capacity()).fold(0, max); let max_tuple_length = encoded_tuples
.iter()
.map(EncodedTuple::capacity)
.fold(0, max);
for tuple in encoded_tuples { for tuple in encoded_tuples {
for key in 0..max_tuple_length { for key in 0..max_tuple_length {
match variables.entry(key) { match variables.entry(key) {
@ -649,6 +652,7 @@ impl PlanExpression {
} }
impl fmt::Display for PlanExpression { impl fmt::Display for PlanExpression {
#[allow(clippy::many_single_char_names)]
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self { match self {
Self::Variable(v) => { Self::Variable(v) => {
@ -838,7 +842,7 @@ pub enum PlanAggregationFunction {
Max, Max,
Avg, Avg,
Sample, Sample,
GroupConcat { separator: Rc<String> }, GroupConcat { separator: Rc<str> },
} }
#[derive(Debug, Clone)] #[derive(Debug, Clone)]
@ -850,7 +854,7 @@ pub enum PlanPropertyPath {
ZeroOrMore(Rc<Self>), ZeroOrMore(Rc<Self>),
OneOrMore(Rc<Self>), OneOrMore(Rc<Self>),
ZeroOrOne(Rc<Self>), ZeroOrOne(Rc<Self>),
NegatedPropertySet(Rc<Vec<PlanTerm<NamedNode>>>), NegatedPropertySet(Rc<[PlanTerm<NamedNode>]>),
} }
impl fmt::Display for PlanPropertyPath { impl fmt::Display for PlanPropertyPath {
@ -1046,7 +1050,7 @@ impl PlanNodeWithStats {
"Aggregate({})", "Aggregate({})",
key_variables key_variables
.iter() .iter()
.map(|c| c.to_string()) .map(ToString::to_string)
.chain(aggregates.iter().map(|(agg, v)| format!("{agg} -> {v}"))) .chain(aggregates.iter().map(|(agg, v)| format!("{agg} -> {v}")))
.collect::<Vec<_>>() .collect::<Vec<_>>()
.join(", ") .join(", ")
@ -1107,7 +1111,7 @@ impl PlanNodeWithStats {
format!( format!(
"Sort({})", "Sort({})",
by.iter() by.iter()
.map(|c| c.to_string()) .map(ToString::to_string)
.collect::<Vec<_>>() .collect::<Vec<_>>()
.join(", ") .join(", ")
) )
@ -1117,7 +1121,7 @@ impl PlanNodeWithStats {
"StaticBindings({})", "StaticBindings({})",
variables variables
.iter() .iter()
.map(|v| v.to_string()) .map(ToString::to_string)
.collect::<Vec<_>>() .collect::<Vec<_>>()
.join(", ") .join(", ")
) )

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

@ -122,7 +122,7 @@ impl<'a> PlanBuilder<'a> {
PlanNode::ForLoopLeftJoin { PlanNode::ForLoopLeftJoin {
left: Rc::new(left), left: Rc::new(left),
right: Rc::new(right), right: Rc::new(right),
possible_problem_vars: Rc::new(possible_problem_vars.into_iter().collect()), possible_problem_vars: possible_problem_vars.into_iter().collect(),
} }
} else { } else {
PlanNode::HashLeftJoin { PlanNode::HashLeftJoin {
@ -191,7 +191,7 @@ impl<'a> PlanBuilder<'a> {
let service_name = self.pattern_value_from_named_node_or_variable(name, variables); let service_name = self.pattern_value_from_named_node_or_variable(name, variables);
PlanNode::Service { PlanNode::Service {
service_name, service_name,
variables: Rc::new(variables.clone()), variables: Rc::from(variables.as_slice()),
child: Rc::new(child), child: Rc::new(child),
graph_pattern: Rc::new(inner.as_ref().clone()), graph_pattern: Rc::new(inner.as_ref().clone()),
silent: *silent, silent: *silent,
@ -203,22 +203,19 @@ impl<'a> PlanBuilder<'a> {
aggregates, aggregates,
} => PlanNode::Aggregate { } => PlanNode::Aggregate {
child: Rc::new(self.build_for_graph_pattern(inner, variables, graph_name)?), child: Rc::new(self.build_for_graph_pattern(inner, variables, graph_name)?),
key_variables: Rc::new( key_variables: by
by.iter() .iter()
.map(|k| build_plan_variable(variables, k)) .map(|k| build_plan_variable(variables, k))
.collect(), .collect(),
), aggregates: aggregates
aggregates: Rc::new( .iter()
aggregates .map(|(v, a)| {
.iter() Ok((
.map(|(v, a)| { self.build_for_aggregate(a, variables, graph_name)?,
Ok(( build_plan_variable(variables, v),
self.build_for_aggregate(a, variables, graph_name)?, ))
build_plan_variable(variables, v), })
)) .collect::<Result<_, EvaluationError>>()?,
})
.collect::<Result<Vec<_>, EvaluationError>>()?,
),
}, },
GraphPattern::Values { GraphPattern::Values {
variables: table_variables, variables: table_variables,
@ -283,21 +280,19 @@ impl<'a> PlanBuilder<'a> {
&mut inner_variables, &mut inner_variables,
&inner_graph_name, &inner_graph_name,
)?), )?),
mapping: Rc::new( mapping: projection
projection .iter()
.iter() .enumerate()
.enumerate() .map(|(new_variable, variable)| {
.map(|(new_variable, variable)| { (
( PlanVariable {
PlanVariable { encoded: new_variable,
encoded: new_variable, plain: variable.clone(),
plain: variable.clone(), },
}, build_plan_variable(variables, variable),
build_plan_variable(variables, variable), )
) })
}) .collect(),
.collect(),
),
} }
} }
GraphPattern::Distinct { inner } => PlanNode::HashDeduplicate { GraphPattern::Distinct { inner } => PlanNode::HashDeduplicate {
@ -378,16 +373,14 @@ impl<'a> PlanBuilder<'a> {
PropertyPathExpression::ZeroOrOne(p) => { PropertyPathExpression::ZeroOrOne(p) => {
PlanPropertyPath::ZeroOrOne(Rc::new(self.build_for_path(p))) PlanPropertyPath::ZeroOrOne(Rc::new(self.build_for_path(p)))
} }
PropertyPathExpression::NegatedPropertySet(p) => { PropertyPathExpression::NegatedPropertySet(p) => PlanPropertyPath::NegatedPropertySet(
PlanPropertyPath::NegatedPropertySet(Rc::new( p.iter()
p.iter() .map(|p| PlanTerm {
.map(|p| PlanTerm { encoded: self.build_term(p),
encoded: self.build_term(p), plain: p.clone(),
plain: p.clone(), })
}) .collect(),
.collect(), ),
))
}
} }
} }
@ -1084,7 +1077,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_owned())), separator: Rc::from(separator.as_deref().unwrap_or(" ")),
}, },
parameter: Some(self.build_for_expression(expr, variables, graph_name)?), parameter: Some(self.build_for_expression(expr, variables, graph_name)?),
distinct: *distinct, distinct: *distinct,
@ -1219,13 +1212,11 @@ impl<'a> PlanBuilder<'a> {
} }
fn convert_plan_variable(from_variable: &PlanVariable, to: &mut Vec<Variable>) -> PlanVariable { fn convert_plan_variable(from_variable: &PlanVariable, to: &mut Vec<Variable>) -> PlanVariable {
let encoded = if let Some(to_id) = to.iter().enumerate().find_map(|(to_id, var)| { let encoded = if let Some(to_id) = to
if *var == from_variable.plain { .iter()
Some(to_id) .enumerate()
} else { .find_map(|(to_id, var)| (*var == from_variable.plain).then(|| to_id))
None {
}
}) {
to_id to_id
} else { } else {
to.push(Variable::new_unchecked(format!("{:x}", random::<u128>()))); to.push(Variable::new_unchecked(format!("{:x}", random::<u128>())));
@ -1423,25 +1414,25 @@ impl<'a> PlanBuilder<'a> {
if filter_variables.iter().all(|v| left.is_variable_bound(*v)) { if filter_variables.iter().all(|v| left.is_variable_bound(*v)) {
if filter_variables.iter().all(|v| right.is_variable_bound(*v)) { if filter_variables.iter().all(|v| right.is_variable_bound(*v)) {
PlanNode::HashJoin { PlanNode::HashJoin {
left: Rc::new(self.push_filter(left.clone(), filter.clone())), left: Rc::new(self.push_filter(Rc::clone(left), filter.clone())),
right: Rc::new(self.push_filter(right.clone(), filter)), right: Rc::new(self.push_filter(Rc::clone(right), filter)),
} }
} else { } else {
PlanNode::HashJoin { PlanNode::HashJoin {
left: Rc::new(self.push_filter(left.clone(), filter)), left: Rc::new(self.push_filter(Rc::clone(left), filter)),
right: right.clone(), right: Rc::clone(right),
} }
} }
} else if filter_variables.iter().all(|v| right.is_variable_bound(*v)) { } else if filter_variables.iter().all(|v| right.is_variable_bound(*v)) {
PlanNode::HashJoin { PlanNode::HashJoin {
left: left.clone(), left: Rc::clone(left),
right: Rc::new(self.push_filter(right.clone(), filter)), right: Rc::new(self.push_filter(Rc::clone(right), filter)),
} }
} else { } else {
PlanNode::Filter { PlanNode::Filter {
child: Rc::new(PlanNode::HashJoin { child: Rc::new(PlanNode::HashJoin {
left: left.clone(), left: Rc::clone(left),
right: right.clone(), right: Rc::clone(right),
}), }),
expression: filter, expression: filter,
} }
@ -1450,20 +1441,20 @@ impl<'a> PlanBuilder<'a> {
PlanNode::ForLoopJoin { left, right } => { PlanNode::ForLoopJoin { left, right } => {
if filter_variables.iter().all(|v| left.is_variable_bound(*v)) { if filter_variables.iter().all(|v| left.is_variable_bound(*v)) {
PlanNode::ForLoopJoin { PlanNode::ForLoopJoin {
left: Rc::new(self.push_filter(left.clone(), filter)), left: Rc::new(self.push_filter(Rc::clone(left), filter)),
right: right.clone(), right: Rc::clone(right),
} }
} else if filter_variables.iter().all(|v| right.is_variable_bound(*v)) { } else if filter_variables.iter().all(|v| right.is_variable_bound(*v)) {
PlanNode::ForLoopJoin { PlanNode::ForLoopJoin {
//TODO: should we do that always? //TODO: should we do that always?
left: left.clone(), left: Rc::clone(left),
right: Rc::new(self.push_filter(right.clone(), filter)), right: Rc::new(self.push_filter(Rc::clone(right), filter)),
} }
} else { } else {
PlanNode::Filter { PlanNode::Filter {
child: Rc::new(PlanNode::HashJoin { child: Rc::new(PlanNode::HashJoin {
left: left.clone(), left: Rc::clone(left),
right: right.clone(), right: Rc::clone(right),
}), }),
expression: filter, expression: filter,
} }
@ -1477,14 +1468,14 @@ impl<'a> PlanBuilder<'a> {
//TODO: handle the case where the filter generates an expression variable //TODO: handle the case where the filter generates an expression variable
if filter_variables.iter().all(|v| child.is_variable_bound(*v)) { if filter_variables.iter().all(|v| child.is_variable_bound(*v)) {
PlanNode::Extend { PlanNode::Extend {
child: Rc::new(self.push_filter(child.clone(), filter)), child: Rc::new(self.push_filter(Rc::clone(child), filter)),
expression: expression.clone(), expression: expression.clone(),
variable: variable.clone(), variable: variable.clone(),
} }
} else { } else {
PlanNode::Filter { PlanNode::Filter {
child: Rc::new(PlanNode::Extend { child: Rc::new(PlanNode::Extend {
child: child.clone(), child: Rc::clone(child),
expression: expression.clone(), expression: expression.clone(),
variable: variable.clone(), variable: variable.clone(),
}), }),
@ -1495,12 +1486,12 @@ impl<'a> PlanBuilder<'a> {
PlanNode::Filter { child, expression } => { PlanNode::Filter { child, expression } => {
if filter_variables.iter().all(|v| child.is_variable_bound(*v)) { if filter_variables.iter().all(|v| child.is_variable_bound(*v)) {
PlanNode::Filter { PlanNode::Filter {
child: Rc::new(self.push_filter(child.clone(), filter)), child: Rc::new(self.push_filter(Rc::clone(child), filter)),
expression: expression.clone(), expression: expression.clone(),
} }
} else { } else {
PlanNode::Filter { PlanNode::Filter {
child: child.clone(), child: Rc::clone(child),
expression: Box::new(PlanExpression::And(expression.clone(), filter)), expression: Box::new(PlanExpression::And(expression.clone(), filter)),
} }
} }
@ -1508,7 +1499,7 @@ impl<'a> PlanBuilder<'a> {
PlanNode::Union { children } => PlanNode::Union { PlanNode::Union { children } => PlanNode::Union {
children: children children: children
.iter() .iter()
.map(|c| Rc::new(self.push_filter(c.clone(), filter.clone()))) .map(|c| Rc::new(self.push_filter(Rc::clone(c), filter.clone())))
.collect(), .collect(),
}, },
_ => PlanNode::Filter { _ => PlanNode::Filter {
@ -1541,12 +1532,11 @@ impl<'a> PlanBuilder<'a> {
} }
fn build_plan_variable(variables: &mut Vec<Variable>, variable: &Variable) -> PlanVariable { fn build_plan_variable(variables: &mut Vec<Variable>, variable: &Variable) -> PlanVariable {
let encoded = match slice_key(variables, variable) { let encoded = if let Some(key) = slice_key(variables, variable) {
Some(key) => key, key
None => { } else {
variables.push(variable.clone()); variables.push(variable.clone());
variables.len() - 1 variables.len() - 1
}
}; };
PlanVariable { PlanVariable {
plain: variable.clone(), plain: variable.clone(),
@ -1555,12 +1545,11 @@ fn build_plan_variable(variables: &mut Vec<Variable>, variable: &Variable) -> Pl
} }
fn bnode_key(blank_nodes: &mut Vec<BlankNode>, blank_node: &BlankNode) -> usize { fn bnode_key(blank_nodes: &mut Vec<BlankNode>, blank_node: &BlankNode) -> usize {
match slice_key(blank_nodes, blank_node) { if let Some(key) = slice_key(blank_nodes, blank_node) {
Some(key) => key, key
None => { } else {
blank_nodes.push(blank_node.clone()); blank_nodes.push(blank_node.clone());
blank_nodes.len() - 1 blank_nodes.len() - 1
}
} }
} }
@ -1673,21 +1662,13 @@ fn compile_static_pattern_if_exists(
options: Option<&Expression>, options: Option<&Expression>,
) -> Option<Regex> { ) -> Option<Regex> {
let static_pattern = if let Expression::Literal(pattern) = pattern { let static_pattern = if let Expression::Literal(pattern) = pattern {
if pattern.datatype() == xsd::STRING { (pattern.datatype() == xsd::STRING).then(|| pattern.value())
Some(pattern.value())
} else {
None
}
} else { } else {
None None
}; };
let static_options = if let Some(options) = options { let static_options = if let Some(options) = options {
if let Expression::Literal(options) = options { if let Expression::Literal(options) = options {
if options.datatype() == xsd::STRING { (options.datatype() == xsd::STRING).then(|| Some(options.value()))
Some(Some(options.value()))
} else {
None
}
} else { } else {
None None
} }

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

@ -71,7 +71,14 @@ impl<'a, 'b: 'a> SimpleUpdateEvaluator<'a, 'b> {
insert, insert,
pattern, pattern,
.. ..
} => self.eval_delete_insert(delete, insert, using_dataset.as_ref().unwrap(), pattern), } => self.eval_delete_insert(
delete,
insert,
using_dataset
.as_ref()
.ok_or_else(|| EvaluationError::msg("No dataset"))?,
pattern,
),
GraphUpdateOperation::Load { GraphUpdateOperation::Load {
silent, silent,
source, source,
@ -119,14 +126,14 @@ impl<'a, 'b: 'a> SimpleUpdateEvaluator<'a, 'b> {
) -> Result<(), EvaluationError> { ) -> Result<(), EvaluationError> {
let dataset = Rc::new(DatasetView::new(self.transaction.reader(), using)); let dataset = Rc::new(DatasetView::new(self.transaction.reader(), using));
let (plan, variables) = PlanBuilder::build( let (plan, variables) = PlanBuilder::build(
dataset.as_ref(), &dataset,
algebra, algebra,
false, false,
&self.options.query_options.custom_functions, &self.options.query_options.custom_functions,
!self.options.query_options.without_optimizations, !self.options.query_options.without_optimizations,
)?; )?;
let evaluator = SimpleEvaluator::new( let evaluator = SimpleEvaluator::new(
dataset.clone(), Rc::clone(&dataset),
self.base_iri.clone(), self.base_iri.clone(),
self.options.query_options.service_handler(), self.options.query_options.service_handler(),
Rc::new(self.options.query_options.custom_functions.clone()), Rc::new(self.options.query_options.custom_functions.clone()),
@ -374,7 +381,7 @@ impl<'a, 'b: 'a> SimpleUpdateEvaluator<'a, 'b> {
TermPattern::Literal(term) => Some(term.clone().into()), TermPattern::Literal(term) => Some(term.clone().into()),
TermPattern::Triple(triple) => { TermPattern::Triple(triple) => {
Self::convert_triple_pattern(triple, variables, values, dataset, bnodes)? Self::convert_triple_pattern(triple, variables, values, dataset, bnodes)?
.map(|t| t.into()) .map(Into::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))
@ -507,7 +514,7 @@ impl<'a, 'b: 'a> SimpleUpdateEvaluator<'a, 'b> {
GroundTermPattern::Literal(term) => Some(term.clone().into()), GroundTermPattern::Literal(term) => Some(term.clone().into()),
GroundTermPattern::Triple(triple) => { GroundTermPattern::Triple(triple) => {
Self::convert_ground_triple_pattern(triple, variables, values, dataset)? Self::convert_ground_triple_pattern(triple, variables, values, dataset)?
.map(|t| t.into()) .map(Into::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))

27
lib/src/storage/backend/fallback.rs
Unescape View File

@ -29,20 +29,18 @@ impl Db {
Ok(Self(Arc::new(RwLock::new(trees)))) Ok(Self(Arc::new(RwLock::new(trees))))
} }
#[allow(clippy::unwrap_in_result)]
pub fn column_family(&self, name: &'static str) -> Option<ColumnFamily> { pub fn column_family(&self, name: &'static str) -> Option<ColumnFamily> {
let name = ColumnFamily(name); let name = ColumnFamily(name);
if self.0.read().unwrap().contains_key(&name) { (self.0.read().unwrap().contains_key(&name)).then(|| name)
Some(name)
} else {
None
}
} }
#[must_use] #[must_use]
pub fn snapshot(&self) -> Reader { pub fn snapshot(&self) -> Reader {
Reader(InnerReader::Simple(self.0.clone())) Reader(InnerReader::Simple(Arc::clone(&self.0)))
} }
#[allow(clippy::unwrap_in_result)]
pub fn transaction<'a, 'b: 'a, T, E: Error + 'static + From<StorageError>>( pub fn transaction<'a, 'b: 'a, T, E: Error + 'static + From<StorageError>>(
&'b self, &'b self,
f: impl Fn(Transaction<'a>) -> Result<T, E>, f: impl Fn(Transaction<'a>) -> Result<T, E>,
@ -64,6 +62,7 @@ enum InnerReader {
} }
impl Reader { impl Reader {
#[allow(clippy::unwrap_in_result)]
pub fn get( pub fn get(
&self, &self,
column_family: &ColumnFamily, column_family: &ColumnFamily,
@ -90,6 +89,7 @@ impl Reader {
} }
} }
#[allow(clippy::unwrap_in_result)]
pub fn contains_key( pub fn contains_key(
&self, &self,
column_family: &ColumnFamily, column_family: &ColumnFamily,
@ -120,6 +120,7 @@ impl Reader {
self.scan_prefix(column_family, &[]) self.scan_prefix(column_family, &[])
} }
#[allow(clippy::unwrap_in_result)]
pub fn scan_prefix( pub fn scan_prefix(
&self, &self,
column_family: &ColumnFamily, column_family: &ColumnFamily,
@ -176,19 +177,20 @@ impl Reader {
Ok(Iter { iter, current }) Ok(Iter { iter, current })
} }
#[allow(clippy::unwrap_in_result)]
pub fn len(&self, column_family: &ColumnFamily) -> Result<usize, StorageError> { pub fn len(&self, column_family: &ColumnFamily) -> Result<usize, StorageError> {
match &self.0 { match &self.0 {
InnerReader::Simple(reader) => Ok(reader InnerReader::Simple(reader) => Ok(reader
.read() .read()
.unwrap() .unwrap()
.get(column_family) .get(column_family)
.map_or(0, |tree| tree.len())), .map_or(0, BTreeMap::len)),
InnerReader::Transaction(reader) => { InnerReader::Transaction(reader) => {
if let Some(reader) = reader.upgrade() { if let Some(reader) = reader.upgrade() {
Ok((*reader) Ok((*reader)
.borrow() .borrow()
.get(column_family) .get(column_family)
.map_or(0, |tree| tree.len())) .map_or(0, BTreeMap::len))
} else { } else {
Err(StorageError::Other( Err(StorageError::Other(
"The transaction is already ended".into(), "The transaction is already ended".into(),
@ -198,19 +200,20 @@ impl Reader {
} }
} }
#[allow(clippy::unwrap_in_result)]
pub fn is_empty(&self, column_family: &ColumnFamily) -> Result<bool, StorageError> { pub fn is_empty(&self, column_family: &ColumnFamily) -> Result<bool, StorageError> {
match &self.0 { match &self.0 {
InnerReader::Simple(reader) => Ok(reader InnerReader::Simple(reader) => Ok(reader
.read() .read()
.unwrap() .unwrap()
.get(column_family) .get(column_family)
.map_or(true, |tree| tree.is_empty())), .map_or(true, BTreeMap::is_empty)),
InnerReader::Transaction(reader) => { InnerReader::Transaction(reader) => {
if let Some(reader) = reader.upgrade() { if let Some(reader) = reader.upgrade() {
Ok((*reader) Ok((*reader)
.borrow() .borrow()
.get(column_family) .get(column_family)
.map_or(true, |tree| tree.is_empty())) .map_or(true, BTreeMap::is_empty))
} else { } else {
Err(StorageError::Other( Err(StorageError::Other(
"The transaction is already ended".into(), "The transaction is already ended".into(),
@ -246,7 +249,7 @@ impl Transaction<'_> {
.map_or(false, |cf| cf.contains_key(key))) .map_or(false, |cf| cf.contains_key(key)))
} }
#[allow(clippy::unnecessary_wraps)] #[allow(clippy::unnecessary_wraps, clippy::unwrap_in_result)]
pub fn insert( pub fn insert(
&mut self, &mut self,
column_family: &ColumnFamily, column_family: &ColumnFamily,
@ -269,7 +272,7 @@ impl Transaction<'_> {
self.insert(column_family, key, &[]) self.insert(column_family, key, &[])
} }
#[allow(clippy::unnecessary_wraps)] #[allow(clippy::unnecessary_wraps, clippy::unwrap_in_result)]
pub fn remove(&mut self, column_family: &ColumnFamily, key: &[u8]) -> Result<(), StorageError> { pub fn remove(&mut self, column_family: &ColumnFamily, key: &[u8]) -> Result<(), StorageError> {
self.0 self.0
.borrow_mut() .borrow_mut()

60
lib/src/storage/backend/rocksdb.rs
Unescape View File

@ -4,7 +4,7 @@
use crate::storage::error::{CorruptionError, StorageError}; use crate::storage::error::{CorruptionError, StorageError};
use lazy_static::lazy_static; use lazy_static::lazy_static;
use libc::{self, c_char, c_void, free}; use libc::{self, c_void, free};
use oxrocksdb_sys::*; use oxrocksdb_sys::*;
use rand::random; use rand::random;
use std::borrow::Borrow; use std::borrow::Borrow;
@ -241,7 +241,7 @@ impl Db {
.map(|cf| cf.as_ptr()) .map(|cf| cf.as_ptr())
.collect::<Vec<_>>() .collect::<Vec<_>>()
.as_ptr(), .as_ptr(),
cf_options.as_ptr() as *const *const rocksdb_options_t, cf_options.as_ptr().cast(),
cf_handles.as_mut_ptr(), cf_handles.as_mut_ptr(),
)) ))
.map_err(|e| { .map_err(|e| {
@ -359,7 +359,7 @@ impl Db {
.map(|cf| cf.as_ptr()) .map(|cf| cf.as_ptr())
.collect::<Vec<_>>() .collect::<Vec<_>>()
.as_ptr(), .as_ptr(),
cf_options.as_ptr() as *const *const rocksdb_options_t, cf_options.as_ptr().cast(),
cf_handles.as_mut_ptr(), cf_handles.as_mut_ptr(),
)) ))
.map_err(|e| { .map_err(|e| {
@ -393,11 +393,7 @@ impl Db {
cf_handles, cf_handles,
cf_options, cf_options,
is_secondary: true, is_secondary: true,
path_to_remove: if in_memory { path_to_remove: in_memory.then(|| secondary_path),
Some(secondary_path)
} else {
None
},
})), })),
}) })
} }
@ -424,7 +420,7 @@ impl Db {
.map(|cf| cf.as_ptr()) .map(|cf| cf.as_ptr())
.collect::<Vec<_>>() .collect::<Vec<_>>()
.as_ptr(), .as_ptr(),
cf_options.as_ptr() as *const *const rocksdb_options_t, cf_options.as_ptr().cast(),
cf_handles.as_mut_ptr(), cf_handles.as_mut_ptr(),
0, // false 0, // false
)) ))
@ -580,7 +576,7 @@ impl Db {
} }
let options = rocksdb_readoptions_create_copy(db.read_options); let options = rocksdb_readoptions_create_copy(db.read_options);
Reader { Reader {
inner: InnerReader::PlainDb(db.clone()), inner: InnerReader::PlainDb(Arc::clone(db)),
options, options,
} }
} }
@ -594,7 +590,7 @@ impl Db {
rocksdb_readoptions_set_snapshot(options, snapshot); rocksdb_readoptions_set_snapshot(options, snapshot);
Reader { Reader {
inner: InnerReader::TransactionalSnapshot(Rc::new(TransactionalSnapshot { inner: InnerReader::TransactionalSnapshot(Rc::new(TransactionalSnapshot {
db: db.clone(), db: Arc::clone(db),
snapshot, snapshot,
})), })),
options, options,
@ -698,7 +694,7 @@ impl Db {
db.db, db.db,
db.read_options, db.read_options,
column_family.0, column_family.0,
key.as_ptr() as *const c_char, key.as_ptr().cast(),
key.len(), key.len(),
)) ))
} }
@ -707,7 +703,7 @@ impl Db {
db.db, db.db,
db.read_options, db.read_options,
column_family.0, column_family.0,
key.as_ptr() as *const c_char, key.as_ptr().cast(),
key.len() key.len()
)) ))
} }
@ -740,9 +736,9 @@ impl Db {
db.db, db.db,
db.write_options, db.write_options,
column_family.0, column_family.0,
key.as_ptr() as *const c_char, key.as_ptr().cast(),
key.len(), key.len(),
value.as_ptr() as *const c_char, value.as_ptr().cast(),
value.len(), value.len(),
)) ))
}?; }?;
@ -940,7 +936,7 @@ impl Reader {
inner.db.db, inner.db.db,
self.options, self.options,
column_family.0, column_family.0,
key.as_ptr() as *const c_char, key.as_ptr().cast(),
key.len() key.len()
)) ))
} }
@ -950,7 +946,7 @@ impl Reader {
*inner, *inner,
self.options, self.options,
column_family.0, column_family.0,
key.as_ptr() as *const c_char, key.as_ptr().cast(),
key.len() key.len()
)) ))
} else { } else {
@ -964,7 +960,7 @@ impl Reader {
inner.db, inner.db,
self.options, self.options,
column_family.0, column_family.0,
key.as_ptr() as *const c_char, key.as_ptr().cast(),
key.len() key.len()
)) ))
} }
@ -1005,11 +1001,7 @@ impl Reader {
break; break;
} }
} }
if found { found.then(|| bound)
Some(bound)
} else {
None
}
}; };
unsafe { unsafe {
@ -1021,7 +1013,7 @@ impl Reader {
if let Some(upper_bound) = &upper_bound { if let Some(upper_bound) = &upper_bound {
rocksdb_readoptions_set_iterate_upper_bound( rocksdb_readoptions_set_iterate_upper_bound(
options, options,
upper_bound.as_ptr() as *const c_char, upper_bound.as_ptr().cast(),
upper_bound.len(), upper_bound.len(),
); );
} }
@ -1046,7 +1038,7 @@ impl Reader {
if prefix.is_empty() { if prefix.is_empty() {
rocksdb_iter_seek_to_first(iter); rocksdb_iter_seek_to_first(iter);
} else { } else {
rocksdb_iter_seek(iter, prefix.as_ptr() as *const c_char, prefix.len()); rocksdb_iter_seek(iter, prefix.as_ptr().cast(), prefix.len());
} }
let is_currently_valid = rocksdb_iter_valid(iter) != 0; let is_currently_valid = rocksdb_iter_valid(iter) != 0;
Ok(Iter { Ok(Iter {
@ -1101,7 +1093,7 @@ impl Transaction<'_> {
*self.transaction, *self.transaction,
self.read_options, self.read_options,
column_family.0, column_family.0,
key.as_ptr() as *const c_char, key.as_ptr().cast(),
key.len() key.len()
))?; ))?;
Ok(if slice.is_null() { Ok(if slice.is_null() {
@ -1130,9 +1122,9 @@ impl Transaction<'_> {
ffi_result!(rocksdb_transaction_put_cf_with_status( ffi_result!(rocksdb_transaction_put_cf_with_status(
*self.transaction, *self.transaction,
column_family.0, column_family.0,
key.as_ptr() as *const c_char, key.as_ptr().cast(),
key.len(), key.len(),
value.as_ptr() as *const c_char, value.as_ptr().cast(),
value.len(), value.len(),
))?; ))?;
} }
@ -1152,7 +1144,7 @@ impl Transaction<'_> {
ffi_result!(rocksdb_transaction_delete_cf_with_status( ffi_result!(rocksdb_transaction_delete_cf_with_status(
*self.transaction, *self.transaction,
column_family.0, column_family.0,
key.as_ptr() as *const c_char, key.as_ptr().cast(),
key.len(), key.len(),
))?; ))?;
} }
@ -1177,7 +1169,7 @@ impl Deref for PinnableSlice {
unsafe { unsafe {
let mut len = 0; let mut len = 0;
let val = rocksdb_pinnableslice_value(self.0, &mut len); let val = rocksdb_pinnableslice_value(self.0, &mut len);
slice::from_raw_parts(val as *const u8, len) slice::from_raw_parts(val.cast(), len)
} }
} }
} }
@ -1208,7 +1200,7 @@ pub struct Buffer {
impl Drop for Buffer { impl Drop for Buffer {
fn drop(&mut self) { fn drop(&mut self) {
unsafe { unsafe {
free(self.base as *mut c_void); free(self.base.cast());
} }
} }
} }
@ -1285,7 +1277,7 @@ impl Iter {
unsafe { unsafe {
let mut len = 0; let mut len = 0;
let val = rocksdb_iter_key(self.iter, &mut len); let val = rocksdb_iter_key(self.iter, &mut len);
Some(slice::from_raw_parts(val as *const u8, len)) Some(slice::from_raw_parts(val.cast(), len))
} }
} else { } else {
None None
@ -1311,9 +1303,9 @@ impl SstFileWriter {
unsafe { unsafe {
ffi_result!(rocksdb_sstfilewriter_put_with_status( ffi_result!(rocksdb_sstfilewriter_put_with_status(
self.writer, self.writer,
key.as_ptr() as *const c_char, key.as_ptr().cast(),
key.len(), key.len(),
value.as_ptr() as *const c_char, value.as_ptr().cast(),
value.len(), value.len(),
))?; ))?;
} }

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

@ -1,3 +1,4 @@
#![allow(clippy::same_name_method)]
#[cfg(not(target_family = "wasm"))] #[cfg(not(target_family = "wasm"))]
use crate::model::Quad; use crate::model::Quad;
use crate::model::{GraphNameRef, NamedOrBlankNodeRef, QuadRef, TermRef}; use crate::model::{GraphNameRef, NamedOrBlankNodeRef, QuadRef, TermRef};
@ -181,7 +182,7 @@ impl Storage {
] ]
} }
#[allow(clippy::unnecessary_wraps)] #[allow(clippy::unnecessary_wraps, clippy::unwrap_in_result)]
fn setup(db: Db) -> Result<Self, StorageError> { fn setup(db: Db) -> Result<Self, StorageError> {
let this = Self { let this = Self {
#[cfg(not(target_family = "wasm"))] #[cfg(not(target_family = "wasm"))]
@ -1305,7 +1306,7 @@ impl StorageBulkLoader {
let mut buffer_to_load = Vec::with_capacity(batch_size); let mut buffer_to_load = Vec::with_capacity(batch_size);
swap(buffer, &mut buffer_to_load); swap(buffer, &mut buffer_to_load);
let storage = self.storage.clone(); let storage = self.storage.clone();
let done_counter_clone = done_counter.clone(); let done_counter_clone = Arc::clone(done_counter);
threads.push_back(spawn(move || { threads.push_back(spawn(move || {
FileBulkLoader::new(storage, batch_size).load(buffer_to_load, &done_counter_clone) FileBulkLoader::new(storage, batch_size).load(buffer_to_load, &done_counter_clone)
})); }));

4
lib/src/store.rs
Unescape View File

@ -565,7 +565,7 @@ impl Store {
&self, &self,
quads: impl IntoIterator<Item = impl Into<Quad>>, quads: impl IntoIterator<Item = impl Into<Quad>>,
) -> Result<(), StorageError> { ) -> Result<(), StorageError> {
let quads = quads.into_iter().map(|q| q.into()).collect::<Vec<_>>(); let quads = quads.into_iter().map(Into::into).collect::<Vec<_>>();
self.transaction(move |mut t| t.extend(&quads)) self.transaction(move |mut t| t.extend(&quads))
} }
@ -1569,7 +1569,7 @@ impl BulkLoader {
quads: impl IntoIterator<Item = Result<impl Into<Quad>, EI>>, quads: impl IntoIterator<Item = Result<impl Into<Quad>, EI>>,
) -> Result<(), EO> { ) -> Result<(), EO> {
self.storage self.storage
.load(quads.into_iter().map(|q| q.map(|q| q.into()))) .load(quads.into_iter().map(|q| q.map(Into::into)))
} }
} }

2
lib/tests/store.rs
Unescape View File

@ -175,7 +175,7 @@ fn test_load_dataset() -> Result<(), Box<dyn Error>> {
#[test] #[test]
#[cfg(not(target_family = "wasm"))] #[cfg(not(target_family = "wasm"))]
fn test_bulk_load_dataset() -> Result<(), Box<dyn Error>> { fn test_bulk_load_dataset() -> Result<(), Box<dyn Error>> {
let store = Store::new().unwrap(); let store = Store::new()?;
store store
.bulk_loader() .bulk_loader()
.load_dataset(Cursor::new(GRAPH_DATA), DatasetFormat::TriG, None)?; .load_dataset(Cursor::new(GRAPH_DATA), DatasetFormat::TriG, None)?;

12
python/src/io.rs
Unescape View File

@ -9,6 +9,7 @@ use pyo3::exceptions::{PyIOError, PySyntaxError, PyValueError};
use pyo3::prelude::*; use pyo3::prelude::*;
use pyo3::types::PyBytes; use pyo3::types::PyBytes;
use pyo3::wrap_pyfunction; use pyo3::wrap_pyfunction;
use std::error::Error;
use std::fs::File; use std::fs::File;
use std::io::{self, BufRead, BufReader, BufWriter, Cursor, Read, Write}; use std::io::{self, BufRead, BufReader, BufWriter, Cursor, Read, Write};
@ -289,11 +290,7 @@ impl Read for PyIo {
.map_err(to_io_err)?; .map_err(to_io_err)?;
let bytes = read let bytes = read
.extract::<&[u8]>(py) .extract::<&[u8]>(py)
.or_else(|e| { .or_else(|e| read.extract::<&str>(py).map(str::as_bytes).map_err(|_| e))
read.extract::<&str>(py)
.map(|s| s.as_bytes())
.map_err(|_| e)
})
.map_err(to_io_err)?; .map_err(to_io_err)?;
buf.write_all(bytes)?; buf.write_all(bytes)?;
Ok(bytes.len()) Ok(bytes.len())
@ -325,7 +322,10 @@ fn to_io_err(error: impl Into<PyErr>) -> io::Error {
} }
pub fn map_io_err(error: io::Error) -> PyErr { pub fn map_io_err(error: io::Error) -> PyErr {
if error.get_ref().map_or(false, |s| s.is::<PyErr>()) { if error
.get_ref()
.map_or(false, <(dyn Error + Send + Sync + 'static)>::is::<PyErr>)
{
*error.into_inner().unwrap().downcast().unwrap() *error.into_inner().unwrap().downcast().unwrap()
} else { } else {
PyIOError::new_err(error.to_string()) PyIOError::new_err(error.to_string())

2
python/src/sparql.rs
Unescape View File

@ -225,7 +225,7 @@ impl PyQueryTriples {
Ok(allow_threads_unsafe(|| self.inner.next()) Ok(allow_threads_unsafe(|| self.inner.next())
.transpose() .transpose()
.map_err(map_evaluation_error)? .map_err(map_evaluation_error)?
.map(|t| t.into())) .map(Into::into))
} }
} }

8
python/src/store.rs
Unescape View File

@ -228,10 +228,10 @@ impl PyStore {
extract_quads_pattern(subject, predicate, object, graph_name)?; extract_quads_pattern(subject, predicate, object, graph_name)?;
Ok(QuadIter { Ok(QuadIter {
inner: self.inner.quads_for_pattern( inner: self.inner.quads_for_pattern(
subject.as_ref().map(|p| p.into()), subject.as_ref().map(Into::into),
predicate.as_ref().map(|p| p.into()), predicate.as_ref().map(Into::into),
object.as_ref().map(|p| p.into()), object.as_ref().map(Into::into),
graph_name.as_ref().map(|p| p.into()), graph_name.as_ref().map(Into::into),
), ),
}) })
} }

6
server/src/main.rs
Unescape View File

@ -591,7 +591,7 @@ pub fn main() -> anyhow::Result<()> {
let mut file = BufWriter::new(File::create(&explain_file)?); let mut file = BufWriter::new(File::create(&explain_file)?);
match explain_file match explain_file
.extension() .extension()
.and_then(|e| e.to_str()) { .and_then(OsStr::to_str) {
Some("json") => { Some("json") => {
explanation.write_in_json(file)?; explanation.write_in_json(file)?;
}, },
@ -734,7 +734,7 @@ fn format_from_path<T>(
path: &Path, path: &Path,
from_extension: impl FnOnce(&str) -> anyhow::Result<T>, from_extension: impl FnOnce(&str) -> anyhow::Result<T>,
) -> anyhow::Result<T> { ) -> anyhow::Result<T> {
if let Some(ext) = path.extension().and_then(|ext| ext.to_str()) { if let Some(ext) = path.extension().and_then(OsStr::to_str) {
from_extension(ext).map_err(|e| { from_extension(ext).map_err(|e| {
e.context(format!( e.context(format!(
"Not able to guess the file format from file name extension '{ext}'" "Not able to guess the file format from file name extension '{ext}'"
@ -1636,7 +1636,7 @@ impl<O: 'static, U: (Fn(O) -> io::Result<Option<O>>) + 'static> ReadForWrite<O,
) -> Result<Response, HttpError> { ) -> Result<Response, HttpError> {
let buffer = Rc::new(RefCell::new(Vec::new())); let buffer = Rc::new(RefCell::new(Vec::new()));
let state = initial_state_builder(ReadForWriteWriter { let state = initial_state_builder(ReadForWriteWriter {
buffer: buffer.clone(), buffer: Rc::clone(&buffer),
}) })
.map_err(internal_server_error)?; .map_err(internal_server_error)?;
Ok(Response::builder(Status::OK) Ok(Response::builder(Status::OK)

2
testsuite/src/manifest.rs
Unescape View File

@ -347,7 +347,7 @@ impl<'a> Iterator for RdfListIterator<'a> {
let result = self let result = self
.graph .graph
.object_for_subject_predicate(current, rdf::FIRST) .object_for_subject_predicate(current, rdf::FIRST)
.map(|v| v.into_owned()); .map(TermRef::into_owned);
self.current_node = self.current_node =
match self.graph.object_for_subject_predicate(current, rdf::REST) { match self.graph.object_for_subject_predicate(current, rdf::REST) {
Some(TermRef::NamedNode(n)) if n == rdf::NIL => None, Some(TermRef::NamedNode(n)) if n == rdf::NIL => None,

26
testsuite/src/sparql_evaluator.rs
Unescape View File

@ -287,21 +287,11 @@ fn evaluate_update_evaluation_test(test: &Test) -> Result<()> {
} }
fn load_sparql_query_result(url: &str) -> Result<StaticQueryResults> { fn load_sparql_query_result(url: &str) -> Result<StaticQueryResults> {
if url.ends_with(".srx") { if let Some(format) = url
StaticQueryResults::from_query_results( .rsplit_once('.')
QueryResults::read(read_file(url)?, QueryResultsFormat::Xml)?, .and_then(|(_, extension)| QueryResultsFormat::from_extension(extension))
false, {
) StaticQueryResults::from_query_results(QueryResults::read(read_file(url)?, format)?, false)
} else if url.ends_with(".srj") {
StaticQueryResults::from_query_results(
QueryResults::read(read_file(url)?, QueryResultsFormat::Json)?,
false,
)
} else if url.ends_with(".tsv") {
StaticQueryResults::from_query_results(
QueryResults::read(read_file(url)?, QueryResultsFormat::Tsv)?,
false,
)
} else { } else {
StaticQueryResults::from_graph(&load_graph(url, guess_graph_format(url)?)?) StaticQueryResults::from_graph(&load_graph(url, guess_graph_format(url)?)?)
} }
@ -505,7 +495,7 @@ impl StaticQueryResults {
fn from_graph(graph: &Graph) -> Result<Self> { fn from_graph(graph: &Graph) -> Result<Self> {
// Hack to normalize literals // Hack to normalize literals
let store = Store::new().unwrap(); let store = Store::new()?;
for t in graph.iter() { for t in graph.iter() {
store store
.insert(t.in_graph(GraphNameRef::DefaultGraph)) .insert(t.in_graph(GraphNameRef::DefaultGraph))
@ -617,12 +607,12 @@ fn results_diff(expected: StaticQueryResults, actual: StaticQueryResults) -> Str
format_diff( format_diff(
&expected_variables &expected_variables
.iter() .iter()
.map(|v| v.to_string()) .map(ToString::to_string)
.collect::<Vec<_>>() .collect::<Vec<_>>()
.join("\n"), .join("\n"),
&actual_variables &actual_variables
.iter() .iter()
.map(|v| v.to_string()) .map(ToString::to_string)
.collect::<Vec<_>>() .collect::<Vec<_>>()
.join("\n"), .join("\n"),
"variables", "variables",

Write Preview
Loading…
Cancel
Save