SPARQL Protocol and RDF Query Language/Le protocole SPARQL

**Le protocole SPARQL**
Leçon : SPARQL Protocol and RDF Query Language

Chapitre n^o 4
Chap. préc. :	Modèle de données RDF
Chap. suiv. :	Requêtes de lecture

En raison de limitations techniques, la typographie souhaitable du titre, « SPARQL : Le protocole SPARQL
SPARQL Protocol and RDF Query Language/Le protocole SPARQL », n'a pu être restituée correctement ci-dessus.

Dans ce chapitre, nous allons apprendre à envoyer des requêtes à une base de données qui répond à la recommandation SPARQL. Ainsi, dans les chapitres suivants, nous pourrons tester nos requêtes SPARQL immédiatement.

Protocole HTTP

L'HyperText Transfer Protocol — littéralement « protocole de transfert hypertexte » —, plus connu sous l’abréviation HTTP, est un protocole de communication client-serveur développé pour le World Wide Web (ou W3C pour World Wide Web Consortium). HTTPS (avec S pour "secured", soit « sécurisé ») est la variante du HTTP "sécurisée" par l'usage des protocoles SSL ou TLS.

HTTP est un protocole de la couche application. Il peut fonctionner sur n’importe quelle connexion fiable. En pratique, on utilise le protocole TCP comme couche de transport. Un serveur HTTP utilise alors par défaut le port 80 (443 pour HTTPS).

Les clients HTTP les plus connus sont les navigateurs Web permettant à un utilisateur d'accéder à un serveur contenant les données. Il existe aussi des systèmes pour récupérer automatiquement le contenu d'un site, tels que les aspirateurs de site Web ou les robots d'indexation.

Ces clients se connectent à des serveurs HTTP tels qu'Apache HTTP Server, que nous installerons durant un TP.

La liaison entre le client et le serveur n’est pas toujours directe, mais, du point de vue du client HTTP, ces intermédiaires sont invisibles, à moins qu'une erreur ait lieu.

Requêtes

Dans le protocole HTTP, une méthode est une commande spécifiant un type de requête, c'est-à-dire qu'elle demande au serveur d'effectuer une action. En général, l'action concerne une ressource identifiée. Nous allons étudier ce que l’on nomme une ressource et lister les principales commandes.

Ressources

Jusqu'à présent, une ressource est identifiée par une URL, qui suit le nom de la méthode HTTP. La notion d'URL a rapidement atteint ses limites et un nouveau standard est en train de le remplacer : IRI (Internationalized Resource Identifier).

Localisateur uniforme de ressource (URL)

Une URL (Uniform Resource Locator) est une chaîne de caractères ASCII qui spécifie où une ressource connue est disponible sur Internet et indique le mécanisme pour l'atteindre.

Exemples d'URL

http://fr.wikiversity.org est une URL pour atteindre le site fr.Wikiversity via le protocole http.

git://github.com/BorderCloud/4store-php.git est une URL pour atteindre les sources de 4store-php via le protocole git

Identificateur de ressource internationalisé (IRI)

Un IRI (Internationalized Resource Identifier) est une chaîne de caractères (ASCII ou non) qui spécifie où une ressource connue est disponible sur Internet et indique le mécanisme pour l'atteindre.

La différence avec une URL est qu'un IRI peut pointer sur un contenu en utilisant la même langue que ce contenu.

Exemple d'IRI

http://fr.wikipedia.org (URL) pourra devenir http://fr.wikipédia.org (IRI)

Remarque

Une URL est un IRI, mais un IRI n’est pas forcément une URL.

L'architecture HTTP ne supporte pas encore les IRI, mais l'implémentation est en cours. Cependant, les nouveaux logiciels comme les serveurs SPARQL ne travaillent qu'avec des IRI (et, donc, supportent les URL).

Commandes

Liste des principales commandes HTTP :

