oldaplib 0.2.11__py3-none-any.whl → 0.3.1__py3-none-any.whl

oldaplib/src/project.py

@@ -2,8 +2,9 @@ import json
 from copy import deepcopy
 from dataclasses import dataclass
 from functools import partial
+from pprint import pprint
 
-from typing import List, Self, Any
+from typing import List, Self, Any, Callable
 from datetime import date, datetime
 
 from oldaplib.src.cachesingleton import CacheSingletonRedis
@@ -13,6 +14,7 @@ from oldaplib.src.helpers.context import Context
 from oldaplib.src.enums.action import Action
 from oldaplib.src.dtypes.namespaceiri import NamespaceIRI
 from oldaplib.src.helpers.irincname import IriOrNCName
+from oldaplib.src.helpers.observable_dict import ObservableDict
 from oldaplib.src.helpers.serializer import serializer
 from oldaplib.src.helpers.tools import lprint
 from oldaplib.src.xsd.iri import Iri
@@ -108,7 +110,7 @@ class Project(Model):
     #_attributes: dict[ProjectAttr, ProjectAttrTypes]
     #__changeset: dict[ProjectAttr, ProjectAttrChange]
 
-    __slots__ = ('projectIri', 'projectShortName', 'label', 'comment', 'namespaceIri', 'projectStart', 'projectEnd')
+    __slots__ = ('projectIri', 'projectShortName', 'label', 'comment', 'namespaceIri', 'projectStart', 'projectEnd', 'usesExternalOntology')
 
     def __init__(self, *,
                  con: IConnection,
@@ -174,6 +176,8 @@ class Project(Model):
                 partial(Project._get_value, attr=attr),
                 partial(Project._set_value, attr=attr),
                 partial(Project._del_value, attr=attr)))
+        if self._attributes.get(ProjectAttr.USES_EXTERNAL_ONTOLOGY):
+            self._attributes[ProjectAttr.USES_EXTERNAL_ONTOLOGY].set_on_change(self.eo_notify)
         self._changeset = {}
 
     def update_notifier(self):
@@ -181,6 +185,10 @@ class Project(Model):
             if getattr(value, 'set_notifier', None) is not None:
                 value.set_notifier(self.notifier, attr)
 
+    def eo_notify(self, d: ObservableDict):
+        if not self._changeset.get(ProjectAttr.USES_EXTERNAL_ONTOLOGY):
+            self._changeset[ProjectAttr.USES_EXTERNAL_ONTOLOGY] = AttributeChange(self._attributes[ProjectAttr.USES_EXTERNAL_ONTOLOGY].copy(), Action.MODIFY)
+
     def _as_dict(self):
         return {x.fragment: y for x, y in self._attributes.items()} | super()._as_dict()
 
@@ -231,6 +239,31 @@ class Project(Model):
         """
         self._changeset[attr] = AttributeChange(self._attributes[attr], Action.MODIFY)
 
+    def add_external_ontology(self, ontos: dict[Xsd_NCName, NamespaceIRI]):
+        """
+        Adds external ontologies to the project.
+        :param dict[Xsd_NCName, NamespaceIRI]: Dictionary of external ontologies to add
+        :return: None
+        """
+        if not ontos:
+            return
+        if not self._attributes.get(ProjectAttr.USES_EXTERNAL_ONTOLOGY):
+            self._attributes[ProjectAttr.USES_EXTERNAL_ONTOLOGY] = ObservableDict()
+        for prefix, iri in ontos.items():
+            if not self._changeset[ProjectAttr.USES_EXTERNAL_ONTOLOGY]:
+                self._changeset[ProjectAttr.USES_EXTERNAL_ONTOLOGY] = AttributeChange(self._attributes[ProjectAttr.USES_EXTERNAL_ONTOLOGY].copy(), Action.MODIFY)
+            self._attributes[ProjectAttr.USES_EXTERNAL_ONTOLOGY][prefix] = iri
+
+    def del_external_ontology(self, ontos: list[Xsd_NCName]):
+        if not ontos:
+            return
+        if not self._attributes.get(ProjectAttr.USES_EXTERNAL_ONTOLOGY):
+            raise OldapErrorInconsistency(f'Project {self} has no external ontologies.')
+        for prefix in ontos:
+            if not self._changeset[ProjectAttr.USES_EXTERNAL_ONTOLOGY]:
+                self._changeset[ProjectAttr.USES_EXTERNAL_ONTOLOGY] = AttributeChange(self._attributes[ProjectAttr.USES_EXTERNAL_ONTOLOGY].copy(), Action.MODIFY)
+
+
     @classmethod
     def read(cls,
              con: IConnection,
@@ -295,15 +328,17 @@ class Project(Model):
                     tmp._con = con
                     return tmp
             query += f"""
