Le thésaurus W et le Web de données

Accueil | Présentation du thésaurus W | Le thésaurus W et le Web de données

Sommaire

Les technologies du Web sémantique

Le Web sémantique désigne, en premier lieu, une activité du W3C, l'organisme de normalisation du Web, visant au développement de technologies de mise à disposition des données structurées en vue de leur traitement par les machines sur le Web. Par extension, l'expression désigne à présent l'idée et l'ensemble des dispositifs et briques technologiques qui le composent. Comme nous l'avons montré dans l'historique, le mot « sémantique » ne renvoie pas à la définition communément admise en linguistique, mais fait référence à la définition donnée par le domaine de la logique de description dont le but est de faire émerger du sens à travers la structuration des données et l'expression de la logique qui les relie.

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 :

Les machines sont directement reliés aux objets du monde réel
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 :

Schéma de la syntaxe des URI

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 :

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 :

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
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 :

Représentation graphique des triplets étudiés précédemment

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 :

Représentation graphique avec des triplets augmentant des triplets précédents

Les nouveaux triplets sont les suivants :

Sujet

Prédicat

Objet

http://www.sciam.com/article.cfm?id=the-semantic-web http://www.w3.org/1999/02/22-rdf-syntax-ns#type http://purl.org/dc/dcmitype/Text
http://www.sciam.com/article.cfm?id=the-semantic-web http://purl.org/dc/elements/1.1/creator http://www.w3.org/Home/Lassila
http://www.w3.org/Home/Lassila http://www.w3.org/1999/02/22-rdf-syntax-ns#type http://xmlns.com/foaf/0.1/Person

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 :

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 :

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 :

L'ensemble des classes et propriétés de FOAF sont résumés dans ce diagramme :

diagramme représentant le vocabulaire FOAF
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 :

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.

Représentation graphique des différentes logiques présentes dans FOAF
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.

<?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:RDF>

Une ressource décrite est toujours introduite par l’élément <rdf:Description>, l’URI de la resource (le sujet) dans l’attribut @rdf:about. Les éléments enfants sont les prédicats qui se rattachent à cette même ressource. Si l’objet est un litéral, il est représenté sous la forme de la valeur d’un élément. Si l’objet est une ressource, son URI est indiqué dans l’attribut @rdf:resource.

<?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 »
<http://www.w3.org/People/Berners-Lee/card#i> <http://xmlns.com/foaf/0.1/nick> « 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 X.

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.