GET: C'est la méthode la plus courante pour demander une ressource. Une requête GET est sans effet sur la ressource, il doit être possible de répéter la requête sans effet.
POST: Cette méthode doit être utilisée pour soumettre des données, en vue d'un traitement, à une ressource (typiquement depuis un formulaire HTML) ; elle est souvent utilisée aussi pour la création et la mise à jour de ressources.
PUT: Cette méthode permet de remplacer ou d'ajouter une ressource sur le serveur. L'URL fournie est celle de la ressource en question.
DELETE: Cette méthode permet de supprimer une ressource du serveur.

Ces commandes sont souvent détournées de leur mission initiale. Par exemple, un développeur peut utiliser la méthode GET pour envoyer des informations à un serveur et pourra implémenter un traitement de mise à jour des données du serveur en cas de réception de cette commande GET.

Codes de statut HTTP

La réponse du serveur à une commande contient le code de statut HTTP (Status code)

Voici la liste des plus courants :

Code	Message	Signification
2xx	Succès
200	OK	Requête traitée avec succès
3xx	Redirection
301	Moved Permanently	Document déplacé de façon permanente
302	Found	Document déplacé de façon temporaire
303	See Other	La réponse à cette requête est ailleurs
4xx	Erreur du client
400	Bad Request	La syntaxe de la requête est erronée
401	Unauthorized	Une authentification est nécessaire pour accéder à la ressource
403	Forbidden	L’authentification est refusée. Contrairement à l’erreur 401, aucune demande d’authentification ne sera faite
404	Not Found	Document non trouvé
5xx	Erreur du Serveur
500	Internal Server Error	Erreur interne du serveur

Exemple de session HTTP

Voici un exemple de conversation entre un client HTTP et un serveur HTTP www.example.com via le port 80.

Requête

 GET /index.html HTTP/1.1
 Host: www.example.com

Une requête respecte un certain nombre de retours à la ligne et contient la version du protocole, ici HTTP/1.1, la commande, ici GET, la destination, ici www.example.com, et le paramètre de la commande, ici index.html.

Réponse

Voici la réponse que l’on obtient si tout se passe bien entre notre client et le serveur.

 HTTP/1.1 200 OK
 Date: Mon, 23 May 2005 22:38:34 GMT
 Server: Apache/1.3.3.7 (Unix) (Red-Hat/Linux)
 Last-Modified: Wed, 08 Jan 2003 23:11:55 GMT
 ETag: "3f80f-1b6-3e1cb03b"
 Accept-Ranges: bytes
 Content-Length: 438
 Connection: close
 Content-Type: text/html; charset=UTF-8

 <HTML>
 <HEAD>
 <TITLE>Example</TITLE>
  ...

La réponse se compose d'un entête et du message.

L'entête se compose :

La première ligne donne le code de statut HTTP: 200 dans ce cas, c'est-à-dire que le serveur comprend la requête et vous transmet le résultat.
Date: Moment auquel le message est généré.
Server: Indique quel modèle de serveur HTTP répond à la requête.
Last-Modified: Indique la date de dernière modification de la ressource.
ETag (entity tag): Numéro de version de la page dans le cache du serveur ; permet aux navigateurs Web de gérer leur mémoire cache.
Accept-Ranges: Méthode pour récupérer la ressource.
Content-Length: Indique la taille en octets de la ressource.
Content-Type: Indique le type MIME de la ressource.

Le message contient ensuite une page HTML, mais cela dépend de la requête envoyée.

Nous allons étudier, dans la partie suivante, les différentes commandes HTTP utilisables pour un serveur SPARQL 1.0 et ses réponses.

Protocole SPARQL

Protocole de lecture

Requête

Adresse type d'un service SPARQL

http://IP_ou_NOM_DE_DOMAINE/sparql/

Où :

IP_ou_NOM_DE_DOMAINE est une adresse pour atteindre le serveur
/sparql/ est le chemin du service (cela fait partie de la recommandation)

Remarque

Les services SPARQL qui utilisent de vieux logiciels, ont comme chemin : /sparql et non /sparql/

Paramètres d'une requête de lecture