-                SELECT ?proj ?prop ?val
-                FROM NAMED oldap:admin
+                SELECT ?proj ?prop ?val ?prefix ?iri
                 WHERE {{
                     GRAPH oldap:admin {{
                         ?proj a oldap:Project .
-                        ?proj oldap:projectShortName ?shortname .
+                        ?proj oldap:projectShortName {shortname.toRdf} .
                         ?proj ?prop ?val .
+                        OPTIONAL {{
+                            ?val oldap:prefix ?prefix .
+                            ?val oldap:fullIri ?iri
+                        }}
                     }}
-                    FILTER(?shortname = {shortname.toRdf})
                 }}
             """
         jsonobj = con.query(query)
@@ -320,6 +355,7 @@ class Project(Model):
         comment = LangString()
         projectStart = None
         projectEnd = None
+        usesExternalOntology: dict[Xsd_QName, NamespaceIRI] | None = None
         for r in res:
             if projectIri is None:
                 projectIri = r['proj']
@@ -344,6 +380,10 @@ class Project(Model):
                     projectStart = r['val']
                 case 'oldap:projectEnd':
                     projectEnd = r['val']
+                case 'oldap:usesExternalOntology':
+                    if not usesExternalOntology:
+                        usesExternalOntology = {}
+                    usesExternalOntology[r['prefix']] = NamespaceIRI(r['iri'])
         if label:
             label.changeset_clear()
             label.set_notifier(cls.notifier, Xsd_QName(ProjectAttr.LABEL.value))
@@ -362,7 +402,8 @@ class Project(Model):
                        namespaceIri=namespaceIri,
                        comment=comment,
                        projectStart=projectStart,
-                       projectEnd=projectEnd)
+                       projectEnd=projectEnd,
+                       usesExternalOntology=usesExternalOntology)
         cache = CacheSingletonRedis()
         cache.set(instance.projectIri, instance, instance.projectShortName)
         return instance
@@ -480,7 +521,12 @@ class Project(Model):
         for attr, value in self._attributes.items():
             if not value:
                 continue
-            sparql2 += f' ;\n{blank:{(indent + 3) * indent_inc}}{attr.value.toRdf} {value.toRdf}'
+            if attr == ProjectAttr.USES_EXTERNAL_ONTOLOGY:
+                for prefix, iri in value.items():
+                    sparql2 += f' ;\n{blank:{(indent + 3) * indent_inc}}oldap:usesExternalOntology [ oldap:prefix {prefix.toRdf} ; oldap:fullIri {iri.toRdf} ]'
+                pass
+            else:
+                sparql2 += f' ;\n{blank:{(indent + 3) * indent_inc}}{attr.value.toRdf} {value.toRdf}'
         sparql2 += f' .\n{blank:{(indent + 1) * indent_inc}}}}\n'
         sparql2 += f'{blank:{indent * indent_inc}}}}\n'
 
@@ -520,6 +566,22 @@ class Project(Model):
         :raises OldapErrorUpdateFailed: Raised if the update fails due to timestamp mismatch or other inconsistencies.
         :raises OldapError: Raised for other internal errors.
         """
+
+        def dict_diff(a: dict, b: dict) -> dict:
+            """
+            Compare two dicts and return added, removed, and changed key–values.
+            """
+            a_keys = set(a) if a else set()
+            b_keys = set(b) if b else set()
+            shared = a_keys & b_keys
+
+            return {
+                'added': {k: b[k] for k in b_keys - a_keys},
+                'removed': {k: a[k] for k in a_keys - b_keys},
+                'changed': {k: (a[k], b[k]) for k in shared if a[k] != b[k]},
+                'same': {k: a[k] for k in shared if a[k] == b[k]},
+            }
+
         result, message = self.check_for_permissions()
         if not result:
             raise OldapErrorNoPermission(message)
