rdf:type

Vous pouvez rencontrer dans les requêtes SPARQL le mot "a", qui est l’abréviation du prédicat <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> (ou rdf:type)

Utilisation

Le prédicat rdf:type sert à sélectionner l’objet en fonction de son type. C'est donc un prédicat qui est souvent utilisé au sein des requêtes, d'où cette abréviation.

Écriture

Attention, c’est "a" minuscule. Écrire A peut entraîner une erreur.

Sujet

De plus, le sujet des triplets est souvent répété dans une requête pour écrire plusieurs conditions sur ce même sujet. Ainsi, le caractère ";" évite de retaper le sujet des triplets suivants.

Exemple de triplets sans ";"

:book1  dc:title  "SPARQL Tutorial" .
:book1  ns:price  42 .
:book1  foaf:homepage   <http://example.org/book/sparql> .

Les mêmes triplets avec l’utilisation de ";"

:book1  dc:title  "SPARQL Tutorial" ;
        ns:price  42 ;
        foaf:homepage   <http://example.org/book/sparql> .

Prédicat

Pour les mêmes raisons mais pour éviter d'écrire le même prédicat, vous pouvez utiliser le caractère ",". Par exemple :

:book1  dc:author  "Michel" .
:book1  dc:author  "Paul" .

Est équivalent à

:book1  dc:author  "Michel" , "Paul" .

ORDER BY

ORDER BY permet d'ordonner le résultat de la requête. Il suffit de lui donner en argument la colonne selon laquelle il doit ordonner les résultats.

Exemple avec ORDER BY

SELECT ?familyName 
WHERE {
      ?x foaf:familyName ?familyName . 
} 
ORDER BY ?familyName

Vous constatez qu'en effet, c’est ordonné selon l’ordre des noms, mais vous pouvez également spécifier plusieurs colonnes pour l'ordonnancement du résultat. Par exemple par nom puis par prénom :

Exemple avec plusieurs colonnes

SELECT ?familyName ?givenName
WHERE {
   ?x foaf:familyName ?familyName ;
      foaf:givenName ?givenName .
 } 
ORDER BY ?familyName ?givenName

Si vous voulez trier une colonne par ordre inverse, il vous suffit d'ajouter le mot-clef DESC devant le nom de la colonne concernée entre parenthèses. Par exemple la même requête qu'au dessus avec les noms triés par ordre inverse :

Exemple avec les noms triés par ordre inverse

SELECT ?familyName  ?givenName
WHERE {
   ?x foaf:familyName ?familyName ;
      foaf:givenName ?givenName .
 } 
ORDER BY  DESC(?familyName) ?givenName

 Non ORDER BY permet de trier selon les colonnes récupérées uniquement. Ainsi, la requête suivante n’est pas conforme, étant donné que la colonne "givenName" ne fait pas partie des colonnes rapatriées (dans la clause SELECT).

Requête non conforme car ?givenName n’est pas dans la clause SELECT

SELECT ?familyName
WHERE {
   ?x foaf:familyName ?familyName ;
      foaf:givenName ?givenName .
 } 
ORDER BY ?familyName ?givenName

LIMIT

LIMIT permet de limiter le nombre de lignes retournées.

Exemple de requête avec une limite

SELECT * 
WHERE { 
     ?x ?y ?z . 
} 
LIMIT 10

Utilisation

N'hésitez pas à l’utiliser, car dans beaucoup de cas cela vous permettra d'obtenir des temps de réponse plus faibles du serveur interrogé.

OFFSET

OFFSET permet de n'afficher le résultat qu’à partir de la ligne indiquée.

Exemple de requête qui ne donne le résultat qu’à partir de la cinquième ligne

SELECT * 
WHERE {
     ?x ?y ?z . 
} 
OFFSET 5

On peut indiquer en même temps une LIMIT et un OFFSET.

Exemple qui n'affiche que 10 lignes de résultat à partir de la ligne 5

SELECT * 
WHERE {
    ?x ?y ?z . 
} 
OFFSET 5 
LIMIT 10

On a maintenant tout ce qu’il nous faut pour naviguer de page en page dans les résultats d'une requête.

Écrire une requête simple

