.

publish/src/rdf/ontology.rs

@@ -1,15 +1,16 @@
 use crate::error;
 use crate::rdf::vocab::gl;
 use oxigraph::model::vocab::{rdf, rdfs, xsd};
-use oxigraph::model::{LiteralRef, NamedNode, NamedNodeRef, NamedOrBlankNode, NamedOrBlankNodeRef, Term, TermRef, Triple, TripleRef};
+use oxigraph::model::{Dataset, LiteralRef, NamedNode, NamedNodeRef, NamedOrBlankNode, NamedOrBlankNodeRef, Term, TermRef, Triple, TripleRef};
 use oxigraph::sparql::{QueryResults, SparqlEvaluator};
-use std::collections::{BTreeMap, HashMap, HashSet};
+use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
 use std::fmt::Display;
 use std::path::{Path, PathBuf};
 use std::sync::LazyLock;
 use oxigraph::store::Store;
-use tracing::debug_span;
+use tracing::{debug_span, info};
 use crate::rdf::{conversion, materialize};
+use crate::rdf::conversion::{quad_into_term, term_into_named_node, term_into_string, term_to_named_node};
 use crate::rdf::language::LanguageCondition;
 
 static PREFIXES: LazyLock<BTreeMap<String, String>> = LazyLock::new(|| {
@@ -114,14 +115,6 @@ impl Display for LabeledIri {
     }
 }
 
-#[derive(Clone, Debug)]
-pub struct Entity {
-    pub label: String,
-    pub comment: Option<String>,
-    pub catalog_id: u64,
-    pub properties: HashSet<NamedNode>,
-}
-
 #[derive(Clone, Debug)]
 pub struct IndexField {
     pub name: String,
@@ -148,13 +141,13 @@ impl Ontology {
         let language_filter = language.to_filter_expression("fieldValue");
         let query = format!(r#"SELECT ?individual ?catalogId ?fieldName ?fieldValue
 WHERE {{
-    ?entity a gl:Entity ;
+    ?class a gl:SearchableClass ;
     gl:catalogId ?catalogId ;
     gl:associatedProperty ?property .
 
     ?property gl:indexedByField/gl:fieldName ?fieldName .
 
-    ?individual a ?entity ;
+    ?individual a ?class ;
     ?property ?fieldValue .
 
     {language_filter}
@@ -250,9 +243,9 @@ WHERE {{
     pub fn info(&self, iri: &NamedNode, language: &LanguageCondition) -> LabeledIri {
         let label = self.store.quads_for_pattern(Some(iri.as_ref().into()), Some(rdfs::LABEL), None, None)
             .filter_map(Result::ok)
-            .map(conversion::quad_into_term)
+            .map(quad_into_term)
             .filter(|term| language.primary_matches_term(term))
-            .filter_map(conversion::term_into_string)
+            .filter_map(term_into_string)
             .next()
             .unwrap_or_default();
 
@@ -262,15 +255,15 @@ WHERE {{
         }
     }
 
-    pub fn labeled_entities(&self, language: &LanguageCondition) -> impl Iterator<Item = LabeledIri> {
-        self.store.quads_for_pattern(None, Some(rdf::TYPE), Some(gl::ENTITY.into()), None)
+    pub fn searchable_classes(&self, language: &LanguageCondition) -> impl Iterator<Item = LabeledIri> {
+        self.store.quads_for_pattern(None, Some(rdf::TYPE), Some(gl::SEARCHABLE.into()), None)
             .filter_map(Result::ok)
             .filter_map(|quad| {
                 let label = self.store.quads_for_pattern(Some(quad.subject.as_ref().into()), Some(rdfs::LABEL), None, None)
                     .filter_map(Result::ok)
-                    .map(conversion::quad_into_term)
+                    .map(quad_into_term)
                     .filter(|term| language.primary_matches_term(term))
-                    .filter_map(conversion::term_into_string)
+                    .filter_map(term_into_string)
                     .next();
                 if let Some(label) = label && let NamedOrBlankNode::NamedNode(subject) = quad.subject {
                     Some(LabeledIri {
@@ -281,6 +274,15 @@ WHERE {{
             })
     }
 
+    pub fn subclasses_of(&self, class: &NamedNode) -> BTreeSet<NamedNode> {
+        self.store.quads_for_pattern(None, Some(rdfs::SUB_CLASS_OF), Some(class.into()), None)
+            .filter_map(Result::ok)
+            .filter_map(|quad| if let NamedOrBlankNode::NamedNode(subject) = quad.subject {
+                Some(subject)
+            } else { None })
+            .collect()
+    }
+
     pub fn datatypes(&self) -> impl Iterator<Item = NamedNode> {
         self.store
             .quads_for_pattern(
@@ -311,6 +313,17 @@ WHERE {{
             .count() >= 1
     }
 
+    pub fn exclude_read_only(&self) -> impl Fn(TripleRef<'_>) -> bool + 'static {
+        let true_term = TermRef::Literal(LiteralRef::new_typed_literal("true", xsd::BOOLEAN));
+        let dataset = self.store
+            .quads_for_pattern(None, Some(gl::READ_ONLY), Some(true_term), None)
+            .filter_map(Result::ok)
+            .collect::<Dataset>();
+        move |triple| {
+            dataset.quads_for_subject(triple.subject).count() == 0
+        }
+    }
+
     pub fn template_triples<'a>(
         &'a self,
         class: NamedNodeRef<'a>,