1. Studiu comparativ Jena -
Sesame
Andrei Ciprian Constantin
Marcu Ioana
1. Prezentare generala a celor doua API-uri : Jena si Sesame
Am ales sa facem o paralela intre Jena si Sesame,doua framework-uri destinate
procesarii RDF, deoarece sunt cele mai utilizate in acest moment si sunt cele mai mature
dintre toate framework-urile java disponibile. Pentru procesarea RDF mai avem la dispozitie
pentru platforma Java : JRDF ( se bazeaza pe Jena, Sesame), Aquamarine,Protege etc.
Sesame este un framework opensource care permite lucrul cu diferite resurse RDF.
Sunt posibile atat scrierea cat si extragerea de triplete RDF folosind diferite surse de
informatii. Poate fi folosit atat ca o librarie java standard dar si sub forma de server,
instaland Sesame sub Tomcat ca un servlet care va oferi suport pentru interogari si salvari
RDF in cadrul oricarei aplicatii web sau direct din browser.
Obiectul prin care sunt accesate resurse RDF in Sesame este denumit repository
fiecare operatiune de interogare sau salvare se va face prin acest obiect. Se pot folosi ca
repository fisiere RDF locale, resurse RDF de pe web sau o baza de date relationala.
Datorita modului de organizare al framework-ului din perspectiva programatorului nu exista
nici o diferenta intre diferitele surse de stocare a datelor RDF, modalitatea de interogare si
salvare a tripletelor RDF fiind aceeasi. Un avantaj al framework-ului Sesame il reprezinta si
faptul ca asupra repository-ului se pot executa operatii de scriere/citire folosind tranzactii
astfel incat se limiteaza aparitia inconsistentelor din "baza de date" RDF.
Ca sursa de date o performanta optima se poate obtine atunci cand se foloseste ca
metoda de stocare o baza de date obiectuala, Sesame stiind sa lucreze cu PostGresql ca
repository.
Ca si Sesame, Jena este un framework Java pentru procesari RDF, oferind in plus si
suport pentru OWL ( Web Ontology Language) . Jena este dezvoltat de
HP Labs Semantic Web Research si este distribuit sub licenta open source. Framework-ul
este alcatuit dintr-un API RDF , parsere si writere pentru resurse RDF in diferite formate
( RDF/XML, N3, N-Triples), un motor OWL, un sistem persistent de stocare a tripletelor RDF
si motorul de interogari SPARQL. Framework-ul poate fi usor extins deoarece expune toate
functionalitatea interna prin intermediul interfetelor, astfel pornind de la Jena a mai fost
dezvoltat si framework-ul JRDF-ul. Spre deosebire de Sesame, Jena nu poate fi folosit sub
forma de server de interogari RDF.
1

2. 3. Arhitectura Jena si Sesame
Distributia Sesame contine urmatoarele arhive .jar :
• sesame.jar. Clase de baza Sesame
• rio.jar. Set de parseri si obiecte de tip I/O pentru diferite formate de serializare RDF
• openrdf-model.jar. Obiecte si interfete care reprezinta modelul RDF
• openrdf-util.jar. Diferite clase utilitare.
Figura 1. Arhitectura Sesame
Pornind de sus in jos arhitectura Sesame cuprinde:
• Programul client care se foloseste de Sesame pentru a accesa resurse RDF
• Sesame Access API - layer care ofera acces programului client la resurse RDF atat
sub forma unui servlet care poate fi accesat de pe web sau sub forma unui
repository
• un alt nivel de acces il reprezinta nivelul Graph API si Sesame Repository API. Primul
API ofera acces avansat la resurse RDF, cum ar fi crearea de modele RDF direct din
cod iar al doilea api ofera acces pentru interogarea si stocarea de resurse RDF.
• la nivelul urmator avem Storage and Inference Layer. Aici se se abstractizeaza
modalitatea de stocare a resurselor RDF (baza de date, fisier, resursa web), se ofera
suport pentru inferente si pentru acces concurent.
2

