Utilisation du moteur D2RQ avec Jena

Puisque D2RQ se branche sur les composants de Jena et sur son moteur de requêtes SPARQL, ARQ, il est sensible à la version de Jena et de ARQ, qui sont utilisés. D2RQ ne fonctionnera pas normalement avec d'autres versions de Jena que celles qui sont livrées avec. Regardez le répertoire /lib/arq-X.Y dans la distribution de D2RQ pour la version utilisée.

1. Télécharger D2RQ.
2. Ajouter le fichier d2rq-X.Y.jar du répertoire /lib de D2RQ à votre CLASSPATH.
3. Ajouter l'ensemble des fichiers JAR du répertoire /lib/arq-X.Y dans le CLASSPATH de votre application.
4. Ajouter le JAR commons-logging-X.Y.jar et slf4j-api-X.Y.jar du répertoire /lib/logging de D2RQ dans le CLASSPATH de votre application. Si votre application ne configure pas son propre système de journalisation, ajouter les autres JAR de ce répertoire.
5. Ajouter un pilote JDBC pour votre base de données dans le CLASSPATH de votre application. Des pilotes pour quelques bases de données populaires sont disponibles dans le répertoire /lib/db-drivers de D2RQ.

Le téléchargement de D2RQ omet quelques fichiers JAR de Jena/ARQ qui ne sont pas requis pour lancer D2RQ, mais qui peuvent l'être pour utiliser d'autres fonctionnalités de Jena/ARQ. Pour avoir tous les JAR, vous pouvez télécharger la bonne version de ARQ (comme indiqué par le nom du répertoire de D2RQ /lib/arq-X.Y) à partir du site de téléchargement de Jena.

Les journaux de D2RQ utilisent l'API Apache Commons Logging. D2RQ est envoyé avec Apache log4j, mais vous pouvez utiliser une interface de journalisation différente.

Pour activer les messages de débogage de D2RQ, fixer le niveau d'enregistrement de la journalisation de.fuberlin.wiwiss.d2rq à ALL. Une façon facile de le faire est d'ajouter les JAR de log4j du répertoire /lib/logging de D2RQ au CLASSPATH de votre application, et de créer un fichier log4j.properties quelque part dans le CLASSPATH (par exemple, dans votre dossier source) avec ce contenu :

log4j.rootLogger=INFO, stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{HH:mm:ss} %-5p %-20c{1} :: %m%n
log4j.logger.de.fuberlin.wiwiss.d2rq=ALL

La classe ModelD2RQ fournit une vue Model de Jena sur les données dans la base de données associée avec D2RQ.

L'exemple suivant montre comment un ModelD2RQ est mis en place en utilisant un fichier d'associations déjà créé et comment les appels à l'API Jena sont utilisés pour extraire des informations à propos des publications et de leurs auteurs à partir du Model.

// Mise en place de l'objet ModelD2RQ utilisant un fichier d'associations
Model m = new ModelD2RQ("file:doc/example/mapping-iswc.ttl");

// Trouver n'importe quoi avec un iswc:InProceedings pour rdf:type 
StmtIterator paperIt = m.listStatements(null, RDF.type, ISWC.InProceedings);

// Lister les publications trouvées et afficher leur titre
while (paperIt.hasNext()) {
    Resource paper = paperIt.nextStatement().getSubject();
    System.out.println("Publication: " + paper.getProperty(DC.title).getString());

    // Liste les auteurs des publications et affiche leur nom
    StmtIterator authorIt = paper.listProperties(DC.creator);
    while (authorIt.hasNext()) {
        Resource author = authorIt.nextStatement().getResource();
        System.out.println("Auteur: " + author.getProperty(FOAF.name).getString());
    }
    System.out.println();
}
m.close();

Les classes ISWC et FOAF ont été créées avec l'outil schemagen de Jena. Les classes DC et RDF font partie de Jena.

Dans certaines situations, il est préférable d'utiliser l'API de bas niveau Graph de Jena à la place de l'API Model. D2RQ fournit une implémentation de l'interface Graph nommée GraphD2RQ.

