Let’s start with the Query API of ActiveRDF that match SPARQL. If you
don’t understand a word, start reading the related entries or drop me a mail.
First of everything, the model (rdfs).
I’ve made a little UML schema to help you. RDF
Schema is similar to UML, but it’s a graph.
There is:
- a
Person
- with a
name
- a
Student
- who is a
Person
- a
Teacher
- who is a
Person too
- a
Course
- with a
name, one Teacher and zero or more Students
The cardinality cannot be achieved with RDF Schema, OWL is the right (but
not the only) way to put cardinality on a schema.
Now the data, a nice graph with two students, a professor and a course :
Our first query gonna be very trivial. (Already done by ActiveRDF in fact)
Namespace.register :simples, \
'http://yoan.dosimple.ch/beta/simple.rdfs#'
# rdf:type and simples:Teacher
type = Namespace.lookup(:rdf,:type)
teacher = Namespace.lookup(:simples, :Teacher)
# the same than: SIMPLES::Teacher.find_all
puts Query.new.distinct(:name) \
.where(:name, type, teacher) \
.execute
# output:
#<http://yoan.dosimple.ch/beta/simple.rdf#professor>
Find every teacher. Now we gonna try to find the students’ name :
# simples:Student and simples:name
student = Namespace.lookup(:simples, :Student)
name = Namespace.lookup(:simples, :name)
puts Query.new.distinct(:name) \
.where(:s, type, student) \
.where(:s, name, :name) \
.execute
# output:
#Yoan Blanc
#Batiste Bieler
So easy ! Next, a bigger query on the whole graph!
# simples:teacher, simples:students
teach = Namespace.lookup(:simples, :teacher)
study = Namespace.lookup(:simples, :student)
puts Query.new.distinct(:cname, :tname). \
where(:s, name, "Yoan Blanc"). \
where(:c, study, :s). \
where(:c, name, :cname). \
where(:c, teach, :t). \
where(:t, name, :tname). \
execute
# output:
#RDF and RDF Schema
#Professor’s name
Find every courses of the student called “Yoan Blanc” and return
the name of the course and the teacher’s name of them.
Next step of that is to build a Web Application that use a Semantic
Database as backend. I wanna play with FOAF (for the social part),
SKOS
(for the tagging) and maybe a homemade RDF Schema inspired by
Annotea. Sounds like the first web 2.0 application I’ve
met years ago. Keep it touch.
Fonçons dans une fonctionnalité de ActiveRDF, les requêtes (Query) qui permettent à la manière de
SQL d’extraire une vue de nos données. L’écriture est très similaire à
SPARQL car
la philosophie derrière est la même. Si vous n’avez pas compris un traitre
mot de la phrase ci-dessus, cette entrée fait partie d’une série, lisez
donc les articles relatifs (voir à la fin).
Pour faire des requêtes, il est bien important de connaître le modèle.
J’ai réalisé une schéma selon le formalisme UML ci-contre. RDF Schema
remplit plus ou moins la fonction de UML, mais avec la contrainte du graphe.
Le modèle contient des étudiants, des professeurs (qui sont des personnes)
ainsi que des cours. Un cours possède un professeur et n étudiants.
En passant, les contraintes de cardinalité ne peuvent être satisfaite avec
RDF Schema seul, OWL permet
lui de les décrire.
Ensuite, selon ce modèle, nos données. Donc au plus simple avec deux
étudiants qui assistent à un cours dispensé par un professeur. Sur ces
données qui respectent notre modèle, nous allons effectuer des requêtes
simples. Merci de basculer sur la zone anglophone pour les détails
du code et les schémas.
La première requête qui est un fonction incluse dans ActiveRDF
(.find_all) va retourner tous les professeurs.
La seconde, le nom de tous les étudiants.
Et la dernière, qui est intéressante car elle touche tous le graphe,
tous les cours que suit l’étudiant « Yoan Blanc »
en retournant le nom du cours ainsi que le nom du professeur dispensant
ce dernier.
Je pense qu’il y a maintenant tous les outils nécessaire à la création
d’une application web avec un backend sémantique. J’ai l’envie
de me lancer avec FOAF, SKOS et un dérivé d’Annotea... Que cela vous
inspire-t-il ? Plus de détails tantôt.
