Development/Tutorials/Metadata/Nepomuk/RDFIntroduction
| Tutorial Series | Nepomuk |
| Previous | |
| What's Next | Using the Nepomuk Resource Class Generator |
| Further Reading | Resource Handling with Nepomuk,
Advanced Queries with SPARQL, Sebastian Trueg's Nepomuk Blog |
RDF and Ontologies in Nepomuk
This tutorial is based on the blog entry Nepomuk Appendix A - RDF for Dummies in a Nutshell by Sebastian Trueg.
All ontologies discussed here are installed with the kdelibs. Thus, they are always in the Nepomuk store. In addition their resource URIs can easily be accessed through the Soprano::Vocabulary namespace.
RDF - The Resource Description Framework
RDF describes a way of storing data. While "classical" databases are based on tables RDF data consists on triples and only triples. Each triple, called statement consists of
subject - predicate - object
The subject is a resource, the predicate is a relation, and the object is either another resource or a literal value. A literal can be a string or an integer or a double or any other type defined by XML Schema (actually it is even possible to define custom literal types). Since RDF was born as a web technology all resources and relations are identified by their unique URI. (Meaning they have a namespace often ending in a # and a name. Typically abbreviation such as foo:bar are used.) Thus, a dataset in RDF is basically a graph where resources are the nodes, predicates the links, and literals act as leaves.
RDF defines one important default property: rdf:type which allows to assign a type to a resource.
RDFS - The RDF Schema
RDFS defines a set of resources and properties extending RDF. This extension basically allows to define ontologies. RDFS defines the two important classes rdfs:Resource and rdfs:Class which introduces the distinction between instances and types, as well as properties to define type hierarchies: rdfs:subClassOf and rdfs:subPropertyOf, and rdfs:domain and rdfs:range to specify details when defining properties.
This allows to create new classes and properties much like in object oriented programming. For example:
@PREFIX foo: <http://foo.bar/types#> foo:Human rdf:type rdfs:Class . foo:Woman rdf:type rdfs:Class . foo:Woman rdfs:subClassOf foo:Human . foo:isMotherOf rdf:type rdf:Property . foo:isMotherOf rdfs:domain foo:Woman . foo:isMotherOf rdfs:range foo:Human . foo:Mary rdf:type foo:Woman . foo:Mary foo:isMotherOf foo:Carl .
A simple example of how to define an ontology in RDFS (using the Turtle language). The last two important predicates in RDFS are rdfs:label and rdfs:comment which define human readable names and comments for any resource.
NRL - The Nepomuk Representation Language
NRL was developed in Nepomuk to further extend on RDFS. I will not go into detail and explain everything about NRL but keep to what is important with respect to KDE at the moment.
Most importantly NRL changes triples to quadruples where the fourth "parameter" is another resource defining the graph in which the statement is stored (may be empty which means to store in the "default graph"). This graph (or context as it is called in Soprano) is just another resource which groups a set of statements and allows to "attach" information to this set. NRL defines a set of graph types of which two are important here: nrl:InstanceBase and nrl:Ontology. The first one defines graphs that contain instances and the second one, well you guessed it, defines graphs that contain types and predicates.
To make this clearer let's extend our example with NRL stuff:
@PREFIX foo: <http://foo.bar/types#> foo:graph1 rdf:type nrl:Ontology . foo:graph2 rdf:type nrl:InstanceBase . foo:Human rdf:type rdfs:Class foo:graph1. foo:Woman rdf:type rdfs:Class foo:graph1. foo:Woman rdfs:subClassOf foo:Human foo:graph1 . foo:isMotherOf rdf:type rdf:Property foo:graph1 . foo:isMotherOf rdfs:domain foo:Woman foo:graph1 . foo:isMotherOf rdfs:range foo:Human foo:graph1 . foo:Mary rdf:type foo:Woman foo:graph2 . foo:Mary foo:isMotherOf foo:Carl foo:graph2 .
But making a distinction between ontology and instance resources is not all we gain from contexts.
NAO - The Nepomuk Annotation Ontology
NAO already defines resource types and properties you already encountered in KDE: nao:Tag or nao:rating. But it also defines nao:created which is a property that assigns an xls:dateTime literal to a resource, in our case a graph. This way we store information about when a piece of information was inserted into the Nepomuk repository.
foo:graph1 nao:created "2008-02-12T14:43.022Z"^^<http://www.w3.org/2001/XMLSchema#dateTime> .
Xesam - The Desktop File Metadata Ontology
Xesam is an ontology that has been developed in regards to desktop file indexing tools such as Strigi. It tries to define classes/types and properties for most of the metadata that occurs in files on the desktop. Simple examples include id3 tags or image size or even email data such as sender or recipient. File Metadata indexed by Strigi on the KDE desktop is stored in the Nepomuk repository using Xesam classes and properties.
SPARQL - The Query Language for RDF
SPARQL is what we use to query the RDF repository. Its syntax has been designed close to SQL but since it is quite young it is by far not as powerful yet.
Anyway, this is how a simple query that retrieves the mother of Carl looks like:
prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
prefix foo: <http://foo.bar/types#>
select ?r where { ?r foo:isMotherOf foo:Carl . }
Or if we take NRL into account:
prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
prefix foo: <http://foo.bar/types#>
prefix nrl: <http://semanticdesktop.org/ontologies/2007/08/15/nrl#>
select ?r where { graph ?g { ?r foo:isMotherOf foo:Carl . } . ?g rdf:type nrl:InstanceBase . }