Débuter avec Sesame

On a vu précédemment quelles étaient les différences entre Sesame et Jena. Voyons comment installer un serveur Sesame pour manipuler facilement des données RDF. Pas de fichiers de configuration compliqués à éditer, c'est du facile, et une fois dans l'interface d'administration Web, vous trouverez tout ce dont vous avez besoin : ajouter des fichiers RDF, faire une requête SPARQL, naviguer dans les données, etc.

Première partie : installer le serveur.

1. Prérequis : Java doit être installé sur votre machine.
2. Téléchargez Sesame en suivant les liens de téléchargement depuis http://www.openrdf.org (version 2.6.5 au moment de l'écriture de ces lignes) et en prenant le fichier nommé openrdf-sesame-x.y.z-sdk.zip.
3. Téléchargez Tomcat en suivant les liens de téléchargement depuis http://tomcat.apache.org/ (version 7.0.27 au moment de l'écriture de ces lignes). Sous « Binary Distribution > Core », choisissez le format zip.
4. Dézippez le fichier apache-tomcat-a.b.c.zip dans le répertoire de votre choix.
5. Dézippez le fichier openrdf-sesame-x.y.z-sdk.zip dans le répertoire de votre choix.
6. Copiez les fichiers openrdf-sesame-x.y.z/war/openrdf-sesame.war et openrdf-sesame-x.y.z/war/openrdf-workbench.war dans le répertoire apache-tomcat-a.b.c/webapps.
7. Démarrez Tomcat à l'aide des commandes apache-tomcat-a.b.c/bin/startup.bat (ou .sh).
8. Accédez dans votre navigateur à l'adresse http://localhost:8080/openrdf-workbench : c'est la console Web d'administration de Sesame.

Deuxième partie : paramétrer un entrepôt RDF.

1. Dans la console d'administration, cliquez sur « New Repository » en haut à gauche.
2. Dans le menu qui s'affiche, sélectionnez « In Memory Store », et donnez un ID et un titre à votre repository, par exemple « Test » et « Mon repository de test » ; c'est dans cet écran que vous pouvez choisir le mode de stockage du repository, dans une base, dans des fichiers, etc. Si vous avez besoin de stocker le RDF dans une base de données, c'est ici que ça doit se faire. Pour le moment, on va garder le RDF en mémoire, avec une synchronisation dans un fichier pour ne pas perdre les données en cas d'arrêt du serveur. Cliquez sur Next.
3. Le formulaire affiche maintenant les champs « Persist Yes/No » et « Sync Delay » ; laissez « Persist » à « Yes » et entrez la valeur « 100 » pour « Sync Delay » ; cliquez sur Create.
4. Le repository est créé et vous avez maintenant accès aux fonctions d'admin sur la gauche, notamment « Add » pour uploader des données RDF ; allez-y, vous pouvez uploader un fichier de données RDF.

Sesame dispose d'une API Java permettant de manipuler du RDF en mémoire, d'interroger un serveur Sesame (voir la procédure d'installation d'un serveur Sesame), ou d'interroger un endpoint SPARQL distant. Voici un « quickstart » permettant de commencer à travailler avec l'API en quelques minutes, en ajoutant les dépendances adéquates et avec un exemple de code complet. Vous pouvez également vous référer à la documentation de l'API Sesame.

II-A. JAR nécessaires▲

II-B. Démarrage rapide▲

// I : création du Repository  

// création du Repository en mémoire.  
Repository repository = new SailRepository(new MemoryStore());    
// initialisation du Repository : cet appel est obligatoire une fois et une seule  
repository.initialize();  

// II : chargement de fichier RDF  

// le fichier RDF contenant les données à charger  
File fileToAdd = new File("/fichier/à/charger.rdf");  
// charger les données dans le Repository  
repository.getConnection().add(  
    // référence au fichier à charger  
    fileToAdd,  
    // namespace par défaut à utiliser pour les URI relatives contenues dans le RDF  
    RDF.NAMESPACE,    
    // format du fichier RDF à charger (RDF/XML, N3, TRIG, etc.)  
    // le format est déterminé dynamiquement à partir de l'extension du fichier  
    // (.rdf, .n3, .trig, etc.)  
    RDFFormat.forFileName(fileToAdd.getName())  
);  

// III : écriture de fichier RDF  

// on utilise RDFXMLWriter qui génère du RDF/XML  
repository.getConnection().export(new RDFXMLWriter(new FileOutputStream("/fichier.rdf")));  