L'exemple suivant montre comment l'API Graph est utilisée pour trouver toutes les publications qui ont été publiées en 2003.

// Chargement du fichier d'associations
Model mapModel = FileManager.get().loadModel("doc/example/mapping-iswc.ttl");

// Parcourt le fichier d'associations
MapParser parser = new MapParser(mapModel, "http://localhost:2020/");
Mapping mapping = parser.parse();

// Mise en place du GraphD2RQ
GraphD2RQ g = new GraphD2RQ(mapping);

// Crée un modèle find(spo)
Node subject = Node.ANY;
Node predicate = DC.date.asNode();
Node object = Node.createLiteral("2003", null, XSDDatatype.XSDgYear);
Triple pattern = new Triple(subject, predicate, object);

// Requête sur le graphe
Iterator<Triple> it = g.find(pattern);

// Affiche les résultats de la requête
while (it.hasNext()) {
    Triple t = (Triple) it.next();
    System.out.println("Published in 2003: " + t.getSubject());
};
g.close();

V-A. CachingGraphD2RQ▲

D2RQ peut répondre aux requêtes SPARQL sur un modèle D2RQ. L'exemple montre comment un modèle D2RQ est mis en place, comment une requête SPARQL est exécutée et comment les résultats sont écrits dans la console.

ModelD2RQ m = new ModelD2RQ("file:doc/example/mapping-iswc.ttl");
String sparql = 
    "PREFIX dc: <http://purl.org/dc/elements/1.1/>" +
    "PREFIX foaf: <http://xmlns.com/foaf/0.1/>" +
    "SELECT ?paperTitle ?authorName WHERE {" +
    "     ?paper dc:title ?paperTitle . " +
    "     ?paper dc:creator ?author ." +
    "     ?author foaf:name ?authorName ." +
    "}";
Query q = QueryFactory.create(sparql); 
ResultSet rs = QueryExecutionFactory.create(q, m).execSelect();
while (rs.hasNext()) {
    QuerySolution row = rs.nextSolution();
    System.out.println("Titre: " + row.getLiteral("paperTitle").getString());
    System.out.println("Auteur: " + row.getLiteral("authorName").getString());
};
m.close();

D2RQ est livré avec un assembleur Jena. Les spécifications de l'assembleur Jena sont des fichiers de configuration RDF qui décrivent comment construire un modèle Jena. Pour plus d'information sur les assembleurs Jena, consulter la page d'initiation de l'assembleur Jena.

L'exemple suivant montre une spécification d'un assembleur pour un modèle D2RQ :

@prefix : <#> .
@prefix ja: <http://jena.hpl.hp.com/2005/11/Assembler#> .
@prefix d2rq: <http://www.wiwiss.fu-berlin.de/suhl/bizer/D2RQ/0.1#> .

<> ja:imports d2rq: .

:myModel
    a d2rq:D2RQModel;
    d2rq:mappingFile <mapping-iswc.ttl>;
    d2rq:resourceBaseURI <http://localhost:2020/>;
    .

Les spécifications du modèle D2RQ supportent ces deux propriétés :

Cet exemple d'utilisation créera un modèle D2RQ à partir d'une spécification de modèle et l'écrira dans la console :

// Charger une spécification d'assembleur à partir d'un fichier
Model assemblerSpec = FileManager.get().loadModel("doc/example/assembler.ttl");

// Récupérer la ressource du modèle
Resource modelSpec = assemblerSpec.createResource(assemblerSpec.expandPrefix(":myModel"));

// Assemble un modèle
Model m = Assembler.general.openModel(modelSpec);

// L'écrit dans System.out
m.write(System.out);

m.close();

La documentation Javadoc pour la dernière version est disponible.

Merci à Richard Cyganiak pour son aide et ses conseils durant la réalisation de cette traduction, à Thibaut Cuvelier pour ses corrections et à ClaudeLeloup et à jacques_jean pour leur relecture orthographique.