.

graph/src/indexer.rs

@@ -1,16 +1,12 @@
 use rayon::iter::ParallelIterator;
 use std::collections::{HashMap, HashSet};
 use oxigraph::model::{Graph, NamedNode, TermRef, NamedOrBlankNodeRef, NamedNodeRef};
-use oxigraph::sparql::results::{QueryResultsFormat, QueryResultsParser, SliceQueryResultsParserOutput};
 use rayon::iter::IntoParallelRefIterator;
-use gl_inference::tonic::transport::Channel;
-use gl_inference::proto::ontology_client::OntologyClient;
-use gl_inference::proto::OntologyQueryRequest;
 use gl_search::{Field, OwnedValue, Schema};
 use crate::class::Class;
 use crate::{helpers, vocab, CurieHelper};
-use crate::helpers::{term_as_str, term_to_named_node};
 use crate::language::LanguageCondition;
+use crate::ontology::ResourceDescription;
 
 pub struct Indexer<'a> {
     language: LanguageCondition,
@@ -83,7 +79,7 @@ impl<'a> Indexer<'a> {
         ])
     }
 
-    pub fn graph(&self, graph: &Graph) -> crate::Result<Vec<HashMap<Field, OwnedValue>>> {
+    pub fn graph(&self, graph: &Graph) -> Vec<HashMap<Field, OwnedValue>> {
         let mut entities_and_types = HashSet::new();
         let triples = graph.triples_for_predicate(vocab::rdf::TYPE);
         for triple in triples {
@@ -119,85 +115,42 @@ impl<'a> Indexer<'a> {
                 })
             }).collect();
 
-        Ok(results)
+        results
     }
 
-    pub async fn ontology(&self, client: &mut OntologyClient<Channel>) -> crate::Result<Vec<HashMap<Field, OwnedValue>>> {
-        let filter = LanguageCondition::filter([
-            (String::from("label"), self.language.clone()),
-            (String::from("description"), self.language.clone()),
-        ]);
+    pub fn ontology(&self, entities: HashMap<NamedNode, (NamedNode, ResourceDescription)>) -> Vec<HashMap<Field, OwnedValue>> {
+        let label_field = Schema::field("label", self.language.primary_language());
+        let definition_field = Schema::field("definition", self.language.primary_language());
 
-        let mut request = OntologyQueryRequest::default();
-        request.sparql_query = Some(format!(r#"PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
-PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
-PREFIX skos: <http://www.w3.org/2004/02/skos/core#>
-
-SELECT ?class ?subject ?label ?description WHERE {{
-    VALUES ?class {{ rdf:Property rdfs:Class skos:Concept }}
-    ?subject a ?class ;
-    	rdfs:label ?label .
-
-    OPTIONAL {{ ?subject rdfs:comment ?comment }}
-    OPTIONAL {{ ?subject skos:definition ?definition }}
-    BIND(COALESCE(?definition, ?comment) AS ?description)
-    {filter}
-}}"#));
-
-        let response = client.query(request).await?;
-        let parser_output = QueryResultsParser::from_format(QueryResultsFormat::Json)
-            .for_slice(&response.get_ref().results)?;
-
-        let mut results = Vec::new();
-        if let SliceQueryResultsParserOutput::Solutions(solutions) = parser_output {
-            let primary_language = self.language.primary_language();
-            let label_field = Schema::field("label", primary_language);
-            let definition_field = Schema::field("definition", primary_language);
-            for solution in solutions.filter_map(Result::ok) {
+        entities.iter()
+            .map(|(subject, (class, description))| {
                 let mut document = HashMap::with_capacity(4);
 
-                let discriminant = solution
-                    .get("class")
-                    .and_then(term_to_named_node)
-                    .and_then(Class::try_from_named_node)
+                let discriminant = Class::try_from_named_node(class)
                     .map(|doc_type| doc_type as u64)
                     .map(OwnedValue::U64)
                     .unwrap_or(OwnedValue::Null);
                 document.insert(Schema::discriminant_field(), discriminant);
 
-                let subject_str = solution
-                    .get("subject")
-                    .and_then(term_to_named_node)
-                    .map(NamedNode::as_str);
-
-                let curie = subject_str
-                    .and_then(|subject| self.curie_helper.abbreviate(None, subject))
+                let curie = self.curie_helper.abbreviate(None, subject.as_str())
                     .map(OwnedValue::Str)
                     .unwrap_or(OwnedValue::Null);
                 document.insert(Schema::curie_field(), curie);
 
-                let subject = subject_str
-                    .map(OwnedValue::from)
-                    .unwrap_or(OwnedValue::Null);
+                let subject = OwnedValue::from(subject.as_str());
                 document.insert(Schema::iri_field(), subject);
 
-                let label = solution
-                    .get("label")
-                    .and_then(term_as_str)
+                let label = description.label.clone()
                     .map(OwnedValue::from)
                     .unwrap_or(OwnedValue::Null);
                 document.insert(label_field, label);
 
-                let definition = solution
-                    .get("description")
-                    .and_then(term_as_str)
+                let definition = description.description.clone()
                     .map(OwnedValue::from)
                     .unwrap_or(OwnedValue::Null);
                 document.insert(definition_field, definition);
 
-                results.push(document);
-            }
-        }
-        Ok(results)
+                document
+            }).collect()
     }
 }