query: paramètre obligatoire, passe la requête SPARQL au service
default-graph-uri: paramètre facultatif qui peut être répété, indique le ou les graphes de la base de données où exécuter la requête
named-graph-uri: paramètre facultatif qui peut être répété, indique le ou les graphes qui seront utilisés au sein de la requête
output: paramètre facultatif qui peut différer d'un logiciel à l'autre, si c’est une requête SELECT ou ASK, on peut demander un autre format de réponse, comme le format "json". Par défaut, le format est en XML.

Nous étudierons dans les leçons suivantes à quoi servent ces paramètres.

Commandes HTTP pour envoyer une requête de lecture

Commandes HTTP pour faire une requête de lecture

On peut faire une requête de lecture avec la commande GET ou POST.

La méthode GET permet d'écrire très simplement une requête (dans un navigateur pour tester une requête).

Par exemple : http://lod.bordercloud.com/sparql/?query=ask {?x ?y "TSO"@en . }

La méthode POST permet de faire les mêmes requêtes, mais POST permet d'envoyer des requêtes de taille plus importante par rapport à une requête GET.

Exemple d'entête HTTP GET pour une requête SPARQL

GET /sparql/?query='''Requête_Encodée''' HTTP/1.1
Host: www.example.org
User-agent: my-sparql-client/0.1

Exemple d'entête HTTP POST pour une requête SPARQL

POST /sparql/ HTTP/1.1
Host: www.example.org
User-agent: sparql-client/0.1
Content-Type: application/x-www-form-urlencoded
Content-Length: 1001

query=Très_Longue_Requête_Encodée

Réponse

La réponse d'une requête prend la forme d'un "SPARQL result" (tableau de résultat) ou le format d'un graphe RDF.

La forme "SPARQL result" peut prendre le format XML ou JSON (ou texte avec tabulation, en fonction des logiciels)
La forme graphe RDF peut prendre le format XML ou Turtle.

SPARQL adapte le format de sortie en fonction du type de requêtes de lecture.

Format des réponses SPARQL

Il y a quatre types de requêtes en SPARQL (que nous étudierons en détail dans les chapitres suivants) :

SELECT: retourne un SPARQL result en XML par défaut. Pour obtenir un autre format comme JSON, il faut le préciser avec le paramètre output.
ASK: retourne un SPARQL result en XML par défaut. Pour obtenir un autre format comme JSON, il faut le préciser avec le paramètre output.
CONSTRUCT: retourne un graphe RDF en XML par défaut. Pour obtenir un autre format comme Turtle, il faut le préciser avec le paramètre output.
DESCRIBE: retourne un document en Turtle ou un graphe RDF en XML. Pour obtenir un autre format précis, il faut l'indiquer avec le paramètre output.

Format SPARQL result XML

Exemple de session avec une requête SELECT

Voici un exemple de requête SELECT :

select * where { ?x ?y ?z .} limit 5

Cette requête aura comme entête HTTP :

GET /sparql/?query=select%20*%20where%20%20{%20?x%20?y%20?z%20.}%20limit%205 HTTP/1.1
Host: www.example.org
Accept: application/sparql-results+xml

La réponse aura comme entête :

HTTP/1.1 200 OK
Date: Fri, 26 Aug 2011 19:17:17 GMT
Server: Apache/2.2.3 (CentOS)
Connection: close
Content-Type: application/xml

Et la réponse contiendra le document SPARQL result XML :

<?xml version="1.0"?>
<sparql xmlns="http://www.w3.org/2005/sparql-results#">
  <head>
    <variable name="x"/>
    <variable name="y"/>
    <variable name="z"/>
  </head>
  <results>
    <result>
      <binding name="x">
        <uri>http://www.example.org/ID1</uri>
      </binding>
      <binding name="y">
        <uri>http://xmlns.com/foaf/0.1/primaryTopic</uri>
      </binding>
      <binding name="z">
        <uri>http://www.example.org/ID2</uri>
      </binding>
    </result>
   ...
  </results>