3. Arhitectura Jena (Figura 2) are ca scop realizarea de reprezentari multiple pentru un
graf RDF. Acest lucru ofera programatorului o mai buna manipulare a datelor RDF.
Aplicatia accesaza tripletele RDF prin intermediul interfetei Model care translateaza
operatiile de nivel inalt in operatii low-level care se executa asupra tripletelor stocate ca
intr-un graf RDF. Operatiile de nivel intalt pot fi de tip Sparql sau apeluri de API Jena. Ca
modalitate de stocare a grafului RDF putem avea o baze de date relationala ( Mysql), o
baza de date obiectuala (PostgreSql), il putem stoca sub forma unui obiect java in
memorie sau intr-un fisier din care il putem reincarca mai tarziu.
Figura 2. Arhitectura Jena
3

4. 4. SeRQL vs Sparql
Interogarile facute asupra documentelor RDF pot fi facute din mai multe puncte de vedere :
• din punct de vedere sintactic documentele RDF pot fi vazute ca documente XML
• din punct de vedere structural pot fi vazute drept colectii de triplete
• din punct de vedere semantic pot fi vazute ca un graf.
Interogarile RDF cel mai bine sunt facute la nivel semantic. In Sesame astfel de interogari,
spre deosebire de JENA unde se foloseste Sparql, se fac folosindu-se un limbaj nativ SeRQL
(Sesame RDF Query Language). Avantajele SeRQL sunt faptul ca suporta interogari
imbricate ( interogari folosind operatori de genul IN, EXISTS care primesc ca argument
rezultatul altei interogari SeRQL) si faptul ca sintaxa este putin mai "user friendly".
Dezavantajul ar fi ca acest limbaj nu reprezinta un starad W3C precum Sparql si faptul ca
nu poate fi folosit in alte framework-uri, celelalte unelte java pentru RDF folosind Sparql ca
limbaj de interogare. In acelasi timp interogarile SeRQL rulate cu Sesame vor fi mai rapide
decat cele Sparql din cauza implementarii native.
Pentru a exemplifica diferentele prezentam mai jos interogarile SeRQL respectiv Sparql
pentru a gasi titlurile filmelor in care joaca Arnold Schwarzenegger precum si denumirea
personajului jucat:
Sparql SeRQL
SELECT DISTINCT
PREFIX movie: <http://example.org/movies/
X, T
>
FROM
SELECT DISTINCT ?x ?t
{X} movie:title {T};
WHERE { ?x movie:title ?t ;
movie:hasPart {Y} movie:characterName
movie:hasPart ?y .
{Z}
?y movie:characterName ?z .
WHERE
FILTER (?z = “Arnold
Z = “Arnold Schwarzenegger”@en
Schwarzenegger”@en)
USING NAMESPACE
}
movie = <http://example.org/movies/>
Dupa cum se poate vedea si din exemplu de mai sus SeRQL are o sintaxa asemanatoare cu
cea SQL. In prima parte a interogarii, in clauza SELECT avem variabilele care vor fi
returnate. In clauza FROM avem calea din graf in care vrem sa facem cautarea iar in clauza
WHERE avem conditii aditionale.
4

