Ontologies

Ontologies are sets of domain concepts. The domain can span both documents (information resources) and abstract/physical things (non-information resources).

Ontologies can import other ontologies, both user-defined and system ones provided by LinkedDataHub. The dataspace's namespace ontology is resolved as a native owl:imports union graph — the transitive closure of its imports — which is cached per ontology URI. No inference is materialized: the terms are served exactly as declared.

An ontology URI is resolved against the store first and the platform's bundled copies second: a document in the admin dataspace that declares the ontology (<uri> a owl:Ontology) is the graph that resolves, even for a vocabulary the platform ships a copy of. That is what lets an imported vocabulary and its annotations live in one document under the vocabulary's own URI.

Package ontologies join the dataspace's imports closure automatically. They are derived from the dataspace's ldh:import declarations at ontology load time and declared as owl:imports of the namespace ontology, so they resolve like any other import. On the first request after the import, the package ontology is materialized: copied verbatim into a document under the admin dataspace's ontologies/ container, named after the package's path (ontologies/editor-taxonomy/ for the taxonomy editor), with the ontology as its foaf:primaryTopic. From then on that document is what the closure resolves the package ontology to, and its constructors, constraints and views are edited like the namespace ontology's. A later change to the published package does not reach the dataspace until the document is deleted, after which the next request materializes the package again.

Main ontology properties:

Imports

The URI of another ontology whose terms are pulled into this ontology's imports closure (owl:imports)

Version

Version identifier of the ontology (owl:versionInfo)

Classes

Classes are RDFS/OWL classes declared in the dataspace's namespace ontology. Their instances live in the dataspace dataset.

The main class properties, explained in the sub-sections below:

Constructors

Queries that construct a new class instance

Constraints

Commands or command templates that validate a class instance

schema:Product spin:constructor :ProductConstructor ;
    spin:constraint :MissingName .

:ProductConstructor a ldh:Constructor ;
    rdfs:label "Product constructor" ;
    dct:title "Product constructor" ;
    sp:text """
        PREFIX schema:  <https://schema.org/>
        PREFIX dct:     <http://purl.org/dc/terms/>
        PREFIX xsd:     <http://www.w3.org/2001/XMLSchema#>

        CONSTRUCT {
            $this dct:title [ a xsd:string ] ;
                schema:name [ a xsd:string ] ;
                schema:identifier [ a xsd:string ] ;
                schema:description [ a xsd:string ] ;
                schema:category [ a schema:ProductGroup ] ;
                schema:provider [ a schema:Corporation ] ;
                schema:offers [ a schema:Offer ] .
        }
        WHERE {}""" ;
    rdfs:isDefinedBy : .

PREFIX rdf:     <http://www.w3.org/1999/02/22-rdf-syntax-ns#>

CONSTRUCT {
  $this rdf:value "<div xmlns=\"http://www.w3.org/1999/xhtml\"></div>"^^rdf:XMLLiteral .
}
WHERE {}

:MissingName a ldh:MissingPropertyValue ;
    rdfs:label "Missing schema:name" ;
    sp:arg1 schema:name ;
    rdfs:isDefinedBy : .

[ a spin:ConstraintViolation ;
    rdfs:label "Missing schema:name" ;
    spin:violationRoot <#this> ;
    spin:violationPath schema:name ] .

Properties

You can define new properties. Like classes, properties are declared in the dataspace's namespace ontology. The expected values of a property on a class are described either with a SPIN property constraint (a mandatory-property check) or with an OWL restriction, both of which the creation and editing forms enforce.

schema:broker a owl:ObjectProperty ;
    rdfs:label "Sales rep";
    rdfs:domain schema:Order ;
    rdfs:range schema:Person ;
    rdfs:isDefinedBy : .

[] a owl:Restriction ;
    owl:onProperty schema:broker ;
    owl:minCardinality 1 ;
    owl:maxCardinality 1 ;
    rdfs:isDefinedBy : .

Importing external vocabularies

The Import ontology action loads an external vocabulary into a document of the admin dataspace and derives instance constructors for its classes. The vocabulary stays in that document, under its own URI and with its own header, and the derived constructors are appended beside it; the document names the vocabulary as its foaf:primaryTopic rather than claiming to be an ontology itself. The dataspace's namespace ontology imports the vocabulary URI, which resolves to that document because it declares the vocabulary — so the constructors are edited where the vocabulary is, and nothing has to be re-fetched from the network or a bundled copy.

Importing the SKOS vocabulary, for example, leaves the target document with content of this shape (abridged):

<> a dh:Item ;
    foaf:primaryTopic <http://www.w3.org/2004/02/skos/core> .    # the document is about the vocabulary

<http://www.w3.org/2004/02/skos/core> a owl:Ontology .          # the vocabulary's own header and terms follow

skos:Concept spin:constructor [ a ldh:Constructor ;
    sp:text """
        PREFIX skos: <http://www.w3.org/2004/02/skos/core#>
        PREFIX xsd:  <http://www.w3.org/2001/XMLSchema#>

        CONSTRUCT {
            $this skos:prefLabel [ a xsd:string ] ;
                skos:broader [ a skos:Concept ] .
        }
        WHERE {}""" ] .                                       # …one derived constructor per class

Management