@@ -545,20 +607,89 @@ class Project(Model):
                                                             field=Xsd_QName(field.value))
                     sparql_list.append(sparql)
                 continue
+            if field == ProjectAttr.USES_EXTERNAL_ONTOLOGY:
+                if change.action == Action.MODIFY:
+                    diff = dict_diff(self._changeset[ProjectAttr.USES_EXTERNAL_ONTOLOGY].old_value, self._attributes[ProjectAttr.USES_EXTERNAL_ONTOLOGY])
+                    #
+                    # first we remove the "removed" and "changed"
+                    #
+                    to_delete = set(diff['removed']) | set(diff['changed'])
+                    for key in to_delete:
+                        sparql = f"""
+                        DELETE {{
+                            GRAPH oldap:admin {{
+                                {self.projectIri.toRdf} oldap:usesExternalOntology ?o .
+                                ?o ?p ?v .
+                            }}
+                        }}
+                        WHERE {{
+                            GRAPH oldap:admin {{
+                                ?o oldap:prefix {key.toRdf} .
+                                ?o oldap:fullIri ?anyiri .
+                            }}
+                        }}
+                        """
+                        sparql_list.append(sparql)
+                    to_add = set(diff['added']) | set(diff['changed'])
+                    sparql = f"""
+                    INSERT DATA {{
+                        GRAPH oldap:admin {{
+                    """
+                    for key in to_add:
+                        sparql += f"   {self.projectIri.toRdf} oldap:usesExternalOntology  [ oldap:prefix {key.toRdf} ; oldap:fullIri {self._attributes[ProjectAttr.USES_EXTERNAL_ONTOLOGY][key].toRdf} ] .\n"
+                    sparql += f"""
+                        }}
+                    }}
+                    """
+                    sparql_list.append(sparql)
+                if change.action == Action.DELETE:
+                    sparql = f"""
+                    DELETE {{
+                        GRAPH oldap:admin {{
+                            {self.projectIri.toRdf} oldap:usesExternalOntology ?o .
+                            ?o ?p ?v .
+                        }}
+                    }}
+                    WHERE {{
+                        GRAPH oldap:admin {{
+                            {self.projectIri.toRdf} oldap:usesExternalOntology ?o .
+                            ?o ?p ?v .
+                        }}
+                    }}
+                    """
+                    sparql_list.append(sparql)
+                if change.action == Action.CREATE:
+                    sparql = f"""
+                    INSERT DATA {{
+                        GRAPH oldap:admin {{
+                    """
+                    for prefix, iri in self._attributes[ProjectAttr.USES_EXTERNAL_ONTOLOGY].items():
+                        sparql += f"   {self.projectIri.toRdf} oldap:usesExternalOntology  [ oldap:prefix {prefix.toRdf} ; oldap:fullIri {iri.toRdf} ] .\n"
+                    sparql += f"""
+                        }}
+                    }}
+                    """
+                    sparql_list.append(sparql)
+                continue
             sparql = f'{blank:{indent * indent_inc}}# Project field "{field.value}" with action "{change.action.value}"\n'
-            sparql += f'{blank:{indent * indent_inc}}WITH oldap:admin\n'
             if change.action != Action.CREATE:
                 sparql += f'{blank:{indent * indent_inc}}DELETE {{\n'
-                sparql += f'{blank:{(indent + 1) * indent_inc}}?project {field.value} {change.old_value.toRdf} .\n'
+                sparql += f'{blank:{(indent + 1) * indent_inc}}GRAPH oldap:admin {{\n'
+                sparql += f'{blank:{(indent + 2) * indent_inc}}?project {field.value} {change.old_value.toRdf} .\n'
+                sparql += f'{blank:{(indent + 1)* indent_inc}}}}\n'
                 sparql += f'{blank:{indent * indent_inc}}}}\n'
             if change.action != Action.DELETE:
                 sparql += f'{blank:{indent * indent_inc}}INSERT {{\n'
