ARQ - API Application

Traducteurs

| Julien Plu | Thibaut Cuvelier |

L'objectif de ce tutoriel est de vous apprendre à utiliser l'API Application de ARQ. Il vous permettra de mieux comprendre le fonctionnement des requêtes SPARQL avec Jena.

Commentez

- Titre : ARQ - API Application

- Traducteurs : Julien Plu, Thibaut Cuvelier

- Parution : 30 mai 2011

- Mise à jour : 8 janvier 2016

- Public visé :

- Licence : Copyright ® 2011-2013 Developpez LLC. Tous droits réservés Developpez LLC. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents et images sans l'autorisation expresse de Developpez LLC. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.

Sommaire

- I. Introduction

- II. Les classes-clés

- III. Les requêtes SELECT

- III-A. Exemple : le formatage d'un ensemble de résultats

- III-B. Exemple : les résultats du traitement

- IV. Les requêtes CONSTRUCT

- V. Les requêtes DESCRIBE

- VI. Les requêtes ASK

- VII. Formater les résultats XML

- VIII. Jeux de données

- IX. L'article original

- X. Remerciements

I - Introduction

L'API de l'application est dans le paquet com.hp.hpl.jena.query.

D'autres paquets contiennent diverses parties du système (moteur d'exécution, analyseurs, tests, etc.). La plupart des applications n'ont besoin que du paquet principal. Seules les applications souhaitant par programmation, construire des requêtes, ou modifier le comportement du moteur de requête ont besoin d'utiliser les autres paquets directement.

II - Les classes-clés

Le paquet com.hp.hpl.jena.query est le paquet principal de l'application.

- Query - une classe qui représente la requête de l'application. C'est un conteneur pour tous les détails de la requête. Les objets de la classe Query sont normalement créés en appelant une des méthodes de QueryFactory qui fournissent un accès à des analyseurs différents.

- QueryExecution - représente l'exécution d'une requête.

- QueryExecutionFactory - un endroit pour obtenir des instances de QueryExecution.