5. O alta facilitate a limbajului SeRQL o reprezinta faptul ca putem construi dintr-un
graf un subgraf al sau pe baza anumitor conditii. Vom obtine astfel ca rezultat o serie de
triplete RDF care pot sa aiba structura obiectelor din graful original sau pot fi derivate din
aceastea. Pentru a realiza acest lucru se foloste clauza CONSTRUCT. De asemenea se pot
combina folosind aceasta clauza si obtine ca rezultat un subgraf avand ca parinti doua
grafuri distincte.
Mai sus am precizat si faptul ca SeRQL suporta si interogari imbricate. Ca si in SQL in
clauza WHERE putem avea subinterogari. Astfel avem la dispozitie urmatorii operatori :
• operatorul IN
• operatorul ANY
• operatorul ALL
• operatorul EXISTS
Operatorul IN permite gasirea unor rezultate pentru care o anumita proprietate
poate sa aiba valorile dintr-o anumita multime, in dreapta operatorul IN vom aveam
interogarea care va returna acea multime de valori.
Operatorul EXISTS poate fi folosit pentru a afla daca o anumite proprietate are
setata o valoare sau nu, se pot face interogari de genul: gasiti toate filmele pentru care nu
se stie anul aparitiei.
5. Procesarea datelor RDF in Jena si Sesame
Framework-ul Jena ofera clase pentru pentru reprezentarea grafurilor RDF,
resurselor, proprietatilor si literalilor prin intermediul claselor. Interfetele care modeleaza
aceste concepte sunt : Model ( graf) , Resource, Property, Literal.
5.1 Crearea Modelului (Jena) vs Repository (Sesame)
In Jena sunt foarte multe moduri de a crea un model prin intermediul clasei
ModelFactory, lasand astfel utilizatorul sa reprezinte graful rdf asa cum doreste. Cel mai
simplu mod de a crea un model gol, reprezentat in memorie este astfel :
ModelFactory.createDefaultModel()
Pentru a crea un model care poate fi regasit ulterior dupa nume trebuie sa folosim
clasa ModelMaker pe care o obtinem prin intermediul clasei ModelFactory astfel :
ModelFactory.createMemModelMaker().
Vom avea astfel acces la funtii precum : createModel(String ), openModel(String)
care creaza un model cu numele dorit in memorie.
Pentru a crea un model pornind de la un fisier vom apela metoda
createFileModelMaker(numer_fisier) a clasei ModelMaker care va returna un model care va fi
memorat pe disc. Cand modelul va fi inchis continutul acestuia va fi salvat pe disc in fisierul
trimis ca parametru metodei prezentate mai sus.
5

6. Pentru a memora modelul sub forma unei baze de date se poate folosi functia
createModelRDBMaker(IDBConnection c). Aceste tip de modele pot fi mult mai mari decat
cele create in fisiere sau in memorie, datele sunt persistate instant dar viteza de procesare
este mult mai mica decat in celelalte cazuri. Obiectul conexiune c poate fi creat in 2 moduri:
• -ModelFactory.createSimpleRDBConnection(url,user,pass,type) - url-ul
reprezinta un string de conectare JDBC.
• -ModelFactory.createSimpleRDBConnection() - in acest caz se vor folosi
datele de conectare din configuratia jena si anume jena.db.url, jena.db.user,
jena.db.password si jena.db.type.
Pentrul accesul la diferite baze de cunostinte RDF se pot folosi 2 interfete puse la
dispozitie de framework-ul Sesame :
org.openrdf.repository.sail.SailRepository ( interfata folosita pentru accesul unui
repository RDF local )
org.openrdf.repository.http.HTTPRepository ( interfata folosita pentru accesul unui
repository Sesame remote de pe web)
Cel mai simplu tip de repository care poate fi construit in Sesame este cel stocat in
memeorie. In exemplul de mai jos creeam un astfel de repository trimitand ca parametru
constructorului un obiect SAIL de tip MemoryStore :
Repository myRepository = new SailRepository(new MemoryStore());
myRepository.initialize();
Pentru a creea un repository Sesame in memorie care din timp in timp isi salveaza
continutul pe disc putem utiliza urmatorul cod:
File dataDir = new File("c:tempmyRepository");
MemoryStore memStore = new MemoryStore(dataDir);
memStore.setSyncDelay(1000L);
Repository myRepository = new SailRepository(memStore);
myRepository.initialize();
Cea mai buna modalitate de stocare a unui repository Sesame o reprezinta cea nativa
sub forma binara pe disc. Aceasta ofera suport pentru date de mari dimensiuni si pentru un
acces rapid la acestea. Codul care creaza un astfel de repository este:
File dataDir = new File("/path/to/datadir/");
Repository myRepository = new SailRepository(new NativeStore(dataDir));
myRepository.initialize();
Pentru a accesa un repository Sesame de pe web trebuie sa specificam adresa serverului
care gazduieste acest repository precum si identificatorul repository-ului ca in urmatorul
exemplu:
String sesameServer = "http://example.org/sesame2";
String repositoryID = "example-db";
Repository myRepository = new HTTPRepository(sesameServer, repositoryID);
myRepository.initialize();
6