</sparql>

Exemple de session avec une requête ASK

Voici un exemple de requête ASK :

PREFIX ex: <http://www.example.org/> 
PREFIX foaf: <http://xmlns.com/foaf/0.1/> 
ASK WHERE { ex:ID1 foaf:primaryTopic ex:ID2}

Cette requête aura comme entête HTTP :

GET /sparql/?query=PREFIX%20ex:%20%3Chttp://www.example.org/%3E%20PREFIX%20foaf:%20%3Chttp://xmlns.com/foaf/0.1/%3E%20ASK%20WHERE%20{%20ex:ID1%20foaf:primaryTopic%20ex:ID2} HTTP/1.1
Host: www.example.org
User-agent: Firefox/6.0

La réponse aura comme entête :

HTTP/1.1 200 OK
Date: Fri, 26 Aug 2011 19:17:17 GMT
Server: Apache/2.2.3 (CentOS)
Connection: close
Content-Type: application/xml

Et la réponse contiendra le document SPARQL result XML :

<?xml version="1.0"?>
<sparql xmlns="http://www.w3.org/2005/sparql-results#">
 <head></head>
 <boolean>true</boolean>
</sparql>

Format SPARQL result JSON

Exemple de session avec une requête SELECT et en sortie du JSON

Voici un exemple de requête SELECT :

select * where { ?x ?y ?z .} limit 5

Cette requête aura comme entête HTTP :

GET /sparql/?query=select%20*%20where%20%20{%20?x%20?y%20?z%20.}%20limit%205 HTTP/1.1
Host: www.example.org
User-agent: Firefox/6.0
Accept: application/json

ou bien pour Jena Fuseki :

GET /sparql/?query=select%20*%20where%20%20{%20?x%20?y%20?z%20.}%20limit%205&output=json HTTP/1.1
Host: www.example.org
User-agent: Firefox/6.0

La réponse aura comme entête :

HTTP/1.1 200 OK
Date: Fri, 26 Aug 2011 19:17:17 GMT
Server: Apache/2.2.3 (CentOS)
Connection: close
Content-Type: application/json

Et la réponse contiendra le document JSON :

<?xml version="1.0"?>
{
  "head": { "vars": [ "x" , "y" , "z" ]
  } ,
  "results": { 
    "bindings": [
      {
        "x": { "type": "uri" , "value": "http://www.example.org/ID1" } ,
        "y": { "type": "uri" , "value": "http://xmlns.com/foaf/0.1/primaryTopic" } ,
        "z": { "type": "uri" , "value": "http://www.example.org/ID2" } 
      } ,
      ...
    ]
  }
}

Option CORS à activer avec JSON

L’intérêt d'obtenir un format JSON est d’utiliser ce contenu à travers un script en Javascript. Cependant, votre navigateur n'autorise pas le chargement de JSON d'un autre domaine que celui du site où vous vous trouvez. Bien que cette limitation soit justifiée pour des raisons de sécurité, elle empêche le chargement de résultat SPARQL en JSON.

Une alternative existe : elle consiste à activer dans votre serveur l'option CORS (Cross-Origin Resource Sharing). Cette option insère la ligne Access-Control-Allow-Origin: * dans l'entête de la réponse HTTP pour désactiver cette sécurité.

Format graphe RDF XML

Exemple de session avec une requête DESCRIBE

Voici un exemple de requête DESCRIBE :

PREFIX ex: <http://www.example.org/> 
DESCRIBE ex:ID1

Cette requête aura comme entête HTTP :

GET /sparql?query=PREFIX%20ex:%20%3Chttp://www.example.org/%3E%20DESCRIBE%20ex:ID1 HTTP/1.1
Host: www.example.org
User-agent: Firefox/6.0

La réponse aura comme entête :

HTTP/1.1 200 OK
Date: Fri, 26 Aug 2011 19:17:17 GMT
Server: Apache/2.2.3 (CentOS)
Connection: close
Content-Type: application/xml