-                sparql += f'{blank:{(indent + 1) * indent_inc}}?project {field.value} {self._attributes[field].toRdf} .\n'
+                sparql += f'{blank:{(indent + 1) * indent_inc}}GRAPH oldap:admin {{\n'
+                sparql += f'{blank:{(indent + 2) * indent_inc}}?project {field.value} {self._attributes[field].toRdf} .\n'
+                sparql += f'{blank:{(indent + 1) * indent_inc}}}}\n'
                 sparql += f'{blank:{indent * indent_inc}}}}\n'
             sparql += f'{blank:{indent * indent_inc}}WHERE {{\n'
             sparql += f'{blank:{(indent + 1) * indent_inc}}BIND({self.projectIri.toRdf} as ?project)\n'
             if change.action != Action.CREATE:
-                sparql += f'{blank:{(indent + 1) * indent_inc}}?project {field.value} {change.old_value.toRdf} .\n'
+                sparql += f'{blank:{(indent + 1) * indent_inc}}GRAPH oldap:admin {{\n'
+                sparql += f'{blank:{(indent + 2) * indent_inc}}?project {field.value} {change.old_value.toRdf} .\n'
+                sparql += f'{blank:{(indent + 1) * indent_inc}}}}\n'
             sparql += f'{blank:{indent * indent_inc}}}}'
             sparql_list.append(sparql)
         sparql = context.sparql_context
@@ -570,6 +701,7 @@ class Project(Model):
             self.set_modified_by_iri(Xsd_QName('oldap:admin'), self.projectIri, self.modified, timestamp)
             modtime = self.get_modified_by_iri(Xsd_QName('oldap:admin'), self.projectIri)
         except OldapError:
+            print(sparql)
             self._con.transaction_abort()
             raise
         if timestamp != modtime:

oldaplib/src/propertyclass.py

@@ -66,8 +66,8 @@ Attributes = dict[Iri, PropTypes]
 @serializer
 class HasPropertyData:
     refprop: Iri | None = None
-    minCount: Xsd_integer | None = None
-    maxCount: Xsd_integer | None = None
+    minCount: Xsd_nonNegativeInteger | None = None
+    maxCount: Xsd_nonNegativeInteger | None = None
     order: Xsd_decimal | None = None
     group: Iri | None = None
 
@@ -88,19 +88,16 @@ class HasPropertyData:
         def create_owl(self, indent: int = 0, indent_inc: int = 4):
             blank = ''
             sparql = ''
-            min_count = Xsd_nonNegativeInteger(int(self.minCount)) if self.minCount else None
-            max_count = Xsd_nonNegativeInteger(int(self.maxCount)) if self.maxCount else None
 
-            if min_count and max_count and min_count == max_count:
-                sparql += f' ;\n{blank:{(indent + 1) * indent_inc}}owl:qualifiedCardinality {min_count.toRdf}'
+            if self.minCount and self.maxCount and self.minCount == self.maxCount:
+                sparql += f' ;\n{blank:{(indent + 1) * indent_inc}}owl:qualifiedCardinality {self.minCount.toRdf}'
             else:
-                if min_count:
-                    sparql += f' ;\n{blank:{(indent + 1) * indent_inc}}owl:minQualifiedCardinality {min_count.toRdf}'
-                if max_count:
-                    sparql += f' ;\n{blank:{(indent + 1) * indent_inc}}owl:maxQualifiedCardinality {max_count.toRdf}'
+                if self.minCount:
+                    sparql += f' ;\n{blank:{(indent + 1) * indent_inc}}owl:minQualifiedCardinality {self.minCount.toRdf}'
+                if self.maxCount:
+                    sparql += f' ;\n{blank:{(indent + 1) * indent_inc}}owl:maxQualifiedCardinality {self.maxCount.toRdf}'
             return sparql
 
-
 #@strict
 @serializer
 class PropertyClass(Model, Notify):
@@ -196,8 +193,8 @@ class PropertyClass(Model, Notify):
                  property_class_iri: Iri | str | None = None,
                  notifier: Callable[[PropClassAttr], None] | None = None,
                  notify_data: PropClassAttr | None = None,
-                 statement_property: bool  | Xsd_boolean= False,
-                 external_ontology: bool | Xsd_boolean = False,
+                 _statementProperty: bool | Xsd_boolean= False,
+                 _externalOntology: bool | Xsd_boolean = False,
                  _internal: Iri | None = None,  # DO NOT USE!! Only for serialization!
                  _force_external: bool | None = None,  # DO NOT USE!! Only for serialization!
                  _from_triplestore: bool = False,
