.

inference/src/logic.rs

@@ -44,9 +44,9 @@ fn run_update(query_name: &str, query: &str, store: &Store, graph_name: GraphNam
 
 pub(crate) fn infer(inferences: usize, store: &Store, graph_name: GraphNameRef<'_>) -> crate::error::Result<usize> {
     let old_count = store.quads_for_pattern(None, None, None, Some(graph_name)).count();
-    run_update("rdfs:subPropertyOf", SUB_PROPERTY_OF_UPDATE, &store, graph_name)?;
-    run_update("rdfs:subClassOf", SUB_CLASS_OF_UPDATE, &store, graph_name)?;
-    run_update("rdfs:domain", DOMAIN_UPDATE, &store, graph_name)?;
+    run_update("rdfs:subPropertyOf", SUB_PROPERTY_OF_UPDATE, store, graph_name)?;
+    run_update("rdfs:subClassOf", SUB_CLASS_OF_UPDATE, store, graph_name)?;
+    run_update("rdfs:domain", DOMAIN_UPDATE, store, graph_name)?;
     let new_count = store.quads_for_pattern(None, None, None, Some(graph_name)).count();
 
     let new_inferences_total = inferences + (new_count - old_count);

inference/src/service.rs

@@ -31,16 +31,15 @@ impl Ontology for OntologyService {
         let span = debug_span!("Load Ontology", old_size = field::Empty, input_size = field::Empty, inferences = field::Empty, new_size = field::Empty).entered();
 
         let request = request.get_ref();
-        let mut response = OntologyLoadResponse::default();
 
-        response.old_size = self.ontology.len()
+        let old_size = self.ontology.len()
             .map_err(|err| Status::internal(err.to_string()))?
             .to_u64()
             .unwrap_or(u64::MAX);
 
         let path = std::path::Path::new(&request.path);
         let store = Store::open_read_only(path).unwrap();
-        response.input_size = store.len()
+        let input_size = store.len()
             .map_err(|err| Status::internal(err.to_string()))?
             .to_u64()
             .unwrap_or(u64::MAX);
@@ -53,18 +52,25 @@ impl Ontology for OntologyService {
             });
         self.ontology.extend(quads).unwrap();
 
-        response.inferences = if request.infer {
+        let inferences = if request.infer {
             crate::logic::infer(0, &self.ontology, ONTOLOGY_GRAPH)
                 .map_err(|err| Status::internal(err.to_string()))?
                 .to_u64()
                 .unwrap_or(u64::MAX)
         } else { 0 };
 
-        response.new_size = self.ontology.len()
+        let new_size = self.ontology.len()
             .map_err(|err| Status::internal(err.to_string()))?
             .to_u64()
             .unwrap_or(u64::MAX);
 
+        let response = OntologyLoadResponse {
+            old_size,
+            input_size,
+            inferences,
+            new_size,
+        };
+
         span.record("old_size", response.old_size);
         span.record("input_size", response.input_size);
         span.record("inferences", response.inferences);
@@ -76,8 +82,7 @@ impl Ontology for OntologyService {
     async fn clear(&self, _request: Request<()>) -> Result<Response<OntologyClearResponse>, Status> {
         let span = debug_span!("Clear Ontology", size = field::Empty).entered();
 
-        let mut response = OntologyClearResponse::default();
-        response.size = self.ontology.len()
+        let size = self.ontology.len()
             .map_err(|err| Status::internal(err.to_string()))?
             .to_u64()
             .unwrap_or(u64::MAX);
@@ -85,6 +90,10 @@ impl Ontology for OntologyService {
         self.ontology.clear()
             .map_err(|err| Status::internal(err.to_string()))?;
 
+        let response = OntologyClearResponse {
+            size,
+        };
+
         span.record("size", response.size);
 
         Ok(Response::new(response))