L'exemple ci-dessous montre une requête SPARQL pour trouver le titre d'un livre à partir du graphe des données RDF suivant, décrit au format Turtle. La requête se compose de deux parties :

1. la clause SELECT identifie les variables à faire apparaître dans la réponse de cette requête,
2. et la clause WHERE fournit le masque du graphe à appliquer sur le graphe des données RDF pour chercher cette réponse.

Le masque du graphe, dans cet exemple, est constitué d'un triplet avec une seule variable "?Titre" à l'endroit du triplet où l’objet est attendu.

Dans le graphe RDF/Turtle :

<http://example.org/book/book1> <http://purl.org/dc/elements/1.1/title> "Tutoriel SPARQL".

On applique la requête SPARQL :

#Ma première requête
SELECT ?titre
WHERE
{
   <http://example.org/book/book1> <http://purl.org/dc/elements/1.1/title> ?titre.
}

Cette requête sur les données ci-dessus a une seule solution.

Résultat de la requête :

Obtenir plusieurs réponses

Le résultat d'une requête est un tableau où chaque ligne représente une solution différente, qui correspond à un sous-graphe trouvé à l'aide du masque de la requête. Il peut y avoir zéro, une ou plusieurs solutions à une requête.

Chaque ligne contient la liste des variables indiquées dans la clause SELECT de la requête. Pour chaque solution, il existe une ligne dans la solution et chaque ligne affichera la valeur qu'a dû prendre chaque variable de la clause SELECT pour trouver cette solution.

Dans le graphe RDF/Turtle :

@prefix foaf:  <http://xmlns.com/foaf/0.1/> .

<http://jlow.me>  foaf:name   "Johnny Lee Outlaw" .
<http://jlow.me>  foaf:mbox   <mailto:jlow@jlow.me> .
<http://peter.me>  foaf:name   "Peter Goodguy" .
<http://peter.me>  foaf:mbox   <mailto:peter@peter.me> .
<http://carol.me>  foaf:mbox   <mailto:carol@carol.me> .

On applique la requête SPARQL :

PREFIX foaf:   <http://xmlns.com/foaf/0.1/>
SELECT ?name ?mbox
WHERE
  { ?x foaf:name ?name .
    ?x foaf:mbox ?mbox }

Résultat de la requête:

Littéral avec une balise de langue

Précédée du symbole @, la balise de langue qui suit un littéral permet de faire cohabiter dans une même base de données plusieurs langues et permet d'obtenir toutes les langues disponibles à travers une simple requête.

Cependant, quand on compare un littéral, il est alors indispensable de ne pas oublier la balise de langue sous peine de n'obtenir aucune solution.

Ainsi, la requête :

SELECT ?v WHERE { ?v ?p "cat" }

ne donne aucune réponse, car elle ne précise pas la balise de la langue contenue dans les données interrogées.

mais la requête :

SELECT ?v WHERE { ?v ?p "cat"@en }

donne la solution :

Littéral avec un type numérique

Les entiers, dans une requête SPARQL, sont implicitement de type xsd:integer.
Exemple: le littéral 42 est équivalent à l'écriture
"42"^^<http://www.w3.org/2001/XMLSchema#integer>.

Ainsi, la requête :

SELECT ?v WHERE { ?v ?p 42 }

donne la solution :

Littéral avec un type arbitraire

La base de données n'a pas besoin de comprendre ce que représente un type pour l'enregistrer ou pour le retrouver. La base de données va simplement comparer la forme lexicale et la référence IRI du type avec les données qu'elle contient.

Ainsi, la requête :