@@ -230,12 +227,12 @@ class PropertyClass(Model, Notify):
         :type notifier: Callable[[PropClassAttr], None] | None
         :param notify_data: Data or attribute passed to the notifier function, optional.
         :type notify_data: PropClassAttr | None
-        :param statement_property: Boolean indicating if the property is a statement-property
+        :param _statementProperty: Boolean indicating if the property is a statement-property
             (used for RDF*star statements).
-        :type statement_property: bool
-        :param external_ontology: Boolean indicating whether this property comes from an
+        :type _statementProperty: bool
+        :param _externalOntology: Boolean indicating whether this property comes from an
             external ontology (false by default).
-        :type external_ontology: bool
+        :type _externalOntology: bool
         :param validate: Boolean that determines whether validation is active.
         :type validate: bool
         :param kwargs: Arbitrary additional named arguments that might be used
@@ -255,8 +252,8 @@ class PropertyClass(Model, Notify):
                        validate=validate)
         Notify.__init__(self, notifier, notify_data)
 
-        self._statementProperty = statement_property if isinstance(statement_property, Xsd_boolean) else Xsd_boolean(statement_property, validate=True)
-        self._externalOntology = external_ontology if isinstance(external_ontology, Xsd_boolean) else Xsd_boolean(external_ontology, validate=True)
+        self._statementProperty = _statementProperty if isinstance(_statementProperty, Xsd_boolean) else Xsd_boolean(_statementProperty, validate=True)
+        self._externalOntology = _externalOntology if isinstance(_externalOntology, Xsd_boolean) else Xsd_boolean(_externalOntology, validate=True)
         if self._externalOntology:
             self._force_external = True
         if not isinstance(project, Project):
@@ -322,7 +319,7 @@ class PropertyClass(Model, Notify):
                 self._attributes[PropClassAttr.TYPE] = OwlPropertyType.OwlObjectProperty
                 if self._attributes.get(PropClassAttr.DATATYPE) is not None:
                     raise OldapError(f'Datatype "{self._attributes.get(PropClassAttr.DATATYPE)}" not possible for OwlObjectProperty')
-            else:
+            elif self._attributes.get(PropClassAttr.DATATYPE) is not None:
                 self._attributes[PropClassAttr.TYPE] = OwlPropertyType.OwlDataProperty
 
         #
@@ -348,6 +345,9 @@ class PropertyClass(Model, Notify):
         self.__version = SemanticVersion()
         self.__from_triplestore = _from_triplestore
 
+    def __len__(self) -> int:
+        return len(self._attributes)
+
     def update_notifier(self,
                         notifier: Callable[[PropClassAttr], None] | None = None,
                         notify_data: PropClassAttr | None = None,):
@@ -363,6 +363,8 @@ class PropertyClass(Model, Notify):
             'property_class_iri': self.property_class_iri,
             **({'_internal': self._internal} if self._internal else {}),
             **({'_force_external': self._force_external} if self._force_external else {}),
+            **({'_externalOntology': self._externalOntology} if self._externalOntology else {}),
+            **({'_statementProperty': self._statementProperty} if self._statementProperty else {}),
             '_from_triplestore': self.__from_triplestore,
         }
 
@@ -700,6 +702,8 @@ class PropertyClass(Model, Notify):
             if attributes.get(attriri) is None:
                 attributes[attriri] = XsdSet()
             attributes[attriri].add(r['oo'])
+        elif r['attriri'].fragment == 'or':
+            return  # TODO: ignore sh:or for the moment... It's in SHACL, but we do not yet support it
         else:
             if isinstance(r['value'], Xsd_string) and r['value'].lang is not None:
                 if attributes.get(attriri) is None:
@@ -710,6 +714,7 @@ class PropertyClass(Model, Notify):
                     raise OldapError(f'Invalid value for attribute {attriri}: {err}.')
             else:
                 if attributes.get(attriri) is not None:
+                    print("===>", r)
                     raise OldapError(f'Property ({propiri}) attribute "{attriri}" already defined (value="{r['value']}", type="{type(r['value']).__name__}").')
                 attributes[attriri] = r['value']
 
@@ -1016,11 +1021,12 @@ class PropertyClass(Model, Notify):
             sparql += f'\n{blank:{(indent + 1) * indent_inc}} {bnode} sh:path {self._property_class_iri.toRdf}'
         else:
             sparql += f'\n{blank:{(indent + 1) * indent_inc}}sh:path {self._property_class_iri.toRdf}'