7. 5.2 Scrierea/Citirea/Parcurgerea unui graf RDF
Folosind Jena este foarte usor sa se afiseze un model RDF pe ecran apeland functia
write () , care accepta ca parametrul streamul de iesire unde va fi afisat. Un alt parametrul
pe care putem sa il specificam este limba. Formatul in care acesta va fi afisat este RDF XML
si respecta specificatiile w3c. Modelul poate fi incarcat de asemenea dintr-un fisier in format
RDF-XML. Toate exemplele sunt preluate de pe tutorialul oficial.
static String personURI = "http://somewhere/Ioana";
static String fullName = "Ioana Ciprian";
Model model = ModelFactory.createDefaultModel();
Resource ioanaResource = model.createResource(personURI);
ioanaResource.addProperty(VCARD.FN, fullName);
model.write(System.out);
model.read( FileManager.get().open( "inputFileName"));
Output-ul afisat este :
<rdf:RDF xmlns:rdf='http://www.w3.org/1999/02/22-rdf-syntax-ns#'
xmlns:vcard='http://www.w3.org/2001/vcard-rdf/3.0#'
>
<rdf:Description rdf:about='http://somewhere/Ioana'>
<vcard:FN>Ioana</vcard:FN>
</rdf:Description>
</rdf:RDF>
Parcurgerea informatiilor dintr-un model se poate face prin intermediul unui iterator de tip
StmtIterator astfel:
StmtIterator iter = model.listStatements();
while (iter.hasNext()) {
Statement stmt = iter.nextStatement();
Resource subject = stmt.getSubject();
Property predicate = stmt.getPredicate();
RDFNode object = stmt.getObject();
System.out.print(subject.toString());
System.out.print(" " + predicate.toString() + " ");
if (object instanceof Resource) {
System.out.print(object.toString());
} else {
// object is a literal
System.out.print(" "" + object.toString() + """);
}
System.out.println(" .");
}
In Sesame crearea de resurse RDF si scrierea lor in repository-uri se face ca
in exemplu din codul de mai jos:
// creem obiectul de tip repository, vom avea un repository in memorie
nepersistent
Repository myRepository = new SailRepository(new MemoryStore());
7

8. myRepository.initialize();
alueFactory f = myRepository.getValueFactory();
// creem resursele
URI ioana= f.createURI("http://example.org/people/ioana");
URI name = f.createURI("http://example.org/ontology/name");
URI person = f.createURI("http://example.org/ontology/Person");
Literal ioanasName = f.createLiteral("Ioana");
RepositoryConnection con = myRepository.getConnection();
con.add(ioana, RDF.TYPE, person);
con.add(ioana, name, ioanasName);
con.close();
5.3 Cautarea intr-un graf
Sunt mai multe metode in Jena pentru parcurgerea informatiilor si cautarea dupa un
anumit criteriu. Cea mai simpla, ilustrata mai sus nu este indicata pentru modelele mari.
O alta metoda de a obtine un iterator care resursele care au o proprietate "prop" cu
valoarea "value" este prin apelul functiei listSubjectWithProperty (Property prop, RDFNode
value) . De exemplu daca dorim toate resursele care au ca proprietate VCARD.FN putem
scrie :
ResIterator iter = model.listSubjectsWithProperty(VCARD.FN);
while (iter.hasNext()) {
Resource r = iter.nextResource();
...
}
O alta metoada este cu ajutorul functiei membre a interfetei Model : listStatements(Selector
s) care intoarce un iterator catre toate statementurile(tripletele) din model selectate de
catre s. O implementare a interfetei Selector este SimpleSelector, iar un obiect de acest tip
se poate crea astfel :
Selector selector = new SimpleSelector(subject, predicate, object).
Astfel interogarea anterioara se poate rescrie :
Selector selector = new SimpleSelector(null, VCARD.FN, null);
6. Performante Jena vs Sesame
In cadrul tutorialului prezentat in 2006 la conferinta ESWC pentru Sesame se mentiona
ca pentru un repository continand 69 de milioane de triplete din cadrul benchmark-ului
LUBM timpul de incarcare a tripletelor intr-un repository nativ a fost aproximativ 3 ore, iar
dupa incarcare viteza de evaluare a query-urilor SeRQL a fost cuprinsa intre 10-50 ms si 1-5
secunde, un rezultat destul de bun avand in vedere marimea datelor precum si stadiul de
dezvoltare al framework-ului, acum rezultatele probabil sunt mult mai bune.
In cadrul altui test facut de catre Nipun Bhatia rezultatele obtinute pentru incarcarea
unui set de date de 15,472,624 triplete s-a obtinut graficul din figura 3. Se poate observa
usor diferenta destul de mare de performanta dintre motorul nativ Sesame fata de Jena.
8

