Format and lint

Author: tobixdev

bench/src/results/benchmark_results.rs

@@ -24,7 +24,13 @@ impl BenchmarkResults {
 
     /// Adds a new run for a given `namer
     pub fn add_run(&mut self, name: BenchmarkName, run: BenchmarkRun) {
-        let runs = self.runs.entry(name).or_insert(BenchmarkRuns::new());
+        let runs = self.runs.entry(name).or_default();
         runs.add_run(run);
     }
 }
+
+impl Default for BenchmarkResults {
+    fn default() -> Self {
+        Self::new()
+    }
+}

bench/src/results/run.rs

@@ -28,12 +28,18 @@ impl BenchmarkRuns {
             self.runs.iter().map(|run| run.duration).sum::<Duration>() / number_of_samples;
 
         Ok(BenchmarkSummary {
-            avg_duration,
             number_of_samples,
+            avg_duration,
         })
     }
 }
 
+impl Default for BenchmarkRuns {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 /// Represents a single run of a benchmark.
 #[derive(Debug, Serialize, Deserialize)]
 pub struct BenchmarkRun {
@@ -51,14 +57,10 @@ pub struct BenchmarkSummary {
 }
 
 impl Display for BenchmarkSummary {
+    #[allow(clippy::use_debug)]
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         writeln!(f, "Benchmark Summary:")?;
         writeln!(f, "Number of Samples: {}", self.number_of_samples)?;
-        write!(
-            f,
-            "Average Duration: {:\
-        ?}",
-            self.avg_duration
-        )
+        write!(f, "Average Duration: {:?}", self.avg_duration)
     }
 }

lib/engine/src/sparql/eval.rs

@@ -27,7 +27,7 @@ pub async fn evaluate_query(
             pattern, base_iri, ..
         } => {
             let (stream, explanation) =
-                graph_pattern_to_stream(ctx.state(), registry, &query, pattern, base_iri).await?;
+                graph_pattern_to_stream(ctx.state(), registry, query, pattern, base_iri).await?;
             Ok((QueryResults::Solutions(stream), explanation))
         }
         spargebra::Query::Construct {
@@ -37,7 +37,7 @@ pub async fn evaluate_query(
             ..
         } => {
             let (stream, explanation) =
-                graph_pattern_to_stream(ctx.state(), registry, &query, pattern, base_iri).await?;
+                graph_pattern_to_stream(ctx.state(), registry, query, pattern, base_iri).await?;
             Ok((
                 QueryResults::Graph(QueryTripleStream::new(template.clone(), stream)),
                 explanation,
@@ -47,7 +47,7 @@ pub async fn evaluate_query(
             pattern, base_iri, ..
         } => {
             let (mut stream, explanation) =
-                graph_pattern_to_stream(ctx.state(), registry, &query, pattern, base_iri).await?;
+                graph_pattern_to_stream(ctx.state(), registry, query, pattern, base_iri).await?;
             let count = stream.next().await;
             Ok((QueryResults::Boolean(count.is_some()), explanation))
         }

lib/engine/src/sparql/explanation.rs

@@ -3,6 +3,7 @@ use datafusion::physical_plan::ExecutionPlan;
 use std::sync::Arc;
 
 #[derive(Debug)]
+#[allow(clippy::struct_field_names)]
 pub struct QueryExplanation {
     /// The initial logical plan created from the SPARQL query.
     pub initial_logical_plan: LogicalPlan,

lib/logical/src/active_graph.rs

@@ -31,11 +31,12 @@ impl EnumeratedActiveGraph {
 }
 
 impl Display for ActiveGraph {
+    #[allow(clippy::use_debug)]
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
             ActiveGraph::DefaultGraph => write!(f, "Default Graph"),
             ActiveGraph::AllGraphs => write!(f, "All Graphs"),
-            ActiveGraph::Union(graphs) => write!(f, "Union of {:?}", graphs),
+            ActiveGraph::Union(graphs) => write!(f, "Union of {graphs:?}"),
             ActiveGraph::AnyNamedGraph => write!(f, "Any Named Graph"),
         }
     }

lib/logical/src/logical_plan_builder.rs

@@ -490,8 +490,8 @@ fn construct_quads_node_for_pattern(
         _ => None,
     };
     let predicate = match pattern.predicate {
-        NamedNodePattern::NamedNode(nn) => Some(nn.into()),
-        _ => None,
+        NamedNodePattern::NamedNode(nn) => Some(nn),
+        NamedNodePattern::Variable(_) => None,
     };
     let object = match pattern.object {
         TermPattern::NamedNode(nn) => Some(nn.into()),

lib/physical/src/quads/physical.rs

@@ -74,7 +74,7 @@ impl ExecutionPlan for QuadsExec {
         self: Arc<Self>,
         children: Vec<Arc<dyn ExecutionPlan>>,
     ) -> DFResult<Arc<dyn ExecutionPlan>> {
-        if children.len() != 0 {
+        if !children.is_empty() {
             return plan_err!("QuadsExec has no child, got {}", children.len());
         }
         Ok(Arc::new((*self).clone()))

lib/storage/src/oxigraph_memory/mod.rs

@@ -4,9 +4,9 @@ mod encoder;
 mod oxigraph_mem_exec;
 mod planner;
 mod quad_storage;
+mod quad_storage_stream;
 mod small_string;
 mod store;
 mod table_provider;
-mod quad_storage_stream;
 
 pub use quad_storage::MemoryQuadStorage;

lib/storage/src/oxigraph_memory/planner.rs

@@ -25,14 +25,17 @@ pub struct OxigraphMemoryQuadNodePlanner {
 
 impl OxigraphMemoryQuadNodePlanner {
     /// Creates a new [OxigraphMemoryQuadNodePlanner].
-    pub fn new(storage: MemoryQuadStorage) -> Self {
+    pub fn new(storage: &MemoryQuadStorage) -> Self {
         Self {
             snapshot: storage.snapshot(),
         }
     }
 
     /// TODO
-    fn enumerate_active_graph(&self, active_graph: &ActiveGraph) -> DFResult<EnumeratedActiveGraph> {
+    fn enumerate_active_graph(
+        &self,
+        active_graph: &ActiveGraph,
+    ) -> DFResult<EnumeratedActiveGraph> {
         let graph_names = match active_graph {
             ActiveGraph::DefaultGraph => vec![GraphName::DefaultGraph],
             ActiveGraph::AllGraphs => {
@@ -90,7 +93,7 @@ impl ExtensionPlanner for OxigraphMemoryQuadNodePlanner {
 impl QuadPatternEvaluator for MemoryStorageReader {
     fn quads_for_pattern(
         &self,
-        graph_name: GraphNameRef<'_>,
+        graph: GraphNameRef<'_>,
         subject: Option<SubjectRef<'_>>,
         predicate: Option<NamedNodeRef<'_>>,
         object: Option<TermRef<'_>>,
@@ -100,7 +103,7 @@ impl QuadPatternEvaluator for MemoryStorageReader {
             subject.map(EncodedTerm::from).as_ref(),
             predicate.map(EncodedTerm::from).as_ref(),
             object.map(EncodedTerm::from).as_ref(),
-            Some(&EncodedTerm::from(graph_name)),
+            Some(&EncodedTerm::from(graph)),
         );
         Ok(Box::pin(QuadIteratorBatchRecordStream::new(
             iterator, batch_size,

lib/storage/src/oxigraph_memory/quad_storage.rs

@@ -7,10 +7,7 @@ use datafusion::catalog::TableProvider;
 use datafusion::physical_planner::ExtensionPlanner;
 use rdf_fusion_common::error::{CorruptionError, StorageError};
 use rdf_fusion_common::QuadStorage;
-use rdf_fusion_model::{
-    GraphNameRef, NamedOrBlankNode, NamedOrBlankNodeRef, Quad, QuadRef
-    ,
-};
+use rdf_fusion_model::{GraphNameRef, NamedOrBlankNode, NamedOrBlankNodeRef, Quad, QuadRef};
 use std::sync::Arc;
 
 #[derive(Clone, Debug)]
@@ -125,6 +122,6 @@ impl QuadStorage for MemoryQuadStorage {
     }
 
     fn planners(&self) -> Vec<Arc<dyn ExtensionPlanner + Send + Sync>> {
-        vec![Arc::new(OxigraphMemoryQuadNodePlanner::new(self.clone()))]
+        vec![Arc::new(OxigraphMemoryQuadNodePlanner::new(self))]
     }
 }