- DatasetFactory - un endroit pour créer des jeux de données, y compris créer une DataSource (un Dataset que l'on peut mettre à jour).

- pour les requêtes SELECT :

III - Les requêtes SELECT

Les étapes de base pour faire une requête SELECT sont décrites dans l'exemple ci-dessous. Une requête est créée à partir d'une chaîne de caractères utilisant la QueryFactory. La requête et le modèle ou le jeu de données RDF pouvant être interrogés sont ensuite transmis à QueryExecutionFactory pour produire une instance de l'exécution de la requête. Les résultats sont traités dans une boucle et finalement l'exécution de la requête est fermée.

import com.hp.hpl.jena.query.* ;
Model model = ... ;
String queryString = " .... " ;
Query query = QueryFactory.create(queryString) ;
QueryExecution qexec = QueryExecutionFactory.create(query, model) ;
try {
ResultSet results = qexec.execSelect() ;
for ( ; results.hasNext() ; )
{
QuerySolution soln = results.nextSolution() ;
RDFNode x = soln.get("varName") ;       // Get a result variable by name.
Resource r = soln.getResource("VarR") ; // Get a result variable - must be a resource
Literal l = soln.getLiteral("VarL") ;   // Get a result variable - must be a literal
}
} finally { qexec.close() ; }

Il est important de fermer proprement l'exécution de la requête quand elle se termine. Les ressources du système sont connectées à un stockage persistant et ont besoin d'être libérées.

Un ResultSetARQ prend en charge l'interface itérateur de Java, donc ce qui suit est aussi une façon de traiter les résultats si vous préférez :

Iterator<QuerySolution> results = qexec.execSelect() ;
for ( ; results.hasNext() ; )
{
QuerySolution soln = results.next() ;
. . .
}

L'étape de la création d'une requête et aussi celle de l'exécution d'une requête peuvent être réduites en une seule dans certains cas les plus communs :

import com.hp.hpl.jena.query.* ;
Model model = ... ;
String queryString = " .... " ;
QueryExecution qexec = QueryExecutionFactory.create(queryString, model) ;
try {
ResultSet results = qexec.execSelect() ;
. . .
} finally { qexec.close() ; }

III-A - Exemple : le formatage d'un ensemble de résultats

Au lieu d'une boucle pour le traitement de chaque ligne du jeu de résultats, l'application peut appeler une opération du ResultSetFormatter. C'est ce que les applications en ligne de commande font.

Exemple : traiter les résultats pour produire un texte de présentation simple :

ResultSetFormatter fmt = new ResultSetFormatter(results, query) ;
fmt.printAll(System.out) ;

ou simplement :

ResultSetFormatter.out(System.out, results, query) ;

III-B - Exemple : les résultats du traitement

Les résultats sont des objets provenant de l'API RDF de Jena et des appels de l'API, qui ne modifient pas le modèle, et qui peuvent être mélangés avec le traitement des résultats de la requête :

for ( ; results.hasNext() ; )
{
// Access variables: soln.get("x") ;
RDFNode n = soln.get("x") ; // "x" is a variable in the query
// If you need to test the thing returned
if ( n.isLiteral() )
((Literal)n).getLexicalForm() ;
if ( n.isResource() )
{
Resource r = (Resource)n ;
if ( ! r.isAnon() )
{
... r.getURI() ...
}
}
}

Les mises à jour du modèle doivent être effectuées après que l'exécution de la requête est terminée. Généralement, ceci implique la collecte des résultats d'intérêt dans une structure de données locales et en boucle sur cette structure une fois l'exécution de la requête terminée et fermée.

IV - Les requêtes CONSTRUCT

Les requêtes CONSTRUCT retournent un seul graphe RDF. Comme d'habitude, l'exécution de la requête doit être fermée après utilisation.

Query query = QueryFactory.create(queryString) ;
QueryExecution qexec = QueryExecutionFactory.create(query, model) ;
Model resultModel = qexec.execConstruct() ;
qexec.close() ;

V - Les requêtes DESCRIBE

Les requêtes DESCRIBE retournent un seul graphe RDF. Différents gestionnaires de l'opération DESCRIBE peuvent être chargés et ajoutés par l'application.

Query query = QueryFactory.create(queryString) ;
QueryExecution qexec = QueryExecutionFactory.create(query, model) ;
Model resultModel = qexec.execDescribe() ;
qexec.close() ;

VI - Les requêtes ASK

L'opération Query.execAsk () retourne une valeur booléenne indiquant si le modèle de requête correspond au graphe ou au jeu de données, ou non.

Query query = QueryFactory.create(queryString) ;
QueryExecution qexec = QueryExecutionFactory.create(query, model) ;
boolean result = qexec.execAsk() ;
qexec.close() ;

VII - Formater les résultats XML

La classe ResultSetFormatter possède des méthodes pour écrire les résultats d'interrogation SPARQL au format XML. Voir la méthode ResultSetFormatter.outputAsXML.

VIII - Jeux de données

Les exemples ci-dessus sont tous des requêtes sur un modèle unique. Une requête SPARQL est faite sur un jeu de données, qui est un graphe par défaut et zéro ou plusieurs graphes nommés. Les jeux de données peuvent être construits en utilisant DatasetFactory :

String dftGraphURI = "file:default-graph.ttl" ;
List namedGraphURIs = new ArrayList() ;
namedGraphURIs.add("file:named-1.ttl") ;
namedGraphURIs.add("file:named-2.ttl") ;

Query query = QueryFactory.create(queryString) ;

Dataset dataset = DatasetFactory.create(dftGraphURI, namedGraphURIs) ;
QueryExecution qExec = QueryExecutionFactory.create(query, dataset) ;
try { ... }
finally { qExec.close() ; }

Les modèles déjà existants peuvent également être utilisés : une DataSource est un jeu de données pouvant être mis à jour.

DataSource dataSource = DatsetFactory.create() ;
dataSource.setDefaultModel(model) ;
dataSource.addNamedModel("http://example/named-1", modelX) ;
dataSource.addNamedModel("http://example/named-2", modelY) ;
QueryExecution qExec = QueryExecutionFactory.create(query, dataSource) ;

IX - L'article original

Cet article est la traduction de ARQ - Application API.

X - Remerciements

Merci à Claude Leloup et jacques_jean pour leur relecture orthographique.