// on peut remplacer par N3Writer pour sortir du N3  
// dans ce cas, bien mettre l'extension du fichier à .n3  
// repository.getConnection().export(new N3Writer(new FileOutputStream("/fichier.n3")));  

// IV. Connexion à un serveur Sesame ou un endpoint SPARQL distant  

// pour se connecter à un serveur Sesame : utiliser le constructeur avec 2 String  
// en donnant l'adresse du serveur et le nom du repository  
Repository sesameServer = new HTTPRepository("http://localhost:8080/openrdf-sesame","Test");  
sesameServer.initialize();  

// pour se connecter à un endpoint SPARQL public : utiliser le constructeur avec 1 String  
// en donnant l'adresse du endpoint  
Repository dbpedia = new HTTPRepository("http://dbpedia.org/sparql");  
dbpedia.initialize();

On a vu précédemment comment utiliser l'API Sesame depuis un programme Java, quelles dépendances étaient nécessaires et comment faire les opérations de base avec un Repository : initialiser, charger des données, écrire des données.

Voilà maintenant comment effectuer des requêtes SPARQLSELECT et CONSTRUCT sur un Repository, et traiter les résultats. Les deux types de query utilisent des objets différents : TupleQuery et TupleQueryResultSELECT pour les SELECT, GraphQuery et GraphQueryResultCONSTRUCT pour les CONSTRUCT. Les commentaires dans le code ci-dessous parlent d'eux-mêmes, et n'hésitez pas à vous reporter à la documentation des API Sesame pour d'autres exemples.

// création du Repository en mémoire.
Repository repository = new SailRepository(new MemoryStore());    
// initialisation du Repository : cet appel est obligatoire une fois et une seule  
repository.initialize();  

// on ouvre une connexion au repository  
// comme en JDBC, c'est à travers cette connexion que sont envoyées toute les requêtes  
RepositoryConnection connection = repository.getConnection();  

// I. exemple de Query SELECT  

// on initialise la query.  
TupleQuery selectQuery = connection.prepareTupleQuery(    
    QueryLanguage.SPARQL,  
    "SELECT ?x ?foafName WHERE { ?x <http://xmlns.com/foaf/0.1/name> ?foafName }"    
);  

// on l'exécute 
TupleQueryResult selectQueryResult = selectQuery.evaluate();  

// on itère sur les résultats  
while(selectQueryResult.hasNext()) {  
    // chaque ligne du résultat est un BindingSet  
    BindingSet aBinding = selectQueryResult.next();  

    // on print les valeurs de cette ligne  
    System.out.println("Personne "+aBinding.getValue("x")+" a pour nom "+aBinding.getValue("foafName"));  

    // si on ne connaît pas les noms de variables de la query, on peut les récupérer dynamiquement  
    for (String aBindingName : selectQueryResult.getBindingNames()) {  
        System.out.println("La valeur de "+aBindingName+" est "+aBinding.getValue(aBindingName));  
    }  
}  

// II. Exemple de Query CONSTRUCT  

// on initialise la query  
GraphQuery constructQuery = connection.prepareGraphQuery(  
    QueryLanguage.SPARQL,  
    "PREFIX foaf: <http://xmlns.com/foaf/0.1/> " +    
    "PREFIX vcard: <http://www.w3.org/2006/vcard/ns#>" +  
    "CONSTRUCT {?x vcard:n _:n . _:n vcard:given-name ?name .} WHERE { ?x foaf:name ?name }"  
);  

// on l'exécute  
GraphQueryResult constructQueryResult = constructQuery.evaluate();  

// on itère sur les résultats, qui sont des Statements RDF, pas des bindings  
while(constructQueryResult.hasNext()) {  
    Statement anRDFStatement = constructQueryResult.next();  
    // ici on se contente d'afficher le Statement  
    // typiquement on devrait en faire quelque chose : écrire dans un fichier, ou  
    // l'insérer dans un autre Repository, etc.  
    System.out.println(anRDFStatement);  
}  

// quand on n'a plus besoin de la connexion, on la ferme  
connection.close();

Articles originaux :

• Tutoriel : comment installer un serveur RDF Sesame ? ;
• Tutoriel : exemple avec l'API Sesame RDF ;
• Tutoriel : exemple de query SPARQL avec l'API Sesame.

De Thomas Francart que nous remercions pour son autorisation de reproduire son article sur Developpez.com. Merci à Julien Plu pour la mise en page et à ClaudeLELOUP et jacques_jean pour leur relecture orthographique.