9. Ryan Lee in cadrul unui test efectuat in anul 2004 folosind un set de date cuprinzand
170,244 triplete a obtinut rezultate care arata ca Jena este mai rapid la scrierea intr-un
model a tripletelor RDF decat Sesame dar este mai incet la interogarea unui astfel de model
decat Sesame. Rezultatele obtinute de catre Ryan relativ la viteza de executie a
interogarilor RDF Lee sun prezentate in tabelul urmator :
Jena (model salvat intr-o Sesame (PostgreSQL
baza de date PostgreSQL ) repository)
Load page 115791 ms 2047 ms
Ar mai trebui adaugat ca pentru a putea realiza repository-uri foarte mari de resurse
RDF Sesame suporta crearea de modele distruite de procesare RDF folosind conceptul de
"RDF federation". Au fost create 2 de astfel de noduri de procesare RDF distribuite AliBaba's
Federation ibazat pe Sesame 2.3 si care poate functiona cu oricare endpoint Sparql si
Sesame's Federation bazat pe Sesame 3.0.
7. Documentatie si suport oferit de Jena si Sesame
Jena ofera suport prin intermediul listei de mailuri : jena_dev. De asemnea o
documentatie destinata si utlizatorilor care nu cunosc prea bine RDF-ul se gaseste si pe
pagina oficiala a dezvoltatorilor : http://jena.sourceforge.net/documentation.html. Jena
ofera si exemple concrete pornind pornind de la cele mai simple precum crearea unui
model. Datorita largii utilizari a framework-ului Jena si faptului ca ofera utilizatorului multe
functionalitati pentru procesarea RDF, pe web se gasesc mai multe informatii si exemple
care usureaza munca dezvoltatorului.
Pentru Sesame nu exista documentatie oficiala, Java Doc contine doar definitia
metodelor. Acest lucru constituie un lucru foarte important pentru dezvoltator pentru ca sa
stie cum sa foloseasca corect ce are pus la dispozitie de framework.
9

10. 8. Concluzii
Avand in vedere ca Java are ofera deja suport pentru serviciile web, este o ocazie
pentru aceasta platforma sa se maturizeze in ceea ce priveste procesarea RDF iar Jena si
Sesame reprezinta un pas in explorarea acestui domeniu. Jena pune la dispozitia
dezvoltatorilor un framework care ofera dezvoltatorilor o putere mare de dezvoltare si o
mare extensibiliate. De asemeni Jena datorita adoptarii standardelor W3C prezinta o mai
mare “incredere” din partea dezvoltatorilor. Spre deosebire de Jena Sesame si-a creat
propriul limbaj de interogari RDF si nu ofera o extensibilitate atat de usoara. Sesame sta
prost si la capitolul documentatie dar ofera o viteza mai buna de executie a interogarilor
RDF, un servlet prin care pot fi rulate interogari RDF foarte usor din orice aplicatie web si se
pare ca a castigat in popularitate datorita acestor lucruri fata de Jena.
Bibliografie
http://java-source.net/open-source/rss-rdf-tools
http://www.iandickinson.me.uk/articles/jena-eclipse-helloworld/
http://www.ibm.com/developerworks/xml/library/j-jena/
http://www.slideshare.net/yuhana/070517-jena
http://www.ea2215.univ-brest.fr/publications/par_chercheur/saliou/17-2007-SAKAI.pdf
http://simile.mit.edu/reports/stores/
http://labs.ingenta.com/2006/05/juc/paper.pdf
http://ist.kunsan.ac.kr/teaching/07.01.graduate.NewDatabaseTechnologies/08-LUBM__A
%20Benchmark%20for%20OWL%20Knowledge%20Base%20Systems-2005.pdf
10