Et la réponse contiendra le document RDF XML:

<rdf:RDF
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:j.0="http://xmlns.com/foaf/0.1/"
    xmlns:j.1="http://purl.org/dc/terms/"
    xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#" > 
  <rdf:Description rdf:about="http://www.example.org/ID1">
    <rdfs:label>Description of a document version of 13/11/2008</rdfs:label>
    <j.1:created rdf:datatype="http://www.w3.org/2001/XMLSchema#dateTime">2008-11-03T20:37:51Z</j.1:created>
    <j.1:modified rdf:datatype="http://www.w3.org/2001/XMLSchema#dateTime">2008-11-03T21:12:31Z</j.1:modified>
    <j.0:primaryTopic rdf:resource="http://www.example.org/ID2"/>
  </rdf:Description>
</rdf:RDF>

Format graphe RDF Turtle

Exemple de session avec une requête CONSTRUCT avec en sortie du Turtle

Voici un exemple de requête CONSTRUCT :

PREFIX skos: <http://www.w3.org/2008/05/skos#>
PREFIX foaf: <http://xmlns.com/foaf/0.1/>
CONSTRUCT { ?x skos:Concept ?z. ?x ?p ?v . }
WHERE { ?x foaf:primaryTopic ?z. ?x ?p ?v . } LIMIT 5

Cette requête aura comme entête HTTP :

GET /sparql?query=PREFIX%20skos:%20%3Chttp://www.w3.org/2008/05/skos%23%3E%20PREFIX%20foaf:%20%3Chttp://xmlns.com/foaf/0.1/%3E%20CONSTRUCT%20{...}%20WHERE%20{...}%20LIMIT%205&output=turtle HTTP/1.1
Host: www.example.org
Accept: text/rdf+n3

La réponse aura comme entête :

HTTP/1.1 200 OK
Date: Fri, 26 Aug 2011 19:17:17 GMT
Server: Apache/2.2.3 (CentOS)
Connection: close
Content-Type: text/turtle

Et la réponse contiendra le document turtle :

@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>.
@prefix foaf: <http://xmlns.com/foaf/0.1/>.
@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>.
@prefix skos: <http://www.w3.org/2008/05/skos#>.
@prefix purl: <http://purl.org/dc/terms/>.
@prefix xsd: <http://www.w3.org/2001/XMLSchema#>.
@prefix ex: <http://www.example.org/>.

ex:ID1 skos:Concept ex:ID2;
       foaf:primaryTopic ex:ID2;
       rdfs:label "Description of a document version of 13/11/2008";
       purl:created "2008-11-03T20:37:51Z"^^xsd:dateTime;
       purl:modified "2008-11-03T21:12:31Z"^^xsd:dateTime.
...

Protocole d'écriture

Requête

Adresse type d'un service SPARQL Update

Adresse type d'un service SPARQL

http://IP_ou_NOM_DE_DOMAINE/update/

Où :

IP_ou_NOM_DE_DOMAINE est une adresse pour atteindre le serveur
/update/ est le chemin du service d'écriture (cela fait partie de la recommandation)

Paramètres d'une requête d'écriture

update: paramètre obligatoire, passe la requête SPARQL au service

Nous étudierons dans les chapitres suivants à quoi sert ce paramètre.

Commandes HTTP pour faire une requête d'écriture

On utilise la commande POST pour écrire des données.

Exemple d'entête HTTP POST pour une requête Update

POST /update/ HTTP/1.1
Host: www.example.org
User-agent: sparql-client/0.1
Content-Type: application/x-www-form-urlencoded
Content-Length: 1001

update=Requête_Update

Réponse

Pour savoir, si une requête c’est bien déroulée, on lit le code de statut HTTP, qui doit être égal à 200.

En fonction des implémentations, des messages d'erreurs peuvent être envoyés par le serveur.

Références

Voir aussi

"Hello world" en SPARQL

SPARQL Protocol and RDF Query Language

Modèle de données RDF

Requêtes de lecture