SELECT ?v WHERE { ?v ?p "abc"^^<http://example.org/datatype#specialDatatype> }

donne la solution :

Littéral texte

regex() est une fonction qui permet d’utiliser une expression régulière pour vérifier une chaîne de caractères sans balise de langue.

Exemple de requête SPARQL :

PREFIX  dc:  <http://purl.org/dc/elements/1.1/>
SELECT  ?title
WHERE   { ?x dc:title ?title
          FILTER regex(?title, "^SPARQL") 
        }

Résultat de la requête:

Pour appliquer cette contrainte à tout littéral sans se soucier de la balise de langue, on utilise la fonction str().

Ainsi, la requête SPARQL devient :

PREFIX  dc:  <http://purl.org/dc/elements/1.1/>
SELECT  ?title
WHERE   { ?x dc:title ?title
          FILTER regex(str(?title), "^SPARQL") 
        }

Et le résultat de la requête fait apparaitre deux résultats:

On peut également appliquer l'option "insensible à la casse" à notre expression régulière, avec le paramètre "i".

Par exemple, la requête SPARQL devient :

PREFIX  dc:  <http://purl.org/dc/elements/1.1/>
SELECT  ?title
WHERE   { ?x dc:title ?title
          FILTER regex(str(?title), "web", "i" ) 
        }

Et voici résultat de la requête :

Littéral numérique

La clause FILTER peut vérifier des conditions numériques.

Par exemple la requête SPARQL :

PREFIX  dc:  <http://purl.org/dc/elements/1.1/>
PREFIX  ns:  <http://example.org/ns#>
SELECT  ?title ?price
WHERE   { ?x ns:price ?price .
          FILTER (?price < 30.5)
          ?x dc:title ?title . }

donnera le résultat:

Les autres littéraux

La clause FILTER peut utiliser de nombreuses fonctions et des opérateurs booléens que nous étudierons dans une future leçon. Si vous cherchez une fonction particulière, vous pourrez la trouver, en attendant, dans la documentation de SPARQL ().

Jointure basique

A . B

Considérer A et B comme des graphes. "A.B" représente une jointure, rassemblant les résultats de A et B en fonction des variables en commun.

Les points qui séparent les triplets dans la clause WHERE représentent des jointures basiques.

Jointure à gauche

A OPTIONAL { B }

Considérer A et B comme des graphes. "A OPTIONAL { B }" représente une jointure à gauche. Il rassemble les résultats de A et B en fonction des variables en commun, si possible. Il garde toutes les solutions de A s’il y a ou non des résultats dans B.

Un masque peut contenir des clauses optionnelles qui permettent d'ajouter des solutions, sans exclure les solutions qui existent sans nécessairement respecter ces clauses.

Utilisons le graphe RDF/Turtle suivant :

@prefix foaf:       <http://xmlns.com/foaf/0.1/> .
@prefix rdf:        <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .

<http://alice.me>   rdf:type        foaf:Person .
<http://alice.me>   foaf:name       "Alice" .
<http://alice.me>   foaf:mbox       <mailto:alice@example.com> .
<http://alice.me>   foaf:mbox       <mailto:alice@work.example> .

<http://bob.me>   rdf:type        foaf:Person .
<http://bob.me>  foaf:name       "Bob" .

Ainsi la requête :

PREFIX foaf: <http://xmlns.com/foaf/0.1/>
SELECT ?name ?mbox
WHERE  { ?x foaf:name  ?name .
         OPTIONAL { ?x  foaf:mbox  ?mbox }
       }

donne la solution :

Pour "Bob", il n'y a pas de valeur pour la variable mbox, car la clause optionnelle n’est pas vérifiée pour "Bob" .

On peut mettre plusieurs clauses OPTIONAL dans une requête.

Par exemple, avec le graphe RDF/Turtle suivant :

@prefix foaf:   <http://xmlns.com/foaf/0.1/> .
@prefix dc:   <http://purl.org/dc/elements/1.1/> .
@prefix :     <http://example.org/book/> .
@prefix ns:   <http://example.org/ns#> .

:book1  dc:title  "SPARQL Tutorial" .
:book1  ns:price  42 .
:book1  foaf:homepage   <http://example.org/book/sparql> .

:book2  dc:title  "The Semantic Web" .
:book2  ns:price  23 .

:book3  dc:title  "MediaWiki" .
:book3  ns:price  28 .

Ainsi, la requête :

PREFIX  foaf: <http://xmlns.com/foaf/0.1/> 
PREFIX  dc:  <http://purl.org/dc/elements/1.1/>
PREFIX  ns:  <http://example.org/ns#>
SELECT  ?title ?price ?hpage
WHERE   { ?x dc:title ?title .
          OPTIONAL { ?x ns:price ?price . FILTER (?price > 25) }.
          OPTIONAL { ?x foaf:homepage ?hpage }
        }

donne la solution :

Addition

{ A } UNION { B }

Considérer A et B comme des graphes. "{ A } UNION { B } " représente une addition. Il rassemble les résultats de A et B sans condition.

Il arrive que les données que l’on désire atteindre soient enregistrées à des moments différents et donc probablement avec des ontologies différentes, c'est-à-dire dans des graphes de structures différentes.

Le mot clé UNION permet d’utiliser la même variable dans des masques différents sans exclusion mutuelle.

Par exemple, avec le graphe RDF/Turtle suivant :

@prefix :     <http://example.org/book/> .
@prefix dc10:  <http://purl.org/dc/elements/1.0/> .
@prefix dc11:  <http://purl.org/dc/elements/1.1/> .

:a  dc10:title     "SPARQL Query Language Tutorial" .
:a  dc10:creator   "Alice" .

:b  dc11:title     "SPARQL Protocol Tutorial" .
:b  dc11:creator   "Bob" .

:c  dc10:title     "SPARQL" .
:c  dc11:title     "SPARQL (updated)" .

Ainsi la requête :

PREFIX dc10:  <http://purl.org/dc/elements/1.0/>
PREFIX dc11:  <http://purl.org/dc/elements/1.1/>

SELECT ?title
WHERE  { { ?book dc10:title  ?title } UNION { ?book dc11:title  ?title } }

donne la solution :

Soustraction

Seulement disponible pour SPARQL 1.1.

A MINUS { B }

Considérer A et B comme des graphes. "A MINUS { B } " représente une soustraction. Il conserve uniquement les résultats de A qui ne sont pas dans les résultats de B.

Interroger un point d'accès SPARQL

1. Aller sur le site de DBpedia et trouver l’IRI au sein de DBpedia qui correspond le mieux à la page w:Doctor_Who
2. Dans le formulaire du point d’accès http://dbpedia.org/sparql, écrire une requête pour afficher les prédicats et objets de cet IRI.
3. Écrire une requête pour afficher les sujets et prédicats de cet IRI.

Solution

1. En lisant la documentation de DBpedia, vous pouvez comprendre que les IRI des pages Wikipédia sont les objets du triplet suivant :

<http://dbpedia.org/resource/Doctor_Who> foaf:page <http://en.wikipedia.org/wiki/Doctor_Who>

Vous pouvez remarquer que l'IRI du sujet du triplet ne fait pas référence à une langue. Pourtant, les prédicats et les objets de ce sujet ne font pas référence directement à toutes les pages « Doctor Who » dans tous les wikis.

Remarque

Seule une petite partie de Wikipédia est utilisée par DBpedia et les pages des langues non anglaises sont très peu exploitées par DBpedia.

La page w:Doctor_Who ne figure pas directement dans DBpedia. La référence (IRI) la plus proche sera donc <http://dbpedia.org/resource/Doctor_Who>

2. Requête pour afficher les prédicats et objets du sujet : <http://dbpedia.org/resource/Doctor_Who>

select * where {
<http://dbpedia.org/resource/Doctor_Who> ?predicat ?object . 
}

3. Requête pour afficher les sujets et prédicats qui font référence à : <http://dbpedia.org/resource/Doctor_Who>

select distinct * where {
?sujet ?predicat <http://dbpedia.org/resource/Doctor_Who>  . 
}

 

Faire une requête complexe

1. Avec DBpedia, faire une requête pour trouver les dix premiers films français.
2. Vous afficherez en résultat pour chaque film : le lien vers la page Wikipédia du film, la date, le nom et la description.

PREFIX rdfs:<http://www.w3.org/2000/01/rdf-schema#>
PREFIX dbpedia2:<http://dbpedia.org/property/>
PREFIX dbpedia:<http://dbpedia.org/ontology/>
PREFIX foaf: <http://xmlns.com/foaf/0.1/>

SELECT ?link ?date ?label ?comment
WHERE { 
?film <http://purl.org/dc/terms/subject> <http://dbpedia.org/resource/Category:French_films>;
      rdfs:comment ?comment;
      rdfs:label ?label;
      dbpedia:releaseDate  ?date;
      foaf:page ?link.

  FILTER langMatches( lang(?comment), 'fr')
  FILTER langMatches( lang(?label), 'fr')

 }
ORDER BY ?date 
OFFSET  1 
LIMIT 10