Vous donner des bases pour écrire des requêtes SPARQL.
Bonus: lire/écrire du Turtle (très proche de SPARQL).
Ce n'est qu'une introduction ; pour en savoir plus :
PREFIX foaf: <http://xmlns.com/foaf/0.1/>
SELECT ?n1 ?n2
WHERE {
?p1 a <http://xmlns.com/foaf/0.1/Person> .
foaf:name ?n1 ;
foaf:knows ?p2 .
?p2 a foaf:Person ;
foaf:name ?n2 .
}
n1 | n2 |
---|---|
Alice | Bob |
Carol | Dan |
Dr Jekyll | Dan |
Mr Hide | Dan |
Rappel : les préfixes servent à abréger les IRIs.
PREFIX foaf: <http://xmlns.com/foaf/0.1/>
PREFIX : <http://example.com/>
IRI en extension (relatif ou absolu) :
<http://xmlns.org/foaf/0.1/Person>
<../other-file.rdf>
<#something>
<>
IRI abrégé :
foaf:Person
:something
Litéral :
"Bonjour"
"Hello"@en # avec tag de langue
"123"^^xsd:integer # typé
42 # equiv. "42"^^xsd:integer
1.5 # equiv. "1.5"^^xsd:decimal
314e-2 # equiv. "314e-2"^^xsd:double
true # equiv. "true"^^xsd:boolean
Nœud muet :
_:toto
[] # voir ci-après
Variable (SPARQL seulement) :
?x
$y
NB: pas de distinction entre ?
et $
,
donc ?x
et $x
identifient la même variable.
"."
:?p1 foaf:name "Pierre-Antoine Champin" .
"a"
en position de prédicat est
un raccourci pour <http://www.w3.org/1999/02/22-rdf-syntax-ns#type>
:?p1 a foaf:Person .
On peut « factoriser » plusieurs triplets ayant le même sujet en séparant
les couples <prédicat, objet> par un point-virgule ";"
:
<#pa> a foaf:Person ;
foaf:givenName "Pierre-Anntoine" ;
foaf:surname "Champin" .
On peut « factoriser » plusieurs triplets ayant
le même sujet et le même prédicat
en séparant les objets par une virgule ","
:
<#pa> foaf:phone <tel:+33-472-44-82-40>, <tel:+33-472-69-21-73>.
On peut bien sûr combiner les deux types de factorisation.
On n'est jamais obligé de factoriser, on peut aussi répéter les termes.
Lorsqu'un nœud muet n'a qu'un seul arc entrant, au lieu de lui inventer un identifiant local :
<#pa> foaf:know _:quelqun .
_:quelqun a foaf:Person ; foaf:name ?n .
on peut utiliser la notation []
:
<#pa> foaf:knows [
a foaf:Person ;
foaf:name ?n
] .
En SPARQL, on peut accepter qu'une partie du graphe ne soit pas satisfaite :
?p1 a foaf:Person ; foaf:name ?n .
OPTIONAL { ?p1 foaf:phone ?tel }
En SPARQL, on peut ajouter des contraintes sur les valeurs d'un graphe,
avec la clause FILTER
.
?p foaf:age ?a .
FILTER (?a >= 18)
On peut combiner des conditions avec les opérateurs logiques « et » (&&
),
« ou » (||
) et « non » (!
).
FILTER ( 20 <= ?a && ?a < 30 )
isIRI
, isBLANK
, isLITERAL
, isNUMERIC
OPTIONAL
) a bien une valeur :
Bound
REGEX(<variable>, <texte>)
Similaire au SELECT de SQL :
projection sur un sous-ensemble des variables du graphe
Résultat : tableau
Structure :
SELECT <variables> WHERE { <graphe> }
SELECT DISTINCT ?sn
WHERE { <#pa> foaf:knows ?p. ?p foaf:surname ?sn. }
Sans le DISTINCT
, la requête renverra deux fois le résultat sn="Doe"
.
Pour obtenir les 10 premiers résultats :
SELECT ?p
WHERE { <#pa> foaf:knows ?p. }
LIMIT 10
Pour obtenir les 5 résultats suivants :
SELECT ?p
WHERE { <#pa> foaf:knows ?p. }
LIMIT 5 OFFSET 10
SELECT ?p ?n
WHERE { <#pa> foaf:knows [ foaf:givenName ?p ; foaf:surname ?n ] }
ORDER BY ?n ?p
On peut aussi trier par ordre descendant :
SELECT ?name ?age
WHERE { <#pa> foaf:knows [ foaf:name ?name ; foaf:age ?age ] }
ORDER BY DESC(?age)
LIMIT 1
Note
l'utilisation du tri et de LIMIT 1
permet ici de n'obtenir
que la personne la plus vieille que connaît <#pa>
.
Sert à aggréger certaines valeurs avec l'une des fonctions d'aggrégations :
Count
, Sum
, Avg
, Min
, Max
, GroupConcat
et Sample
.
SELECT ?p1 (count(?p2) as ?cp2)
WHERE { ?p1 foaf:knows ?p2 }
GROUP BY ?p1
On peut combiner GROUP BY
avec ORDER BY
et LIMIT
(attention à l'ordre) :
SELECT ?p1 (count(?p2) as ?cp2)
WHERE { ?p1 foaf:knows ?p2 }
GROUP BY ?p1
ORDER BY DESC(?cp2)
LIMIT 3
SELECT ?type
WHERE { ?o a ?type }
GROUP BY ?type
ORDER BY DESC(count(?o))
LIMIT 30
SELECT DISTINCT ?prop
WHERE { ?o a <http://example.org/UnType> ; ?prop ?val . }
LIMIT 30
Sert à demander si un graphe existe ou non dans la base.
Résultat : vrai ou faux
Structure :
ASK { <graphe> }
Sert à construire un graphe à partir des résultat d'un autre
Résultat : un graphe RDF
Structure :
CONSTRUCT { <graphe> } WHERE { <graphe> }
Peut jouer un rôle similaire à XSL-T pour RDF
CONSTRUCT {
?p1 ex:hasMutualFriendWith ?p3 ;
foaf:name ?n1 .
?p3 foaf:name ?n3 .
} WHERE {
?p1 foaf:knows ?p2 .
?p3 foaf:knows ?p2 .
OPTIONAL { ?p1 foaf:name ?n1 }
OPTIONAL { ?p3 foaf:name ?n3 }
}
construit un graphe contenant des arcs ex:hasMutualFriendWith
entre les personnes qui partagent au moins un ami,
et copie également les arcs foaf:name
concernant ces personnes, le cas échéant.
En appliquant l'exemple de CONSTRUCT
ci-dessus
au graphe donné en exemple en début de chapitre, on obtient :
Depuis la version 1.1, possibilité de modifier les données.