-        sparql += f' ;\n{blank:{(indent + 1) * indent_inc}}schema:version {self.__version.toRdf}'
-        sparql += f' ;\n{blank:{(indent + 1) * indent_inc}}dcterms:creator {self._con.userIri.toRdf}'
-        sparql += f' ;\n{blank:{(indent + 1) * indent_inc}}dcterms:created {timestamp.toRdf}'
-        sparql += f' ;\n{blank:{(indent + 1) * indent_inc}}dcterms:contributor {self._con.userIri.toRdf}'
-        sparql += f' ;\n{blank:{(indent + 1) * indent_inc}}dcterms:modified {timestamp.toRdf}'
+        if len(self._attributes) > 0:
+            sparql += f' ;\n{blank:{(indent + 1) * indent_inc}}schema:version {self.__version.toRdf}'
+            sparql += f' ;\n{blank:{(indent + 1) * indent_inc}}dcterms:creator {self._con.userIri.toRdf}'
+            sparql += f' ;\n{blank:{(indent + 1) * indent_inc}}dcterms:created {timestamp.toRdf}'
+            sparql += f' ;\n{blank:{(indent + 1) * indent_inc}}dcterms:contributor {self._con.userIri.toRdf}'
+            sparql += f' ;\n{blank:{(indent + 1) * indent_inc}}dcterms:modified {timestamp.toRdf}'
         sparql += f' ;\n{blank:{(indent + 1) * indent_inc}}oldap:statementProperty {self._statementProperty.toRdf}'
         sparql += f' ;\n{blank:{(indent + 1) * indent_inc}}oldap:externalOntology {self._externalOntology.toRdf}'
         for prop, value in self._attributes.items():
@@ -1080,6 +1086,8 @@ class PropertyClass(Model, Notify):
     def create_owl_part2(self, *,
                          haspropdata: HasPropertyData | None = None,
                          indent: int = 0, indent_inc: int = 4) -> str:
+        if not (haspropdata.minCount or haspropdata.maxCount or self._attributes.get(PropClassAttr.DATATYPE) or self._attributes.get(PropClassAttr.CLASS)):
+            return ''  # no OWL to be added!
         blank = ''
         sparql = f'{blank:{indent * indent_inc}}[\n'
         sparql += f'{blank:{(indent + 1) * indent_inc}}rdf:type owl:Restriction ;\n'
@@ -1093,13 +1101,14 @@ class PropertyClass(Model, Notify):
             if haspropdata.maxCount:
                 sparql += f' ;\n{blank:{(indent + 1)*indent_inc}}owl:maxQualifiedCardinality {haspropdata.maxCount.toRdf}'
         #
-        # (NOTE: owl:onClass and owl:onDatatype can be used only in a restriction and are "local" to the use
+        # (NOTE: owl:onClass and owl:onDataRange can be used only in a restriction and are "local" to the use
         # of the property within the given resource. However, rdfs:range is "global" for all use of this property!
         #
-        if self._attributes[PropClassAttr.TYPE] == OwlPropertyType.OwlDataProperty:
-            sparql += f' ;\n{blank:{(indent + 1) * indent_inc}}owl:onDatatype {self._attributes[PropClassAttr.DATATYPE].value}'
-        elif self._attributes[PropClassAttr.TYPE] == OwlPropertyType.OwlObjectProperty:
-            sparql += f' ;\n{blank:{(indent + 1) * indent_inc}}owl:onClass {self._attributes[PropClassAttr.CLASS]}'
+        if self._attributes.get(PropClassAttr.DATATYPE) or self._attributes.get(PropClassAttr.CLASS):
+            if self._attributes[PropClassAttr.TYPE] == OwlPropertyType.OwlDataProperty:
+                sparql += f' ;\n{blank:{(indent + 1) * indent_inc}}owl:onDataRange {self._attributes[PropClassAttr.DATATYPE].value}'
+            elif self._attributes[PropClassAttr.TYPE] == OwlPropertyType.OwlObjectProperty:
+                sparql += f' ;\n{blank:{(indent + 1) * indent_inc}}owl:onClass {self._attributes[PropClassAttr.CLASS]}'
         sparql += f' ;\n{blank:{indent * indent_inc}}]'
         return sparql