J'ai écrit le texte de ce billet en guise d'introduction aux technologies du Web sémantique pour le projet de publication selon les règles du Web de données du thésaurus pour l'indexation des archives locales publié par les Archives de France que j'ai mené pour Atos Origin avec le Service Interministériel des Archives de France au printemps 2010 (et sur lequel il faudra que je trouve le temps de revenir sur ce blog pour vous en dire plus...). Claire Sibille, conservateur en chef au SIAF, m'a très gentiment donné l'autorisation de republier ces textes sur mon blog. Je l'en remercie.
Il s'agit d'une introduction générale en trois parties dont ce billet est la seconde :
- Petite histoire du Web sémantique
- Les technologies du Web sémantique
- Retour sur le Web de données
Les différentes technologies du Web sémantique forment des couches dont la compréhension est essentielle pour appréhender au mieux ses possibilités. Mais, au préalable, il est nécessaire de dresser un tableau de l'architecture du Web sur laquelle reposent l'ensemble des fondations du Web sémantique.
URI, représentation, ressource : l'architecture du Web
Trois notions composent l'architecture du Web : l'URI (Uniform ressource identifier), la représentation et la ressource. Les interactions entre ces trois notions peuvent être représentées par le schéma suivant :
L'architecture du Web par Christian Fauré
L'URI (Uniform Ressource Identifier) est un système d'identifiant dans un réseau physique ou virtuel dont la syntaxe est normalisée :
Le Scheme est un préfixe qui indique le contexte dans lequel les identifiants sont attribués. Ce contexte peut renvoyer à l'utilisation d'un protocole de communication s'il s'agit d'un réseau physique (par exemple, HTTP, d'où le fait qu'une URL est un type particulier d'URI) ou d'un réseau virtuel non atteignable par une machine (par exemple URN ou INFO).
L'Authority désigne une autorité dite nommante en charge d'attribuer des noms pour ce scheme. Dans le cas de HTTP, il s'agit d'un nom de domaine acheté auprès d'un fournisseur qui a reçu la délégation de fournir ces noms de domaines auprès de l'organisme qui régit ce scheme, l'ICANN.
Le Path est un chemin ou un nom attribué par l'autorité nommante. Dans le cas d'une URI HTTP, c'est la personne en charge du nom de domaine qui organise l'attribution des différents chemin d'accès à une ressource.
Une URI se doit d'être unique et pérenne. Si nous avons longtemps cru que le problème de la stabilité d'une URL était un problème technique dont la résolution passait par le choix de systèmes d'identifiants dit pérennes (DOI, ARK, Handle ou INFO), il s'agit en réalité avant tout d'une problématique organisationnelle et d'imprimer au sein d'une organisation la volonté de s'engager à garantir cette pérénité.
La représentation désigne un flux fini dans un format précis. D'après l'architecture du Web, une URI peut donc avoir une ou plusieurs représentations en fonction de critères comme le format que peut traiter ou lire (dans le cas de l'humain) le client qui exécute la requête, l'encodage de caractères, la provenance géographique de la requête, la langue... Dans la très grande majorité des cas, une URI n'a qu'une représentation qui est celle renvoyée par défaut par le serveur. De plus, lorsqu'on utilise un navigateur, ce dernier inclut dans sa requête une consigne invisible pour l'humain qui indique au serveur des critères précis, en particulier la préférence pour le format HTML. C'est pourquoi cet aspect de l'architecture du Web est souvent méconnu.
La ressource désigne l'entité elle-même d'un point de vue conceptuel, identifiée par une URI qui possède une ou plusieurs représentations dont la fourniture est soumise à différents critères. Toute entité identifiée par une URI est donc une ressource.
La rencontre du Web et du modèle entités-relations : le modèle RDF
Un modèle définit une organisation théorique et logique de l'information. Par exemple, dans la communication humaine, la grammaire peut être assimilée à un modèle d'organisation des informations pour en permettre notre compréhension. En informatique, il existe de nombreux modèles : le modèle clé-valeur des fichiers de configuration, le modèle tabulaire des bases de données relationnelles, le modèle hiérarchique d'arbres du XML.
A la base des technologies du Web sémantique se situe le modèle RDF (Resource Description Framework) basé sur le modèle entité-relation. Dans ce modèle, chaque entité (ou « chose » ou « signe ») est indépendante et possède des relations avec d'autres entités. RDF est une application particulière de ce modèle, puisqu'il est aussi issu de la réflexion sur la théorie des graphes et la logique des prédicats de premier ordre. En effet, en RDF, les relations qui unissent deux entités sont orientées d'où la dénomination de graphe orienté et sont typées d'où la relation avec la logique des prédicats du premier ordre. Concrètement, le modèle RDF est une logique formelle qui permet d'encoder des données (entendues comme la relation qui unit deux entités) pour donner les moyens à une machine de les traiter et les analyser. Il s'appuie donc sur trois fondations :
les URIs pour identifier les entités assimilés alors à des ressources ;
le principe des triplets pour exprimer la relation qui unit deux entités ;
le principe des graphes dans la mesure où l'ensemble des triplets sur un ensemble d'entités forme un graphe.
L'URI comme signifiant dans le monde des machines
A la suite de Ferdinand de Saussure, la linguistique distingue dans un « signe » linguistique le signifié, c'est-à-dire le concept, et le signifiant, c'est-à-dire la matérialisation de ce concept. Si on applique cette distinction à l'architecture du Web, l'URI peut donc être perçu comme le signifiant d'un concept dans l'espace de communications en réseau des machines. Ainsi, chaque entité manipulée par une machine est désignée par une URI ce qui en fait une ressource. Il existe d'ores et déjà de nombreuses URI définies sur le Web et renvoyant à une entité du monde réel, par exemple :
le concept de personne : http://xmlns.com/foaf/0.1/Person ;
le concept de type ou d'être : http://www.w3.org/1999/02/22-rdf-syntax-ns#type ;
l'URI représentant Tim Berners-Lee : http://www.w3.org/People/Berners-Lee/card#i ;
le concept de créateur d'une ressource : http://purl.org/dc/terms/creator ;
Les triplets pour décrire et exprimer
Évidemment, l'attribution d'une URI ne suffit pas à la machine pour en comprendre le signifié. Il est nécessaire d'associer à cette URI une représentation sur laquelle la machine pourra s'appuyer pour traiter la ressource. Cette description suit le modèle « Entités-relations », à savoir l'encodage de la relation entre deux entités sous la forme d'un triplet : Sujet-Prédicat-Objet qui n'est pas sans rappeler la structure d'une phrase simple : Sujet-Verbe-Complément. Ainsi, la description d'une ressource identifiée par une URI passe par un ensemble de triplets, appelées assertions, dont la ressource est membre. Par exemple, si je veux exprimer l'assertion suivante « Tim Berners-Lee est une personne », elle correspond à la relation par le concept « est » des entités « Tim Berners-Lee » et du concept de « personne ». Graphiquement, il peut être représenté ainsi :
Représentation graphique du triplet
Si on remplace, chacun des signifiés par son signifiant sous la forme d'une URI :
| Sujet | Prédicat | Objet |
| <http://www.w3.org/People/Berners-Lee/card#i> | <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> | <http://xmlns.com/foaf/0.1/Person> |
Si, à présent, je souhaite exprimer l'assertion suivante « L'article Semantic Web a pour créateur Tim Berners-Lee, elle sera exprimée de la manière suivante :
| Sujet | Prédicat | Objet |
| <http://www.sciam.com/article.cfm?id=the-semantic-web> | <http://purl.org/dc/terms/creator> | <http://www.w3.org/People/Berners-Lee/card#i> |
Le modèle RDF propose donc une logique formelle (une phrase simple) pour encoder une donnée (étant entendue comme la relation entre deux signes) en s'appuyant sur les principes des triplets et de l'architecture du Web. Ainsi, chaque membre du triplet est une ressource qui peut-elle même être le sujet ou l'objet d'autres assertions (le cas du prédicat est particulier de ce point de vue). Néanmoins, comme certains types de données ne sont pas forcément des entités, l'objet peut aussi être une chaîne de caractères, une date, un entier... ce qui est désigné par le terme « littéral ». Par exemple, si je souhaite exprimer l'assertion « Tim Berners-Lee a pour nom "Tim Berners-Lee" », elle sera exprimée de la manière suivante :
| Sujet | Prédicat | Objet |
| <http://www.w3.org/People/Berners-Lee/card#i> | <http://xmlns.com/foaf/0.1/name> | "Tim Berners-Lee" |
Le graphe
Comme nous l'avons vu précédemment, un triplet peut être représenté sous la forme d'un graphe dont le sujet et l'objet sont les sommets et le prédicat un arc orienté. Ainsi, un triplet RDF est un graphe orienté. La somme des triplets sur les différentes entités forme un graphe d'où l'expression « Giant Global Graph » utilisée pour la première fois en novembre 2007 par Tim Berners-Lee pour désigner la somme de l'ensemble des triplets disponibles sur le Web. Par exemple, la représentation des triplets précédents forme le graphe suivant :
L'intérêt d'un modèle de graphes réside dans sa souplesse et son évolutivité. Ainsi, si les ressources de ce graphe servent de basent à de nouveaux triplets, le graphe pourra s'enrichir de la manière suivante :
Les nouveaux triplets sont les suivants :
Partager un vocabulaire et une logique commune : OWL-RDFS
Afin d'assurer un consensus sur les URI et leurs sens, il est nécessaire de partager des vocabulaires dont les composantes vont servir de base à la construction des triplets en RDF. Dans les technologies du Web sémantique, ce rôle de « dictionnaire » est assuré par le mécanisme des ontologies exprimées elles-mêmes en RDF à l'aide de deux vocabulaires normalisés au sein du W3C : RDFS et OWL.
En philosophie, une ontologie désigne un « discours sur l'être en tant qu'être ». A la suite de Tom Gruber, les chercheurs dans le domaine de l'intelligence artificielle se sont appropriés le terme pour désigner une organisation logique et formelle d'un domaine de connaissance pour permettre à une machine d'en manipuler les différents objets, leurs caractéristiques et leurs logiques. Ainsi, une ontologie permet de décrire :
des classes, c'est-à-dire des types d'entité du domaine décrit.
des propriétés, c'est-à-dire les différents types de relations qui unissent une classe, deux classes ou une classe et un type de littéral (chaîne de caractères, date, entier...) ;
une logique, c'est-à-dire des règles ou des comportements associés à une classe et/ou à une propriété ;
des instances, c'est-à-dire des individus d'une (ou plusieurs) classe(s).
Ces différentes composantes de l'ontologie interviennent dans l'élaboration des triplets RDF dans la mesure où une classe et une propriété ont des URI déclarées dans l'ontologie. Ainsi, chaque ressource RDF appartient à une classe exprimée via le prédicat « http://www.w3.org/1999/02/22-rdf-syntax-ns#type » décrite dans une ontologie et le prédicat dans un triplet correspond à une propriété déclarée dans une ontologie.
Prenons par exemple l'ontologie FOAF qui permet de décrire une personne. Elle définit, entre autres, les classes suivantes :
agent : http://xmlns.com/foaf/0.1/Agent ;
personne : http://xmlns.com/foaf/0.1/Person ;
document : http://xmlns.com/foaf/0.1/Document ;
groupe : http://xmlns.com/foaf/0.1/Group.
Une propriété se définit par la classe de la ressource qui sera sujet d'un triplet, appelé aussi « domaine » (domain en anglais) et la classe de la ressource ou le type de données dans le cas d'un littéral qui sera l'objet d'un triplet, appelé aussi co-domaine (range en anglais). Ainsi, FOAF définit, entre autres, les propriétés suivantes pour les classes citées précédemment :
le nom : http://xmlns.com/foaf/0.1/name dont le domaine est la classe chose et le co-domaine est un littéral ;
le prénom d'une personne : http://xmlns.com/foaf/0.1/firstName dont le domaine est la classe personne et le co-domaine est un littéral ;
la page Web relative à un agent : http://xmlns.com/foaf/0.1/page dont le domaine est la classe agent et le co-domaine est la classe document ;
la qualité de membre d'un groupe : http://xmlns.com/foaf/0.1/member dont le domaine est la classe groupe et le co-domaine est la classe agent ;
une relation de connaissance entre deux personnes : http://xmlns.com/foaf/0.1/knows dont le domaine est la classe personne et le co-domaine est la classe personne.
L'ensemble des classes et propriétés de FOAF sont résumés dans ce diagramme :
Diagramme FOAF par Dan Brickley
Ce diagramme montre aussi les interactions de FOAF avec d'autres ontologies existantes (SIOC, DOAP, GEO, OWL).
Il existe deux types de logique dans la définition des ontologies :
une logique intrinsèque aux vocabulaires RDFS et OWL : il est ainsi possible de déterminer qu'une classe est une sous-classe d'une autre, dans ce cas, les propriétés applicables à la super-classe sont aussi applicables aux sous-classes par un mécanisme d'héritage. Ainsi, dans FOAF, la propriété « nom » ayant pour domaine la super classe primitive « chose », elle s'applique aussi à toutes les autres classes définies dans FOAF mais aussi dans n'importe quelle autre ontologie ;
une logique déclarée au sein du vocabulaire : il est ainsi possible de déterminer qu'une propriété est symétrique, dans ce cas, la machine peut effectuer des inférences pour créer de nouveaux triplets. Par exemple, si on définit une propriété « frère/sœur de » symétrique et qu'on déclare que
, la machine pourra déduire que .
RDFS et OWL permettent de définir différents types de logique, par exemple, le fait qu'une classe est l'union ou l'intersection de deux classes, le fait que deux propriétés sont inverses, la cardinalité d'une propriété, le fait que des propriétés sont transitives... La figure suivante donne une vision schématique de ces différentes logiques offertes par OWL.
OWL en une slide par Fabien Gandon
Écrire du RDF : RDF/XML, N3, RDFa
RDF étant un modèle, il est nécessaire de disposer d'une syntaxe pour écrire/sérialiser les triplets RDF entre les utilisateurs et les machines. Le W3C a standardisé au rang de recommandation une seule de ces syntaxes : RDF/XML. Mais, cette dernière posant un certain nombre de problèmes, d'autres syntaxes ont vu le jour : N-triples, N3, Turtle, Trix... Pour finir, le W3C a standardisé une sérialisation un peu particulière : RDFa dont l'objectif est d'exprimer des triplets RDF dans des pages Web en HTML.
La syntaxe RDF/XML
Si les triplets peuvent être écrits selon les principes de la syntaxe XML, il ne faut pas pour autant en conclure que RDF est un schéma de XML et confondre les deux. En effet, XML est à la fois une syntaxe et un modèle qui repose sur l'idée d'organisation hiérarchique de l'information. Dans le cadre du RDF/XML, c'est la syntaxe uniquement qui est utilisée. De fait, il n'est pas possible de valider un fichier RDF/XML par rapport à un schéma comme les autres fichiers utilisant XML. De même, le système des espaces de noms n'est pas utilisé dans le même sens.
L’élément racine est toujours RDF. Le système des espaces de noms qui désignent en XML un élément rattaché à un schéma XML, constitue pour RDF un mécanisme d’abréviations des URI.
<rdf:RDF
xmlns:foaf="http://xmlns.com/foaf/0.1/"
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
xmlns:dc="http://purl.org/dc/terms/">
</rdf:RDF>
Une ressource décrite est toujours introduite par l’élément
<?xml version="1.0" encoding="UTF-8"?>
<rdf:RDF
xmlns:foaf="http://xmlns.com/foaf/0.1/"
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
xmlns:dc="http://purl.org/dc/terms/">
<rdf:Description rdf:about="http://www.w3.org/People/Berners-Lee/card#i">
<rdf:type rdf:resource="http://xmlns.com/foaf/0.1/Person"/>
<foaf:name>Timothy Berners-Lee</foaf:name>
<foaf:nick>timbl</foaf:nick>
</rdf:Description>
</rdf:RDF>
Cet exemple est la sérialisation RDF/XML des triplets suivants :
| Sujet | Prédicat | Objet |
| <http://www.w3.org/People/Berners-Lee/card#i> | <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> | <http://xmlns.com/foaf/0.1/Person> |
| <http://www.w3.org/People/Berners-Lee/card#i> | <http://xmlns.com/foaf/0.1/name> | « Timothy Berners-Lee » |
|
|
|
« timbl » |
Dans la mesure où RDF/XML est une représentation d'un graphe sous la forme d'un arbre, il existe plusieurs manières de représenter les mêmes triplets. Ainsi, l'exemple précédent pourrait être sérialisé sans aucune perte d'informations de la manière suivante :
<?xml version="1.0" encoding="UTF-8"?>
<rdf:RDF
xmlns:foaf="http://xmlns.com/foaf/0.1/"
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
xmlns:dc="http://purl.org/dc/terms/">
<foaf:Person rdf:about="http://www.w3.org/People/Berners-Lee/card#i" foaf:name="Timothy Berners-Lee">
<foaf:nick>timbl</foaf:nick>
</foaf:Person>
</rdf:RDF>
Dans ce cas, le type de la ressource prend la place de l'élément rdf:Description, l'attribut de cet élément correspond à un prédicat et sa valeur à l'objet.
La syntaxe N3
Initiée par Tim Berners-Lee, cette syntaxe n'est pas standardisée. Pourtant, elle est au cœur du langage de requêtes SPARQL. Son principe est très simple car il correspond à la structure d'une phrase simple. Un flux N3 est un fichier texte comprenant en premier lieu la déclaration des préfixes des espaces de noms utilisés dans les triplets qui suivent puis l'ensemble des triplets. Chaque triplet se termine par un point. Si deux triplets qui se suivent ont le même sujet, le sujet n'est pas répété et un point virgule sépare l'objet du premier et le prédicat du second. Si deux triplets qui se suivent ont le même sujet et le même prédicat, le sujet et le prédicat ne sont pas répétés et une virgule sépare les différents objets. La sérialisation en N3 des triplets exprimés dans l'exemple précédent est la suivante :
@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
@prefix foaf: <http://xmlns.com/foaf/0.1/> .
@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
@prefix dc: <http://purl.org/dc/terms/> .
<http://www.w3.org/People/Berners-Lee/card#i> rdf:type foaf:Person ;
foaf:name "Timothy Berners-Lee" ;
foaf:nick "timbl".
RDFa
HTML, de même que XHTML, permet de structurer une page Web selon les principes d'un langage à balises. Les différentes balises indiquent de manière hiérarchique le rôle joué par chaque portion d'information dans le contexte de la page Web. Pourtant, pour exploiter automatiquement l'information, il pourrait être utile d'exprimer dans le code HTML la structure ou la description du message quelque soit le code HTML. C'est précisément le but de RDFa qui s'appuie sur le modèle RDF. Pour ce faire, RDFa précise l'utilisation d'attributs existants en HTML et en introduit de nouveaux. Un code informatique est ensuite capable à partir de ces différents attributs et de la structure hiérarchique des éléments HTML d'extraire les triplets de la page Web pour analyser ou traiter les informations. L'introduction dans une page Web des triplets exprimés précédemment pourrait donner le code HTML suivant :
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML+RDFa 1.0//EN"
"http://www.w3.org/MarkUp/DTD/xhtml-rdfa-1.dtd">
<html
xmlns:foaf="http://xmlns.com/foaf/0.1/"
xmlns="http://www.w3.org/1999/xhtml"
xmlns:dc="http://purl.org/dc/terms/">
<head>
<title>Description de Timbl en XHTML + RDFa</title>
</head>
<body>
<div typeof="foaf:person" about="http://www.w3.org/People/Berners-Lee/card#i">
L'inventeur du Web a pour nom
<span property="foaf:name">Timothy Berners-Lee</span>
et pour surnom <span property="foaf:nick">Timbl</span>.
</div>
</body>
</html>
L'URI du sujet est indiqué avec l'attribut @about, son type avec l'attribut @typeof, les prédicats sont indiqués par l'attribut @property, l'objet étant la valeur de l'élément qui contient cet attribut. Dans le cas où l'objet est une ressource, l'attribut est @rel et l'objet est indiqué dans un attribut @href.
Interroger le RDF : SPARQL
Afin d'interroger un ensemble de données structurées en RDF, le W3C a mis au point un langage de requêtes dédié, SPARQL. Mais, au contraire de SQL dédié aux bases de données relationnelles et qui se limite à un langage de requêtes, le W3C a aussi défini un protocole, c'est-à-dire les caractéristiques techniques pour envoyer une requête SPARQL à une application compatible et le format et la structure de la réponse sous la forme d'un flux XML. Ainsi, SPARQL constitue une interface de programmation entre les applications, une API, sous la forme d'un Web services normalisé et ouvre la voie vers une API universelle d'interrogation des données structurées, dans laquelle la sémantique de l'interrogation ne se situe plus dans l'API ce qui limite les possibilités mais bien dans la requête elle-même.
Le langage de requêtes SPARQL
SPARQL offre les moyens de parcourir un graphe RDF selon un principe simple qui pourrait être comparé à celui des équations en mathématiques. Une requête SPARQL a pour but de trouver un ou plusieurs membres d'un ensemble de triplets. Pour ce faire, chaque triplet est exprimé selon la syntaxe N3 dont certains membres (le sujet et/ou le prédicat et/ou l'objet) sont inconnus et sont remplacés par des variables.
Par exemple, soit l'ensemble de triplets RDF suivant :
@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
@prefix foaf: <http://xmlns.com/foaf/0.1/> .
@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
@prefix dc: <http://purl.org/dc/terms/> .
<http://www.w3.org/People/Berners-Lee/card#i> rdf:type foaf:Person ;
foaf:name "Timothy Berners-Lee" ;
foaf:nick "timbl" .
foaf:knows <http://www.ivan-herman.net/foaf.rdf#me> ;
foaf:knows <http://dbpedia.org/resource/Tim_Bray> ;
foaf:knows <http://danbri.org/foaf.rdf#danbri> ;
foaf:knows <http://www.lassila.org/ora.rdf#me> ;
foaf:knows <http://www.cs.umd.edu/~hendler/2003/foaf.rdf#jhendler>.
<http://www.ivan-herman.net/foaf.rdf#me> rdf:type foaf:Person ;
foaf:name "Ivan Herman".
<http://dbpedia.org/resource/Tim_Bray> rdf:type foaf:Person ;
foaf:name "Tim Bray".
<http://danbri.org/foaf.rdf#danbri> rdf:type foaf:Person ;
foaf:name "Dan Brickley".
<http://www.lassila.org/ora.rdf#me> rdf:type foaf:Person ;
foaf:name "Ora Lassila".
<http://www.cs.umd.edu/~hendler/2003/foaf.rdf#jhendler> rdf:type foaf:Person ;
foaf:name "James Hendler".
L'objectif initial de la requête est de trouver toutes les ressources reliés à la ressource représentant Tim Berners Lee avec la propriété foaf:knows, soit les personnes que connaît Tim Berners-Lee. Si on exprime cette information sous la forme d'un triplet en N3, on obtient :
@prefix foaf: <http://xmlns.com/foaf/0.1/> .
<http://www.w3.org/People/Berners-Lee/card#i> foaf:knows <strong>X.</strong>
Si, à présent, on ajoute une question sur ces personnes : le nom de ces personnes qu'on ne connait toujours pas :
@prefix foaf: <http://xmlns.com/foaf/0.1/> .
<http://www.w3.org/People/Berners-Lee/card#i> foaf:knows X.
X foaf:name Y.
Dans ces deux triplets/équations, les deux inconnus sont X qui correspond à l'URI des ressources reliés à Tim Berners-Lee par le prédicat « foaf:knows » et Y qui correspond au littéral relié à X par le prédicat « foaf:name ». Le corps de la requête est alors écrit et il suffit de respecter la syntaxe de SPARQL pour pouvoir la finaliser :
@prefix foaf: <http://xmlns.com/foaf/0.1/> .
SELECT ?X ?Y
WHERE {
<http://www.w3.org/People/Berners-Lee/card#i> foaf:knows ?X.
?X foaf:name ?Y.
}
Le résultat de cette requête sera :
| ?X | ?Y |
| <http://www.ivan-herman.net/foaf.rdf#me> | « Ivan Herman » |
| <http://dbpedia.org/resource/Tim_Bray> | « Tim Bray » |
| <http://danbri.org/foaf.rdf#danbri> | « Dan Brickley » |
| <http://www.lassila.org/ora.rdf#me> | « Ora Lassila » |
| <http://www.cs.umd.edu/~hendler/2003/foaf.rdf#jhendler> | « James Hendler » |
Le processeur SPARQL renvoie toutes les combinaisons cohérentes de valeurs de chaque variable.
Le protocole et le flux XML de réponses
La première version de la recommandation SPARQL paru en janvier 2008 était volontairement limitée à quatre types de requêtes : SELECT que nous avons vu, CONSTRUCT pour construire des triplets RDF à partir des triplets RDF existants, ASK pour vérifier la présence d'une information dans l'ensemble de données RDF et DESCRIBE qui renvoie l'ensemble des triplets dont une ressource précisée est sujet ou objet. Le protocole se limite donc à la construction générique de la requête HTTP pour ces 4 types de requêtes SPARQL et aux messages d'erreur éventuels qu'ils peuvent générer.
Le flux XML de réponses est composé d'une en-tête, d'un corps de la réponse, d'un élément pour chaque ligne de résultat et d'un élément pour chaque résultat au sein de cette ligne :
<?xml version="1.0"?>
<sparql xmlns="http://www.w3.org/2005/sparql-results#">
<head>
<variable name="x"/>
<variable name="y"/>
</head>
<results>
<result>
<binding name="x"><uri>http://www.ivan-herman.net/foaf.rdf#me</uri></binding>
<binding name="y"><literal>Ivan Herman</literal></binding>
</result>
<result>
<binding name="x"><uri>http://dbpedia.org/resource/Tim_Bray</uri></binding>
<binding name="y"><literal>Tim Bray</literal></binding>
</result>
</results>
</sparql>
Il est à signaler que le W3C travaille actuellement à une nouvelle version des différentes recommandations liées à SPARQL qui introduira, entre autres, les fonctionnalités de mises à jour de données RDF, d'interrogations de plusieurs ensembles de données dans une même requête, d'agrégation (calcul de somme, de moyenne...) et développera les API.