Your SlideShare is downloading. ×
Joseki : un server per interrogare risorse RDF attraverso un interfaccia Web
Upcoming SlideShare
Loading in...5
×

Thanks for flagging this SlideShare!

Oops! An error has occurred.

×

Saving this for later?

Get the SlideShare app to save on your phone or tablet. Read anywhere, anytime - even offline.

Text the download link to your phone

Standard text messaging rates apply

Joseki : un server per interrogare risorse RDF attraverso un interfaccia Web

904
views

Published on


1 Comment
1 Like
Statistics
Notes
No Downloads
Views
Total Views
904
On Slideshare
0
From Embeds
0
Number of Embeds
1
Actions
Shares
0
Downloads
0
Comments
1
Likes
1
Embeds 0
No embeds

Report content
Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
No notes for slide

Transcript

  • 1. Università degli Studi di Roma La Sapienza Facoltà di Ingegneria Corso di Laurea in Ingegneria dellInformazione ind. Informatica Joseki : un server per interrogare risorse RDF attraverso uninterfaccia Web Tesi di Laurea di Daniele Palma 20 Luglio 2010Relatore:Prof. Ugo Vitti 2
  • 2. Desidero innanzitutto ringraziare il Professor Ugo Vitti per le numerose orededicate alla mia tesi. Infine, ho desiderio di ringraziare con affetto i mieigenitori per il sostegno ed il grande aiuto che mi hanno dato per essermi statovicino ogni momento durante questi anni di lavoro. 3
  • 3. Indice GeneraleIndice delle Figure 6Indice delle Tabelle 91 - Introduzione 102 - Semantic Web 12 2.1 Che Cosè?................................................................................................12 2.2 LArchitettura del Semantic Web.............................................................12 2.3 I principi del Semantic Web.....................................................................14 2.4 I Linguaggi del Web Semantico...............................................................143 - Resource Description Framework – RDF 17 3.1 Il Modello.................................................................................................18 3.2 La Sintassi................................................................................................20 3.3 La Grammatica Formale..........................................................................23 3.4 RDF Schema............................................................................................26 3.4.1. Classi e Proprietà.......................................................................27 3.4.2. I Vincoli....................................................................................294 - Joseki – Il server RDF di JENA 31 4.1 Joseki........................................................................................................31 4.2 Jena...........................................................................................................32 4.2.1. I tools di Jena............................................................................34 4.3 Introduzione a SPARQL..........................................................................35 4.3.1. Il Pattern Matching....................................................................36 4.3.2. Restrizione sui Valori................................................................39 4.3.3. Manipolazione del risultato.......................................................40 4.4 Un esempio di utilizzo.............................................................................405 - Procedure di installazione 43 5.1 Installazione di Joseki in locale...............................................................43 4
  • 4. 5.1.1. Configurazione di Joseki..........................................................44 5.2 Installazione di Joseki in remoto..............................................................50 5.3 Installazione di Jena.................................................................................536 - Risorse RDF pubbliche 54 6.1 Freebase...................................................................................................54 6.1.1. Esempio di risorsa Freebase.....................................................55 6.2 Dbpedia....................................................................................................57 6.2.1. Esempio di risorsa Dbpedia......................................................58 6.3 MERLOT.................................................................................................60 6.3.1 Esempio di risorsa MERLOT...................................................607 - Interrogazione di risorse RDF 62 7.1 Query su un data-set locale......................................................................62 7.2 Query su data-set remoti..........................................................................668 - Conclusione e sviluppi futuri 73 Appendice A 74 Appendice B 79 Sitografia 82 5
  • 5. Indice delle FigureCapitolo 2:Fig 2.1 : Architettura del Semantic WebFig 2.2 : file XMLCapitolo 3:Fig 3.1: Grafo corrispondente alla frase dell ES 3.1Fig 3.2: Grafo corrispondente alla frase dell ES 3.2Fig 3.3 : Rappresentazione in RDF del ES 3.3Fig 3.4 : Rappresentazione prima forma abbreviataFig 3.5 : Forma normale dell ES 3.5Fig 3.6 : Forma abbreviata dell ES 3.5Fig 3.7 : Forma normale dell ES 3.6Fig 3.8 : Forma abbreviata dell ES 3.6Fig 3.9 :Equivalenza scrittura tra RDF e RDF schemaFig 3.10 : RDF schema dell ES 3.8Fig 3.11 : RDF schema del ES 3.8Capitolo 4 :Fig 4.1: JosekiFig 4.2: Stack di JosekiFig 4.3 : Rappresentazione del modello dell ES 4.1Fig 4.4 : Creazione del modello e delle risorse dell ES 4.1Fig 4.5 : Richiesta degli Statements del modelloFig 4.6 : Richiesta del s p o di uno stamentFig 4.7 : Scrittura del contenuto del modelloFig 4.8 : Lettura di un modelloFig 4.9 : Rappresentazione di alcune tripleFig 4.10 : pattern-matchingFig 4.11 : Semplice query 6
  • 6. Fig 4.12 : uso del comando OPTIONALFig 4.13 : Uso di UNIONFig 4.14 : Query con restrizione su un valoreFig 4.15 : Operatore DistinctFig 4.16 : Altri operatori per la manipolazioneFig 4.17 : Query per un primo utilizzo di JosekiFig 4.18 : Frammento del file books.n3Capitolo 5 :Fig 5.1 : Uso comando unzipFig 5.2 : Uso comando chmodFig 5.3 : Settaggio variabile dambienteFig 5.4 : Avvio di josekiFig 5.5 : Dichiarazione dei prefissi della configurazione di JosekiFig 5.6 : Sezione del servizio di baseFig 5.7 : Selezione del data-setFig 5.8 : Data-set di un modello da fileFig 5.9 : Data-set costruito su più graficiFig 5.10 : Dichiarazione di più modelliFig 5.11 : Accesso ad un modello su DatabaseFig 5.12 : Dichiarazione di un processore standardFig 5.13 : Dichiarazione di un processore con data-set fissoFig 5.14 : Uso comando scpFig 5.15 : Uso comando sshFig 5.16 : Url di riferimento del serverFig 5.17 :Uso del comando nohupFig 5.18 : Modifica del file rc.localFig 5.19 : Visone del file rc.localFig 5.20 : De-compattazione di JenaFig 5.21 : Set variabile dambiente di JenaFig 5.22 : Aggiunta permessi di Jena 7
  • 7. Capitolo 6 :Fig 6.1 : Esempio di Argomentazioni FreebaseFig 6.2 : Raggruppamento dei topicFig 6.3 : Visualizzazione delle risorseFig 6.4 : Scelta del formatoFig 6.5 : Server offerto da DbpediaFig 6.6 : Rappresentazione della risorsa Semantic WebFig 6.7 : Formati di conversione della paginaFig 6.8 : Categorie delle risorseFig 6.9 : Visualizzazione delle risorseCapitolo 7 :Fig 7.1 :Query per lestrazione delle proprietà del data-setFig 7.2 : Risultato della query della Fig 7.1Fig 7.3 : Risorsa e titolo delle ricercheFig 7.4 : Risultato della query in Fig 7.3Fig 7.5 : Prelevo , titolo , data di sviluppo e sito del progettoFig 7.6 : Risultato query della Fig 7.5Fig 7.7 : Estrazione ID, nome , Livello e dataFig 7.8 : Risultato query 7.7Fig 7.9 : Estrazione nome e data di nozze delle principesse europeeFig 7.10 : Risultato query in Fig 7.9Fig 7.11 : Query sulla tavola periodica degli elementiFig 7.12 : Risultato della query mostrata nella Fig 7.12Fig 7.13 : nome e simbolo e peso degli elementi con peso > delluranioFig 7.14 : risultato query mostrata in Fig 7.13Fig 7.15 : Interrogazione di 2 data-setFig 7.16 : Risultato delle query in Fig 7.15Fig 7.17 : Estrazione proprietà DCFig 7.18 : Proprietà DCFig 7.19 : Estrazione proprietà VCARD 8
  • 8. Fig 7.20 : Proprietà standard VCARDIndice delle TabelleCapitolo 3Tab 3.1 : elementi ES 3.1Capitolo 4Tab 4.1 : Risultato della query in Fig 4.11Tab 4.2 : Risultato query della Fig 4.12Tab 4.3: Operatori SPARQLTab 4.4: Risultato Query 9
  • 9. Capitolo 1 Introduzione CAPITOLO 1 IntroduzioneLo scopo di questa tesi, e manipolare alcune risorse pubbliche con un processoreSPARQL installando un server per linterrogazione di risorse RDF (ResourceDescription Framework).Abbiamo scelto di lavorare con il server Joseki, che mette a disposizione unampiadocumentazione, e supporta il linguaggio di interrogazione SPARQL, standardizzato dalW3C [1], in un ambiente di lavoro web.Il Web Semantico si occupa di 2 cose: formati comuni per lintegrazione e lacombinazione di dati recuperati da diverse fonti e linguaggi per indicare come i datisiano correlati ad oggetti del mondo reale. Ciò significa che i dati presenti in undatabase, su una macchina possono portare ad un insieme infinito di database cheriguardano tutti lo stesso oggetto.Tutti gli standard, i linguaggi e il modo di esprimere i concetti, sono racchiusi nellastruttura a gradini del Semantic Web. Questa struttura, insieme a tutti i livelli che nefanno parte, sarà descritta allinterno del capitolo 2.Il Resource Description Framework [14], molto simile allXML, è parte integrante dellastruttura del Semantic Web e ne costituisce uno dei mattoni fondamentali. LRDFdescrive e definisce le proprietà di moltissime risorse presenti in rete: nel capitolo 3 sene descrive il modello e la sintassi, oltre allRDF Schema [18], che riesce ad imprimereed a restringere il dominio di applicazione di una proprietà.Nel capitolo 4, viene descritto dettagliatamente il funzionamento di Joseki [4] e di comepermetta, mediante luso del linguaggio di interrogazione SPARQL, di estrarreinformazione dalle risorse. Verrà spiegata la sintassi SPARQL ed inoltre si farà uso dellelibrerie di Jena, che permettono di manipolare un documento in RDF [22].Joseki utilizza indirettamente il server Jetty per lesecuzione e si mette in ascolto sullaporta 2020 (una volta attivato , andare su http://localhost:2020/sparql ). 10
  • 10. Capitolo 1 IntroduzioneNel capitolo 5 e presentata linstallazione del software, comprensiva di tutti i comandiutilizzati; verrà spiegato come installare il server Joseki localmente al sistema o su unamacchina remota. Inoltre, viene mostrata la configurazione dei servizi che Joseki cioffre e si passerà poi allinstallazione ed alla verifica di alcuni tools offerti da Jena per lamanipolazione di risorse RDF direttamente dal terminale.Si provvederà nel capitolo 6 ad illustrare alcuni repository pubblici ricercati sul web,come DBpedia o Freebase, che manipolano grandi quantità di risorse, mettendole adisposizione del pubblico. Si evidenzia come questi repository sfruttino direttamentetutti i concetti spiegati nella tesi per la manipolazione delle risorse.Infine, nel capitolo 7 sono riportate le query effettuate durante la tesi. Tali query sonostate catalogate in due gruppi: quelle eseguite su data-set locali per il server Joseki, equelle eseguite su data-set remoti per lo stesso server Joseki. Per accedere al servizioJoseki via Web, si deve accedere allindirizzo http://151.100.106.21:2020, oppure peraccedere ad un insieme di risorse correlate a www.retilatina.eu/palma/index.html. 11
  • 11. Capitolo 2 Semantic Web CAPITOLO 2 Semantic Web2.1. Che cosè ?Con lespressione "Semantic Web" si intende un insieme di tecnologie che hannolobiettivo di rendere le informazioni comprensibili ed elaborabili da parte diprogrammi: in pratica, lo scopo sta nel permettere a "macchine" (intese comeinfrastrutture e applicazioni software) di creare nuova conoscenza traendo delleconclusioni a partire dalla base di conoscenza iniziale.Attraverso linterpretazione del contenuto dei documenti che il Web semantico offre,saranno possibili ricerche molto più evolute delle attuali, basate sulla presenza neldocumento di parole-chiave ed altre operazioni specialistiche, come la costruzione direti di relazioni e connessioni tra documenti, secondo logiche più elaborate del semplicecollegamento ipertestuale.2.2. L Architettura del Semantic WebPer quanto riguarda standard e tecnologie, il Semantic Web deve essere inteso come unastruttura "a gradini": uno "stack" tecnologico, formato da più componenti, in cui ognilivello è la base per gli standard definiti ai livelli superiori ( Fig 2.1 ). Fig 2.1 : Architettura del Semantic Web 12
  • 12. Capitolo 2 Semantic Web • Alla base di questa architettura cè lo standard URI (Uniform Resource Identifiers) [9], che viene usato per la definizione univoca di risorse online : documenti, file e indirizzi internet. Al contrario, lo standard UNICODE è un sistema di codifica che associa una combinazione di bit ad ogni simbolo, carattere o segno, in modo indipendente dal programma, dalla piattaforma o dalla lingua utilizzata. • Al livello superiore si trova il metalinguaggio XML (eXtensible Markup Language) [7], che è di fondamentale importanza, unitamente ai NS (NameSpace) [8] e a XML Schema. XML è un linguaggio che porta con se alcune informazioni sulla semantica degli oggetti, mentre i NS, che vengono definiti tramite degli URI, garantiscono l interoperabilità tra i dizionari di meta- dati. • RDF (Resource Description Framework) [14] e RDF Schema [18] costituiscono il linguaggio per descrivere le risorse online e i loro tipi, per l interoperabilità semantica di dati e informazioni e consentono agli agenti intelligenti di effettuare inferenze logiche. • Al livello superiore si trova il Vocabolario delle Ontologie .Le Ontologie sono sistemi di meta-dati, riferiti a specifici vocabolari, che permettono di descrivere le relazioni tra le risorse Web, consentendo agli agenti intelligenti di interpretare e comprendere i dati.Non di minore importanza, ma ancora in fase di sviluppo, troveremo i livelli di : • Logica : prevede limplementazione di un linguaggio che consente di prevedere dei risultati. 13
  • 13. Capitolo 2 Semantic Web • Firma Digitale : è il sistema di autenticazione dei documenti digitali, la firma digitale attesta che una specifica persona ha scritto quel determinato documento. • Fiducia : il Web Semantico può essere osservato come un enorme database in cui lutente può accedere, ma è a sua discrezione comprendere quali siano i dati affidabili da quelli inaffidabili.2.3. I principi del Semantic WebIl Semantic Web si basa su sei principi fondamentali che sottendono allarchitettura delWeb Semantico e ne descrivono le caratteristiche essenziali : 1. Ogni cosa può essere identificata attraverso una URI . 2. Le risorse e i Link possono avere un “tipo”. 3. Linformazione parziale è tollerata. 4. Non cè bisogno di una verità assoluta. 5. Levoluzione è tollerata. 6. Design minimalista2.4. I Linguaggi del Semantic WebIl Web, è un enorme contenitore di informazioni, si è sviluppato mediante lausilio dellinguaggio HTML, questo si preoccupa soprattutto di curare la formattazione grafica deidocumenti nel web e non fornisce nessun supporto per strutturare e descrivere questeinformazioni dal punto di vista semantico.Il linguaggio HTML permette di condividere informazioni in modo semplice, lunicopresupposto è che queste informazioni siano costituite solamente da testo e immaginicon collegamenti ipertestuali.Attualmente le informazioni sul web sono diventate molto più complesse: video,database, musica e molto altro. E necessario quindi, un linguaggio che sia in grado di:descrivere tipologie di informazioni differenti e specifiche, definire relazioni complessedi collegamenti fra documenti e trasmettere informazioni in diversi formati. 14
  • 14. Capitolo 2 Semantic WebNasce, a tal proposito, XML: un metalinguaggio che permette di definire e crearesintatticamente dei linguaggi personalizzati di markup. Si tratta di un linguaggio apertoe basato su testo, che in termini pratici ci consente di esplicitare la struttura di undocumento dal punto di vista sintattico, attraverso marcatori allinterno del testo.Un documento XML è organizzato secondo una struttura logica ad albero e nonpresenta un insieme predefinito di elementi, ma ci consente di crearne di nuovi in basealle nostre esigenze.Esiste un elemento radice che deve essere sempre presente, ogni elemento può avere deifigli che, a loro volta, possono essere specificati da particolari attributi.In Fig 2.2 viene mostrato un tipico documento .xml : <?xml version="1.0" encoding="UTF-8"?> <utenti> <utente> <nome> Daniele </nome> <cognome> Palma </cognome> <indirizzo> Sezze </indirizzo> </utente> <utente> <nome> Marco</nome> <cognome> Rossi </cognome> <indirizzo> Roma </indirizzo> </utente> </utenti> Fig 2.2 : file XMLEsistono inoltre, diverse tecnologie di supporto allXML, come le DTD ( DocumentType Definition ), documenti attraverso cui si specificano le caratteristiche strutturali diun documento XML, grazie allausilio di una serie di "regole grammaticali". Inparticolare, si definisce: linsieme degli elementi del documento XML, le relazionigerarchiche tra gli elementi, lordine di apparizione nel documento XML e qualielementi e quali attributi sono opzionali o meno.Una seconda tecnologia di supporto è XML Schema che, come la DTD, serve adefinire la struttura di un documento XML. Il W3C consiglia di adottarlo al posto della 15
  • 15. Capitolo 2 Semantic WebDTD stessa, essendo una tecnica più nuova ed avanzata. La sua sigla è XSD, ( XMLSchema Definition ).In conclusione, per poter essere correttamente interpretato da un browser, un documentoXML deve essere ben formato, deve cioè possedere le seguenti caratteristiche: • Un prologo, che è la prima istruzione che appare scritta nel documento. Nel nostro caso: <?xml version="1.0" encoding="UTF-8"?>. • Un unico elemento radice (ovvero il nodo principale, chiamato root element) che contiene tutti gli altri nodi del documento. Nell ES 2.1 : <utenti>. • Allinterno del documento tutti i tag devono essere bilanciati.Se il documento XML non contiene errori si dice Well Formed (scritto correttamente).Se il documento è well formed e in più rispetta i requisiti strutturali definiti nel file DTDo XML Schema associato, viene chiamato Valid (valido).Un altro linguaggio di maggior importanza, usato per descrivere le risorse sul Web, èRDF che analizzeremo e presenteremo nel CAP 3. 16
  • 16. Capitolo 3 RDF-Resource Description Framework CAPITOLO 3 Resource Description Framework - RDFLa soluzione proposta dal W3C [14] per elaborare i meta-dati, usati nella descrizionedelle risorse presenti nel Web, consiste nell’utilizzo del Resource DescriptionFramework ( da ora in avanti RDF ).Fra gli obiettivi che il W3C si è proposto di raggiungere con la definizione di RDFpossiamo considerare: interoperabilità fra applicazioni e sviluppo diapplicazioni automatizzate per il trattamento delle risorse del Web in modo semplice.RDF potrà essere utilizzato in svariate aree applicative, come ad esempio, lacatalogazione di risorse facenti parte di un sito Web o di una libreria digitale,descrivendone il contenuto e le relazioni esistenti; rendere più efficientile indicizzazioni effettuate dai motori di ricerca; aiutare la condivisione e lo scambio diinformazioni da parte di agenti software intelligenti.In questo paragrafo, verrà introdotto il modello usato per rappresentare RDF e lasintassi usata per codificare e trasportare i meta-dati così espressi.Tale codifica verrà effettuata in modo da massimizzare l’interoperabilità el’indipendenza dai server che forniranno i meta-dati e dai client che usufruiranno di taliservizi. La sintassi presentata farà uso di XML .Inoltre, bisogna sottolineare come l’obiettivo di RDF sia quello di definire unmeccanismo per descrivere risorse che non fa assunzioni su un particolare dominioapplicativo, né definisce a priori la semantica per uno specifico dominio.La definizione di tale meccanismo sarà quindi indipendente dal campo di applicazionee permetterà la descrizione di informazioni relative ad ogni dominio. 17
  • 17. Capitolo 3 RDF-Resource Description Framework3.1. Il modelloRDF si basa su un modello per rappresentare proprietà e valori ad esseassociate. Le proprietà possono essere pensate come attributi di risorse ecorrispondono ad una coppia attributo-valore.Inoltre, mediante le proprietà, si possono rappresentare le relazioni fra le risorse equindi il modello di RDF può essere visto come uno schema entità-relazione. Per usarela terminologia della programmazione object-oriented, le risorse possono essere vistecome oggetti e le proprietà come variabili d’istanza.Il modello è composto da tre tipologie di oggetti:Risorse : tutto ciò che viene descritto da RDF è detto risorsa. Una risorsa può essere una pagina Web o una parte di essa ( identificata da un elemento HTML o XML) o un intero sito Web. L’identificatore di ogni risorsa è il proprio URI e pertanto una risorsa può anche essere un oggetto non direttamente accessibile dal Web.Proprietà: una proprietà è una caratteristica, un attributo o una relazione utilizzata per descrivere una risorsa. Ogni proprietà ha un significato specifico, definisce i valori che può assumere e i tipi di risorse a cui può essere associata.Asserzioni: una risorsa con una proprietà ed un valore ad essa associato è un’asserzione. Gli oggetti che prendono parte a questa associazione sono detti, rispettivamente: il soggetto, il predicato e l’oggetto. L’oggetto può essere una risorsa o un letterale. 18
  • 18. Capitolo 3 RDF-Resource Description FrameworkES 3.1 La frase: “Mario Rossi è l’autore della risorsa identificata dall’URL ̃ http://www.myhost.org/ mrossi” è composta dagli elementi elencati nella tabella seguente. Soggetto (risorsa) ̃ http://www.myhost.org/ mrossi Predicato (proprietà) Autore Oggetto (letterale) “Mario Rossi” Tabella 3.1 : elementi ES 3.1Questa frase può anche essere rappresentata mediante un grafo in cui i nodi (gli ovali)rappresentano le risorse e gli archi rappresentano le proprietà. I nodi che rappresentanoinvece dei letterali sono disegnati come rettangoli. Autore ̃ http://www.myhost.org/ mrossi Mario Rossi Fig 3.1: Grafo corrispondente alla frase dell ES 3.1ES 3.2 L’oggetto della frase: “La persona di nome Mario Rossi con email mrossi@myhost.org è autore della pagina identificata dall’URL ̃ http://www.myhost.org/ mrossi” è questa volta non più un letterale, ma un’entità` strutturata, rappresentata da un’altra risorsa. 19
  • 19. Capitolo 3 RDF-Resource Description Framework ̃ http://www.myhost.org/ mrossi Autore Nome E-mail Mario Rossi mrossi@myhost.org Fig 3.2: Grafo corrispondente alla frase dell ES 3.23.2 La SintassiIn questo paragrafo verranno presentati due tipi di sintassi per codificare un’istanza delmodello di RDF [16] :La sintassi di serializzazione: permette di esprimere il modello di RDF in maniera regolare.La sintassi abbreviata: estende la sintassi precedente, fornendo altri costrutti che permettono una scrittura più compatta del modello.Queste sintassi hanno comunque, lo stesso potere espressivo. Ogni proprietà assegnataad una risorsa viene elencata dentro un elemento rdf:Description. Questo elementopermette di identificare la risorsa mediante l’attributo rdf:about, contenente l’URI ditale risorsa. Se invece la risorsa non ha un URI, questo può essere fornito usandol’attributo rdf:ID; in questo modo viene creata una risorsa che fa da proxy per quellaoriginaria.Le proprietà così specificate, corrispondono ad archi diversi di un grafo relativo aldocumento RDF. Ad ogni proprietà deve inoltre essere assegnatouno schema. Questo può essere fatto aggiungendo ad ogni proprietà il namespace in cuiviene definito l’elemento che rappresenta la proprietà stessa. 20
  • 20. Capitolo 3 RDF-Resource Description FrameworkSi può pensare ad uno schema come ad un dizionario, che definisce i termini cheverranno adottati e vi associa un particolare significato.ES 3.3 La frase dell’ES 3.1: “Mario Rossi è l’autore della risorsa ̃ definita dall’URI http://www.myhost.org/ mrossi” può essere rappresentata in RDF/XML come : <?xml version="1.0"?> <rdf:RDF xmlns: rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns: s="http://schema.org/"> <rdf:Description rdf:about="http://www.myhost.com/~mrossi"> <s:Autore>Mario Rossi</s:Autore> </rdf:Description> </rdf:RDF> Fig 3.3 : Rappresentazione in RDF del ES 3.3Nei casi in cui sia preferibile usare una forma più compatta, si utilizzala forma abbreviata. Ne esistono tre forme, utilizzabili solo in particolari condizioni: 1.Si può utilizzare, nel caso in cui, non vi siano proprietà ripetute più volte entro l’elemento rdf:Description e i valori di tali proprietà siano dei letterali. In questo caso le proprietà possono essere scritte come attributi dell’elemento rdf:Description. ES 3.4 Il documento scritto nell’ES 3.3 diventa: <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:s="http://schema.org/"> <rdf:Description rdf:about="http://www.myhost.com/~mrossi" s:Autore="Mario Rossi"/> </rdf:RDF> Fig 3.4 : Rappresentazione prima forma abbreviata 21
  • 21. Capitolo 3 RDF-Resource Description Framework 2.Questa forma è applicabile quando l’oggetto di un’asserzione è un’altra risorsa, le cui proprietà sono definite nel documento stesso ed i cui valori sono dei letterali. In questo caso i predicati della risorsa referenziata diventano attributi del predicato che referenzia la risorsa stessa. ES 3.5 La frase: “La persona di codice 1375 si chiama Mario Rossi e ha email ̃ mrossi@myhost.org; la risorsa definita dall’URI http://www.myhost.org/ mrossi è stata creata da costui” può essere scritta come: <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:s="http://schema.org/"> <rdf:Description rdf:about="http://www.myhost.com/~mrossi"> <s:Autore rdf:resource="http://www.myhost.com/people/1375"/> </rdf:Description> <rdf:Description rdf:about="http://www.myhost.com/people/1375"> <s:Nome>Mario Rossi</s:Nome> <s:Email>mrossi@myhost.org</s:Email> </rdf:Description> </rdf:RDF> Fig 3.5 : Forma normale dell ES 3.5 Usando la seconda forma abbreviata, si ottiene: <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:s="http://schema.org/"> <rdf:Description rdf:about="http://www.myhost.com/~mrossi"> <s:Autore rdf:resource="http://www.myhost.com/people/1375" s:Nome="Mario Rossi" s:Email="mrossi@myhost.com"/> </rdf:Description> </rdf:RDF> Fig 3.6 : Forma abbreviata dell ES 3.5 3. Questa forma abbreviata si applica quando l’elemento rdf:Description contiene rdf:type. Questo elemento definisce il tipo della risorsa. In questo caso, il tipo viene usato direttamente come proprietà della risorsa. 22
  • 22. Capitolo 3 RDF-Resource Description Framework ES 3.6 Se si volesse rappresentare il fatto che la risorsa http://www.myhost.com/people/1375” è un oggetto di tipo “Persona”, la frase dell’ES 3.5 diventa: <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:s="http://schema.org/"> <rdf:Description rdf:about="http://www.myhost.com/~mrossi"> <s:Autore> <rdf:Description rdf:about="http://www.myhost.com/people/1375"> <rdf:type rdf:resource="http://schema.org/Persona"/> <s:Nome>Mario Rossi</s:Nome> <s:Email>mrossi@myhost.org</s:Email> </rdf:Description> </s:Autore> </rdf:Description> </rdf:RDF> Fig 3.7 : Forma normale dell ES 3.6 Usando la terza forma abbreviata si ottiene: <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:s="http://schema.org/"> <rdf:Description rdf:about="http://www.myhost.com/~mrossi"> <s:Autore> <s:Persona rdf:about="http://www.myhost.com/people/1375"> <s:Nome>Mario Rossi</s:Nome> <s:Email>mrossi@myhost.org</s:Email> </s:Persona> </s:Autore> </rdf:Description> </rdf:RDF> Fig 3.8 : Forma abbreviata dell ES 3.63.3 La Grammatica FormaleDi seguito, sono presentate e commentate le produzioni grammaticaliche definiscono il modello RDF [19]. E da notare, comunque, che la grammatica qui 23
  • 23. Capitolo 3 RDF-Resource Description Frameworkdefinita è in parte differente da quanto era stato formalizzato nelle prime specifiche dalW3C . 1. RDF ::= "<rdf:RDF>" description* "</rdf:RDF>" description 2. description ::= "<rdf:Description" idAboutAttr? bagIdAttr?propAttr* "/>" | "<rdf:Description" idAboutAttr? BagIdAttr? propAttr* ">" propertyElt"</rdf:Description>" | typedNode 3. idAboutAttr ::= idAttr | aboutAttr 4. idAttr ::= "rdf:ID=/"" IDsymbol "/"" 5. aboutAttr ::= "rdf:about=/"" URI-reference "/"" 6. bagIdAttr ::= "rdf:bagID=/"" IDsymbol "/"" 7. propAttr ::= typeAttr | propName "=/"" string "/"" 8. typeAttr ::= "rdf:type=/"" URI-reference "/"" 9. propertyElt ::= "<" propName idAttr? ">" value"</" propName ">" | "<" propName idAttr? parseLiteral ">"literal "</" propName ">" | "<" propName idAttr? parseResource ">"propertyElt* "</"propName ">" | "<" propName idRefAttr? BagIdAttr? PropAttr* "/>" 24
  • 24. Capitolo 3 RDF-Resource Description Framework 10. typedNode ::= "<" typeName idAboutAttr? BagIdAttr? propAttr* "/>" | "<" typeName idAboutAttr? bagIdAttr?propAttr* ">" propertyElt*"</" typeName ">" 11. propName ::= Qname 12. typeName ::= Qname 13. idRefAttr ::= idAttr | resourceAttr 14. value ::= description | string 15. resourceAttr ::= "rdf:resource=/"" URI-reference "/"" 16. Qname ::= NSprefix ":" name 17. URI-reference ::= string, interpreted per [BLFIM98] 18. IDsymbol ::= (any legal XML name symbol) 19. name ::= (any legal XML name symbol) 20. NSprefix ::= (any legal XML namespace prefix) 21. string ::= (any XML text, with "<", ">", and "" escaped) 22. parseLiteral ::= "rdf:parseType=/"Literal/"" 23. parseResource ::= "rdf:parseType=/"Resource/" 24. literal ::= (any well-formed XML)Ogni propertyElt e di un elemento rdf:Description corrisponde ad una tripla (p, r, v), incui (vedi produzione 9): • p è il risultato della concatenazione del namespace a cui appartiene e con il nome stesso di e; • r rappresenta : – una risorsa identificata dal valore dell’attributo rdf:about di rdf:Description (se presente); 25
  • 25. Capitolo 3 RDF-Resource Description Framework – una nuova risorsa, il cui identificatore è dato dal valore dell’attributo rdf:ID, se presente, oppure una nuova risorsa senza identificatore. • v rappresenta : – la risorsa, il cui identificatore è dato dal valore dell’attributo rdf:resource di e (se presente); – un letterale, nel caso in cui sia presente l’attributo rdf:parseType con valore Literal o il contenuto di e sia del testo XML; – una risorsa, qualora sia presente l’attributo rdf:parseType con valore Resource; – la risorsa, il cui identificatore è ottenuto dal valore dell’attributo (anche implicito) rdf:about o rdf:ID dell’elemento rdf:Description contenuto in e.Quando in un elemento rdf:Description è specificato l’attributo rdf:about, l’asserzionesi riferisce alla risorsa identificata dal valore dell’attributo. Se invece, è presente rdf:IDo rdf:bagID, la tripla stessa rappresenta una risorsa. LURI della risorsa è dato dallaconcatenazione dell’URI del documento, allinterno del quale, è definita la tripla con ilvalore dell’attributo stesso.3.4 RDF SchemaFino ad ora, è stato presentato il modello di RDF come un mezzo per rappresentaremeta-dati e una sintassi RDF/XML come trasporto di tale modello. In questo modo, si èreso possibile associare delle coppie nome-valore delle risorse o URI. Ma spesso questonon basta.Ad esempio, nel caso in cui, si ha una proprietà che fa riferimento ad uno scrittore,sarebbe semanticamente scorretto associarla ad una macchina o a un’abitazione. Oppurese si ha una proprietà che rappresenta un compleanno, è importante vincolarne i valori adelle date (e non numeri generici o caratteri). Il modello di RDF non permette dieffettuare validazione di un valore o restrizione di un dominio di applicazione di unaproprietà. 26
  • 26. Capitolo 3 RDF-Resource Description FrameworkQuesto compito è svolto, invece, da RDF Schema [18]. Però, a differenza di XMLSchema o di una DTD, RDF Schema non vincola la struttura del documento, bensìfornisce informazioni utili all’interpretazione del documento stesso. In seguito, ilnamespace di RDF Schema sarà indicato con rdfs; quello di RDF semplicemente conrdf.3.4.1 Classi e ProprietàIn questo paragrafo, si indicano le classi principali e le proprietà che fannoparte del vocabolario definito da RDF Schema. Le classi permettono di definire i tipibase di ogni risorsa che verrà descritta in RDF; le proprietà sono lo strumento utilizzatoper esprimere le relazioni fra esse.rdfs:Resource Tutto ciò che viene descritto in RDF è detto risorsa. Ogni risorsa è istanza della classe rdfs:Resource.rdfs:Literal Sottoclasse di rdfs:Resource, rappresenta un letterale, una stringa di testo.rdf:Property Rappresenta le proprietà, così come sono state definite nella sottoclasse di rdfs:Resource.rdfs:Class Corrisponde al concetto di tipo e di classe della programmazione object- oriented. Quando viene definita una nuova classe, la risorsa che la rappresenta deve avere la proprietà rdf:type impostata a rdfs:Class.rdf:type Indica che una risorsa è membro di una classe, è ciò istanza di una specifica classe. Il valore di rdf:type deve essere una risorsa che è istanza di rdfs:Class (o sua sottoclasse). In pratica permette di specificare il tipo di una risorsa.rdfs:subClassOf Specifica la relazione di ereditarietà fra classi. Questa proprietà può essere assegnata solo a istanze di rdfs:Class. Una classe può essere sottoclasse di una o più classi (ereditarietà multipla). 27
  • 27. Capitolo 3 RDF-Resource Description Frameworkrdfs:subPropertyOf Istanza di rdf:Property, si utilizza per specificare che una proprietà è una specializzazione di un’altra. Ogni proprietà può essere la specializzazione di zero o più proprietà.rdfs:seeAlso Specifica una risorsa che fornisce ulteriori informazioni sul soggetto dell’asserzione. Ciò che rappresenta questa risorsa comunque, non può essere specificato ed è a carico dell’applicazione specificare la sua interpretazione.rdfs:isDefinedBy E sottoproprietà di rdfs:seeAlso e indica una risorsa che definisce il soggetto di un’asserzione. L’uso più comune di questa proprietà è di fornire un URI che identifichi lo schema in cui è stato definito il soggetto.rdfs:Container Rappresenta la classe base da cui sono derivati i contenitori di RDF.rdfs:ContainerMembershipPropriety E la classe da cui derivano i membri rdf: 1, rdf: 2, etc. dei contenitori.ES 3.7 In questo esempio le due scritture sono equivalenti : la prima non usa RDF schema; la seconda invece, lo adotta per la creazione di una classe chiamata nuovoTipo. <rdf:Description rdf:about="http://schema.org/nuovoTipo"> <rdf:type rdf:resource="http://www.w3.org/2000/01/rdf-schema#Class" /> </rdf:Description> <rdfs:Class rdf:about="http://schema.org/nuovoTipo"/> Fig 3.9 :Equivalenza scrittura tra RDF e RDF schema 28
  • 28. Capitolo 3 RDF-Resource Description FrameworkES 3.8 Definiamo ora la classe Persona, la sua sottoclasse Operaio e la classe Lavoratore, che è sottoclasse di Operaio. Infine istanziamo la classe Lavoratore. <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"> <rdfs:Class rdf:about="http://schema.org/Persona" /> <rdfs:Class rdf:ID="Operaio"> <rdfs:subClassOf rdf:resource="http://schema.org/Persona" /> </rdfs:Class> <rdfs:Class rdf:ID="Lavoratore"> <rdfs:subClassOf rdf:resource="#Operaio" /> </rdfs:Class> <rdf:Description rdf:about="http://lavoratori.org/mrossi"> <rdf:type rdf:resource="#Lavoratore"/> </rdf:Description> </rdf:RDF> Fig 3.10 : RDF schema dell ES 3.83.4.2 I VincoliLe specifiche di RDF Schema definiscono un vocabolario che permette di effettuaredelle asserzioni vincolando le proprietà e le risorse che costituiscono l’associazione.rdfs:ConstraintResource Sottoclasse di rdfs:Resource, le sue istanze rappresentano costrutti di RDF Schema utilizzati per esprimere vincoli. Lo scopo di questa classe è fornire un mezzo ai parser RDF per riconoscere i costrutti che rappresentano vincoli. Non è però possibile indicare al parser come utilizzare i vincoli così identificati.rdfs:ConstraintProperty Sottoclasse di rdf:Property e rdf:Constraint-Resource, le sue istanze sono proprietà usate per specificare dei vincoli. Sia rdfs:domain che rdfs:range sono sue istanze. 29
  • 29. Capitolo 3 RDF-Resource Description Frameworkrdfs:range Usato come predicato di una risorsa r, indica le classi di cui devono essere membre le risorse a cui verrà applicata r.rdfs:domain Usato come predicato di una risorsa r, indica le classi valide che saranno soggetto di un’asserzione che ha come predicato r.ES 3.8 Riprendendo l’ES 3.7, definiamo delle proprietà,vincolandole ai tipi descritti in precedenza. Quando re-istanziamo un oggetto di tipo Lavoratore, possiamo comunque applicarvi i predicati definiti per le superclassi da cui discende. <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#" xmlns:s="http://schema.org/"> <rdf:Property rdf:about="http://schema.org/Nome"> <rdfs:domain rdf:resource="http://schema.org/Persona"/> <rdfs:range rdf:resource="http://www.w3.org/2000/01/rdf-schema#Literal"/> </rdf:Property> <rdf:Property rdf:about="http://schema.org/DataNascita"> <rdfs:domain rdf:resource="http://schema.org/Persona"/> <rdfs:range rdf:resource="http://www.w3.org/2000/01/rdf-schema#Literal"/> </rdf:Property> <rdf:Property rdf:ID="Membro"> <rdfs:domain rdf:resource="#Lavoratore"/> <rdfs:range rdf:resource="#Meccanico"/> </rdf:Property> <rdf:Class rdf:about="http://schema.org/Meccanico"/> <rdf:Description rdf:about="http://lavoratori.org/meccanici#labour"> <rdf:type rdf:resource="http://schema.org/Meccanico"/> </rdf:Description> <rdf:Description rdf:about="http://Lavoratori.org/mrossi"> <rdf:type rdf:resource="#Lavoratore"/> <s:Nome>Mario Rossi</s:Nome> <s:DataNascita>08 Ottobre, 1968</s:DataNascita> <epx:Membro rdf:resource="http://www.iLavoratori.com/meccanici#labour"/> </rdf:Description> </rdf:RDF> Fig 3.11 : RDF schema del ES 3.8 30
  • 30. Capitolo 4 Joseki-Il server RDF di Jena CAPITOLO 4 Joseki – Il server RDF di JENAIn questo capitolo, si descriveranno i servizi offerti da Jena, in particolare il serverJoseki, che con lausilio del linguaggio SPARQL permette di interrogare le risorsedescritte in RDF. Si procederà poi, ad un semplice utilizzo di Joseki.4.1.JosekiJoseki è un HTTP / SOAP engine che permette linvio di query SPARQL via HTTP [4].Nella Fig 4.1 viene schematizzato il funzionamento di Joseki. Fig 4.1: JosekiPartendo da una risorsa descritta da un file RDF , Joseki riesce ad interrogarla mediantelinvio di query SPARQL . Nel file di configurazione iniziale di Joseki (.ttl) vengonodescritte tutte le risorse su cui far riferimento.Tutte le query vengono inviate via HTTP, attraverso un form presente sulla paginainiziale del server alla porta 2020. Inoltre, prima della fase di elaborazione della query,è possibile scegliere in che formato ricevere le informazioni richieste al server. Adesempio, possiamo scegliere di riceverle in formato XML, CSV ( Comma-SeparatedValues ), TSV ( Tabs-Separated Values ) o semplicemente in TXT. 31
  • 31. Capitolo 4 Joseki-Il server RDF di JenaNella Fig 4.2 viene mostrato lo stack di Joseki e di come, mediante l ausilio di Jena,attraverso il protocollo HTTP, riesca ad interagire anche con risorse di tipo differente. Fig 4.2: Stack di Joseki4.2.JenaJena è un framework Java open source (sviluppato dal Semantic Web Research BristolLab della HP) [2] per lo sviluppo di applicazioni orientate al Web Semantico. Essofornisce le API per la creazione, interrogazione e gestione in modo programmatico diRDF.Inoltre Jena, oltre alla parte di programmazione, ci offre diversi tools per gestire ,interrogare , modificare , e convertire direttamente una risorsa.Possiamo ad esempio, convertire le nostre risorse in diversi formati : XML , RDF , N3 ;e interrogarle mediante il linguaggio SPARQL. 32
  • 32. Capitolo 4 Joseki-Il server RDF di JenaES 4.1 Supponiamo di voler creare una risorsa RDF, rappresentata nella Fig 4.3 : Risorsa http://...../Marco_Rossi Proprietà VCard:FN Marco Rossi Attributo Fig 4.3 : Rappresentazione del modello dell ES 4.1Ogni arco di un modello RDF viene chiamato Statement, e può essere diviso in 3 parti :il soggetto , il predicato e loggetto. Ogni statement può anche essere chiamato tripla.Si crea un modello (classe Model) mediante il metodo factoryModelFactory.createDefaultModel() e si aggiungono le varie risorse e le proprietà. Inquesto caso, FN , utilizzando il dizionario VCARD (la definizione di VCARD si trovanel Appendice B ). // creo un model Model Esempio_4_1 = ModelFactory.createDefaultModel(); // creo le risorse aggiungendole in cascata Resource marcoRossi = Esempio_4_1.createResource("http://..../MarcoRossi") .addProperty(VCARD.FN, " Marco Rossi "); Fig 4.4 : Creazione del modello e delle risorse dell ES 4.1VCARD è un dizionario che ci permette di rappresentare tutte le proprietà cheesprimono le generalità di un individuo.È possibile ottenere la lista degli statement contenuti nel Model mediante loggetto diclasse StmtIterator : // Richiedo al modello la lista degli statement contenuti StmtIterator iter = Esempio_4_1.listStatements(); Fig 4.5 : Richiesta degli Statements del modello 33
  • 33. Capitolo 4 Joseki-Il server RDF di Jenae ottenere puntualmente il soggetto, il predicato e loggetto dello statement: Resource subject = stmt.getSubject(); // richiedo il subject Property predicate = stmt.getPredicate(); // richiedo il predicate RDFNode object= stmt.getObject(); // richiedo lobject Fig 4.6 : Richiesta del s p o di uno stamentPer trascrivere il contenuto del model RDF nei vari formati di serializzazione consentitiè possibile utilizzare il metodo write() della classe Model, specificando loutput streamsu cui scrivere con il relativo formato (XML, N-TRIPLE o N3): model.write(fileOutputStream);// Di default XML ! model.write(fileOutputStream, "N-TRIPLE"); model.write(fileOutputStream, "N3"); Fig 4.7 : Scrittura del contenuto del modelloAnalogamente, per leggere un documento RDF, si può utilizzare il metodo read() dellaclasse Model: InputStream in = new FileInputStream(<< nome del file >>); model.read(in, "", "N3"); Fig 4.8 : Lettura di un modello4.2.1 I tools di JenaOltre alle librerie in grado di manipolare una risorsa in RDF, Jena ci offre diversi toolsper operare direttamente sulle risorse . Questi tools vengono lanciati su riga di comandoe sono ad azione immediata.rdfcat : Ci permette di concatenare il contenuto di uno o più documenti RDF. Inoltre, utilizzando le diverse opzioni disponibili , possiamo convertire la nostra risorsa RDF in vari formati dallXML a N3.rdfcopy : Copia un modello. E nostra facoltà scegliere inoltre, in quale sintassi ottenere il risultato della copia ( N3 , XML, RDF , RDF-ABBREV ) 34
  • 34. Capitolo 4 Joseki-Il server RDF di Jenardfcompare : Controlla se due modelli sono isomorfi , ovvero se il primo può essere mappato nellaltro.sparql : Esegue una query direttamente sul modello. Il risultato verrà stampato sul terminale.4.3.Introduzione a SPARQLSPARQL ( SPARQL Protocol and RDF Query Language) è linguaggio di interrogazionedi una risorsa RDF ed è asceso al rango di W3C Candidate Recommendation [1], comeultimo tassello per ledificazione del Web Semantico.Questo linguaggio adotta la sintassi Turtle [5], unestensione di N3 ( N-Triples ) [21],estremamente sintetica e intuitiva al tradizionale RDF/XML.Possiamo convertire direttamente una risorsa RDF/XML in una estensione N3 grazieallausilio delle API di Jena.In Fig 4.9 vi è un esempio pratico di alcune triple RDF espresse in turtle, che verrannoutilizzate come riferimento per gli esempi successivi. @prefix book:<http://esempio.org/book/> @prefix :<http://esempio.org/esempio/> :Alpha book:autore "Mario Rossi". :Beta book:autore "Mario Rossi". :Gamma book:autore "Gino Bianchi". :Gamma book:anno 1994. Fig 4.9 : Rappresentazione di alcune triple@prefix introduce prefissi e namespace; i due punti senza prefisso (seconda riga)definiscono il namespace di default.Le asserzioni sono espresse in concise sequenze soggetto-predicato-oggetto e delimitateda un punto fermo. Gli URI sono inclusi tra parentesi uncinate e i letterali di tipo stringasono contrassegnati da virgolette. 35
  • 35. Capitolo 4 Joseki-Il server RDF di Jena4.3.1 Il Pattern MatchingLe query SPARQL si basano sul meccanismo del "pattern matching" [22] e inparticolare su un costrutto, il "triple pattern", che ricalca la configurazione a triple delleasserzioni RDF, fornendo così, un modello flessibile per la ricerca di corrispondenze. ?titolo book:autore ?autore. Fig 4.10 : pattern-matchingIn luogo del soggetto e delloggetto questo "triple pattern" prevede due variabili,contrassegnate con ?.Le variabili fungono, in un certo senso, da incognite dellinterrogazione; book:autorefunge invece da costante. Le triple RDF ,che trovano riscontro nel modello, assocerannoi propri termini alle variabili corrispondenti.In Fig 4.11 viene mostrata una semplice query per chiarire meglio il funzionamento dellinguaggio PREFIX book: <http://example.org/book/> SELECT ?titolo ?autore ?anno FROM <http://book.com/listaLibri.ttl> WHERE { ?titolo book:autore ?autore. ?titolo book:anno ?anno . } Fig 4.11 : Semplice queryAnalizzando lesempio soprastante, possiamo vedere che : PREFIX dichiara prefissi enamespace. SELECT definisce le variabili di ricerca da prendere in considerazione nelrisultato (nellesempio: titolo, autore e anno). FROM specifica il set di dati su cui dovràoperare la query (si suppone che le triple siano immagazzinate presso lindirizzo“http://book.com/listaLibri.ttl” ). Infine WHERE ,che definisce il criterio di selezionespecificando tra parentesi graffe uno o più "triple patterns" separati da punto fermo.Applicando la query della Fig 4.11 al set di triple mostrate in Fig 4.9 , si ottiene ilseguente risultato: 36
  • 36. Capitolo 4 Joseki-Il server RDF di Jena titolo autore anno Gamma Gino Bianchi 1994 Tab 4.1 : Risultato della query in Fig 4.11Il "binding" tra variabili e termini reperiti corrispondenti (in questo caso, un termine perciascuna variabile) è reso in forma di tabella, come un rapporto campo-valore: le righerappresentano i singoli risultati, le intestazioni di cella rappresentano le variabili definitenella clausola SELECT e le celle, i termini associati alle variabili.La query precedente ha catturato esclusivamente le triple dotate di tutti e tre i terminirichiesti (titolo, autore, anno), escludendo le triple che ne possedevano due soltanto(titolo, autore). È possibile riformulare la query in modo più elastico, prevedendoleventuale assenza di alcuni termini. Possiamo farlo grazie al comando OPTIONALcome si vede in Fig 4.12. PREFIX book: <http://example.org/book/> SELECT ?titolo ?autore ?anno FROM <http://book.com/listaLibri.ttl> WHERE { ?titolo book:autore ?autore. OPTIONAL {?titolo book:anno ?anno} } Fig 4.12 : uso del comando OPTIONALCome mostrato, il secondo pattern è dichiarato opzionale, infatti linformazione èaggiunta al risultato solo se disponibile, altrimenti le variabili compariranno prive divalore (unbound). Il risultato della query mostrata in Fig 4.12 sarà : titolo autore anno Alpha Mario Rossi Beta Mario Rossi Gamma Gino Bianchi 1991 Tab 4.2 : Risultato query della Fig 4.12 37
  • 37. Capitolo 4 Joseki-Il server RDF di JenaLe risorse sprovviste della proprietà ?anno sono mostrate ugualmente e le celle deivalori mancanti sono lasciate vuote.Un altro modo per avere una certa elasticità nel recuperare le informazioni presenti nellerisorse, è quello di combinare i diversi operatori logici, che ci vengono messi adisposizione dal linguaggio SPARQL, come viene fatto nella Fig 4.13. In questa querysi produce lo stesso risultato riportato nella Tab 4.2, ma viene usata la parola chiaveUNION, che ci permette di esprimere un OR logico , che cattura le triple che soddisfanola prima e la seconda triple patterns. PREFIX book: <http://example.org/book/> SELECT ?titolo ?autore ?anno FROM <http://book.com/listaLibri.ttl> WHERE { ?titolo book:autore ?autore. UNION {?titolo cd:anno ?anno} } Fig 4.13 : Uso di UNION 38
  • 38. Capitolo 4 Joseki-Il server RDF di Jena4.3.2 Restrizione sui valoriGrazie ad alcuni operatori applicabili sulle variabili, è possibile restringere il campodelle nostre ricerche ed effettuare delle query sempre più specifiche.Di seguito, è descritta la mappatura degli operatori supportati dal linguaggio SPARQL : A=B A != B A<B A e B possono essere di tipo : numerico , stringa A>B , data e booleano A <= B A >= B A*B A/B A e B possono essere di tipo numerico A+B A-B Tab 4.3: Operatori SPARQLNella Fig 4.14 viene mostrato un esempio di triple patterns con una restrizione suivalori. PREFIX book: <http://example.org/book/> SELECT ?titolo ?autore ?anno FROM <http://book.com/listaLibri.ttl> WHERE { ?titolo book:autore ?autore. FILTER (?anno > 2000). } Fig 4.14 : Query con restrizione su un valoreIn questo caso, la restrizione è effettuata mediante loperatore di confronto >( maggiore ), il filtro esclude i termini che non soddisfano la condizione definita tra le 39
  • 39. Capitolo 4 Joseki-Il server RDF di Jenaparentesi tonde. Il risultato, in questo caso, è nullo ( il data-set di riferimento nonprevede valori maggiori di 2000 per la proprietà anno ).4.3.3 Manipolazione del risultatoMediante SPARQL, possiamo gestire a nostro piacimento il risultato delle nostre query.Ad esempio, come in Fig 4.15, con loperatore DISTINCT è possibile escludere dalrisultato i valori duplicati. SELECT DISTINCT ?titolo ?autore 4.15 : Operatore DistinctAltri costrutti supportati da SPARQL per la manipolazione del risultato sono ORDERBY , LIMIT e OFFSET.Nella Fig 4.16 viene mostrato luso degli altri operatori per la manipolazione delrisultato delle nostre query. ORDER BY DESC(?autore) LIMIT 10 OFFSET 10 Fig 4.16 : Altri operatori per la manipolazioneFacendo riferimento allesempio, lespressione ORDER BY imposta lordine dei risultatidella query . I risultati sono presentati in ordine decrescente (DESC) in base allavariabile ?autore. LIMIT pone restrizioni al numero dei risultati, limitandoli, ai soliprimi 10. OFFSET permette di "saltare" un certo numero di risultati, escludendo, i primi10.4.4. Esempio di utilizzoAppena Joseki viene lanciato di default, permette di eseguire query via browsersullelenco dei dati contenuto nel file desempio books.n3 (un elenco dei libri).Lanciando il browser e collegandosi allURL http://localhost:2020/ si visualizza unapagina Web con una Text Box, nella quale è possibile digitare la query SPARQL che si 40
  • 40. Capitolo 4 Joseki-Il server RDF di Jenavuole eseguire. Ad esempio, inserendo nella Text Box la seguente query SPARQL, sirichiedono tutti i libri che hanno un titolo, e il relativo risultato è presentato in unapagina HTML. In Fig 4.17 viene mostrata la query di prova che ci appresteremo adeseguire : PREFIX books:<http://example.org/book/> PREFIX dc:<http://purl.org/dc/elements/1.1/> SELECT ?book ?title WHERE { ?book dc:title ?title } Fig 4.17 : Query per un primo utilizzo di JosekiJoseki provvederà ad interrogare il file books.n3, che si presenterà come in Fig 4.18, e ilrisultato della query viene visualizzato tramite una pagina web. Infatti, il client effettuauna GET passando come parametro la query inserita nella Text Box e la relativarisposta HTTP di Joseki, che contiene il risultato della query opportunamente formattatoin HTML. @prefix dc:<http://purl.org/dc/elements/1.1/> . @prefix vcard:<http://www.w3.org/2001/vcard-rdf/3.0#> . @prefix ns:<http://example.org/ns#> . @prefix :<http://example.org/book/> . :book1 dc:title "Harry Potter and the Philosophers Stone" ; dc:creator "J.K. Rowling" ;. :book2 dc:title "Harry Potter and the Chamber of Secrets" ; dc:creator _:a . #(…..segue la dichiarazione dei libri....) _:a vcard:FN "J.K. Rowling" ; vcard:N [ vcard:Family "Rowling" ; vcard:Given "Joanna" ] Fig 4.18 : Frammento del file books.n3 41
  • 41. Capitolo 4 Joseki-Il server RDF di JenaIl risultato della query mostrata in Fig 4.17 sarà: books title <http://example.org/book/book7> "Harry Potter and the Deathly Hallows" <http://example.org/book/book2> "Harry Potter and the Chamber of Secrets" <http://example.org/book/book4> "Harry Potter and the Goblet of Fire" <http://example.org/book/book6> "Harry Potter and the Half-Blood Prince" <http://example.org/book/book1> "Harry Potter and the Philosophers Stone" <http://example.org/book/book3> "Harry Potter and the Prisoner Of Azkaban" <http://example.org/book/book5> "Harry Potter and the Order of the Phoenix" Tab 4.4: Risultato Query 42
  • 42. Capitolo 5 Procedure di installazione del Software CAPITOLO 5 Procedure di installazione del softwareIn questo capitolo descriviamo le procedure di installazione del software utilizzato, siasu una macchina locale e sia su una macchina remota, in questo caso un serverdelluniversità raggiungibile allindirizzo 151.100.106.21 sulla porta 2020.5.1. Installazione di Joseki in localeInnanzi tutto bisogna connettersi al sito http://www.joseki.org/, oltre a tutta ladocumentazione necessaria per il funzionamento, sotto la voce download troveremodiverse release del server, scarichiamo la più recente, nel nostro caso Joseki-3.4.1 .Apriamo il terminale e procediamo con la de-compattazione del pacchetto, utilizzando ilcomando : unzip Joseki-3.4.1.zip Fig 5.1 : Uso comando unzipSempre attraverso il terminale, dobbiamo dare i permessi di esecuzione, lettura escrittura a tutti i file presenti nella cartella /bin della nostra distribuzione con ilcomando: chmod u+x bin/* Fig 5.2 : Uso comando chmodLasterisco include tutti i file presenti nella cartella bin.Infine bisogna settare la variabile dambiente , JOSEKIROOT dove è stata installata ladistribuzione del server , per fare ciò si usa il comando : export JOSEKIROOT= < path dell instalazione di Joseki > Fig 5.3 : Settaggio variabile dambiente 43
  • 43. Capitolo 5 Procedure di installazione del SoftwareAdesso il nostro server è pronto per lesecuzione, basta lanciare il file rdfserver presentenella cartella /bin .Di default se si lancia Joseki senza specificare un file di configurazione, il serverprenderà come riferimento il file joseki-config.ttl .Il file di configurazione viene utilizzato per specificare a quale risorsa di dati si vuolefar riferimento, perché è possibile interfacciare Joseki anche con database e risorse ditipo differenti. sh bin/rdfserver < file di configurazione > Fig 5.4 : Avvio di josekiUna volta lanciato il server, Joseki si attiverà utilizzando il protocollo HTTP sulla porta2020, aprendo un qualsiasi browser, andare su http://localhost:2020, per interrogare lenostre risorse .5.1.1 Configurazione di JosekiIl server Joseki viene configurato attraverso dei servizi, e ogni servizio vieneimplementato grazie ad un processore, che esegue le query in modo fisso su data-setpredefiniti, o altrimenti riesce ad assemblare il data-set in modo dinamico a secondadella query. Quando si pubblicano dati già esistenti, è più opportuno utilizzare unprocessore che non consente un data-set da specificare nella query.Il file di configurazione di Joseki non è altro che un grafo RDF, e questo di defaultprende il nome di joseki-config.ttl ed è scritto solitamente in N3 invece di RDF|XML .Grazie a questa configurazione il server può leggere un ampia gamma di serializzazioneRDF.Innanzitutto, bisogna dichiarare alcuni prefissi, questi sono la base delle informazionidel nostro file (come in Fig 5.5), dato che il file di configurazione è in RDF, lordinedelle sezioni non incide sul server, ma aiuta lutente a leggere il file .Quindi, allinterno di un file è possibile inserire più sezioni che riguardando risorse eservizi differenti. 44
  • 44. Capitolo 5 Procedure di installazione del Software @prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> . @prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> . @prefix module: <http://joseki.org/2003/06/module#> . @prefix joseki: <http://joseki.org/2005/06/configuration#> . @prefix ja: <http://jena.hpl.hp.com/2005/11/Assembler#> . ## Nota:aggiungendo rdfs:label ai nodi , Joseki ## stamperà ogni messaggio di log. ## -------------------------------------------------------------- ## Approposito di questa configurazione <> rdfs:comment "Esempio di una configurazione di Joseki" . ## -------------------------------------------------------------- ## Approposito di questo server [] rdf:type joseki:Server ; . Fig 5.5 : Dichiarazione dei prefissi della configurazione di JosekiUna volta dichiarati i prefissi si passa alla descrizione dei servizi, il servizio base offertoda Joseki è linterpretazione del linguaggio SPARQL.In Fig 5.6 si vede come aggiungere il servizio di base : # Servizio 1 - Nuova sezione - # Uso generale di un processore SPARQL , nessun data-set, # bisogna specificare il data-set o nella query o nei parametri del # protocollo di richiesta . [] rdf:type joseki:Service ; rdfs:label "nome servizio" ; joseki:serviceRef "sparql" ; joseki:processor joseki:ProcessorSPARQL ; . Fig 5.6 : Sezione del servizio di baseSe si ha la necessità di interrogare un data-set fisso, Joseki ci permette di farloaggiungendo lopportuno servizio (come si vede in Fig 5.7) 45
  • 45. Capitolo 5 Procedure di installazione del Software # Servizio 2 – processore SPARQL solo #.per un determinato data-set rdf:type joseki:Service ; rdfs:label "SPARQL on the books model" ; joseki:serviceRef "books" ; # parti del data-set joseki:dataset _:books ; # Parti del servizio. # Questo processore non consente né il protocollo, # nemmeno la query per specificare i data-set. joseki:processor joseki:ProcessorSPARQL_FixedDS ; . Fig 5.7 : Selezione del data-setPasseremo ora alla sezione riguardante la dichiarazione del data-set . Un data-set puòessere definito mediante un Jena Assembler Description, ovvero un assemblatore per lacreazione di modelli. Ogni data-set di dati RDF è una raccolta di più grafici che possonoavere un nome o meno, a sua volta ogni grafico, può essere visto come un modello diJena, questi vengono definiti attraverso uno Jena Assembler vocabulary.Si faranno alcuni esempi sulle sezioni del file di configurazione di Joseki che settano idata-set, i tipi di modelli e il processore.Questo primo data-set, mostrato in Fig 5.8, ha un solo grafico di default. Il contenutodel data-set viene caricato da un file ( se ne possono caricare più di uno ), ma il nomedel file non conferisce il nome al modello. 46
  • 46. Capitolo 5 Procedure di installazione del Software # Dataset con un modello da file _:books rdf:type ja:RDFDataset ; rdfs:label "Books" ; ja:defaultGraph [ a ja:MemoryModel ; rdfs:label "books.n3" ; ja:content [ ja:externalContent <file:Data/books.n3> ] ]; . Fig 5.8 : Data-set di un modello da fileUn esempio più complesso è mostrato in Fig 5.9, dove vengono presi due grafici dafonti differenti, e le fonti conferiranno anche il nome al modello. _:dataset1 rdf:type ja:RDFDataset ; ja:defaultGraph _:model0 ; rdfs:label "Dataset _:dataset1" ; a:namedGraph [ ja:graphName <http://example.org/name1> ; ja:graph _:model1 ] ; ja:namedGraph [ ja:graphName <http://example.org/name2> ; ja:graph _:model2 ] ; . Fig 5.9 : Data-set costruito su più graficiVedremo ora come definire la sezione riguardante la dichiarazione dei modelli questoavviene attraverso lo Jena Assembler vocabulary ,in Fig 5.10 si suppone di averediversi modelli su cui far riferimento. 47
  • 47. Capitolo 5 Procedure di installazione del Software ## Grafico individuale ( Jena chiama questi modelli ) ## (la sintassi dei file dei dati è data da un file di estensioni in RDF/XML) _:model0 rdf:type ja:MemoryModel ; rdfs:label "Model fonde i 2 file RDF )" ; ja:content [ ja:externalContent <file:D1.ttl> ; ja:externalContent <file:D2.ttl> ; ] ;. _:model1 rdf:type ja:MemoryModel ; rdfs:label "Model (contenuto D1.ttl )" ; ja:content [ ja:externalContent <file:D1.ttl> ; ] ;. _:model2 rdf:type ja:MemoryModel ; rdfs:label "Model (contenuto D2.ttl )" ; ja:content [ ja:externalContent <file:D2.ttl> ;]. Fig 5.10 : Dichiarazione di più modelliSe si ha la necessità, di interrogare un modello memorizzato su un qualsiasi database, siprocederà come si vede in Fig 5.11 _:db rdf:type ja:RDBModel ; ja:connection [ ja:dbType "MySQL" ; ja:dbURL "jdbc:mysql://localhost/data" ; ja:dbUser "user" ; ja:dbPassword "password" ; ja:dbClass "com.mysql.jdbc.Driver" ; ]; ja:modelName "books" . Fig 5.11 : Accesso ad un modello su Database 48
  • 48. Capitolo 5 Procedure di installazione del SoftwareInfine, vedremo la sezione riguardante il processore, ogni descrizione del processorepuò avere parametri che vengono passati ad ogni istanza di classe al momento dellacreazione.In Fig 5.12 viene mostrata la dichiarazione di un processore standard SPARQL, cheaccetta query attraverso i parametri FROM | FROM NAME, e i dati vengono caricati divolta in volta . Mentre in Fig 5.13 viene dichiarato un processore con con data-set fissoche non accetta query attraverso i parametri FROM | FROM NAME joseki:ProcessorSPARQL rdf:type joseki:Processor ; rdfs:label "Processore Generale SPARQL" ; module:implementation joseki:ImplSPARQL ; # Parametri : accetta query con FROM/FROM NAMED joseki:allowExplicitDataset "true"^^xsd:boolean ; joseki:allowWebLoading "true"^^xsd:boolean ; ## Non cè una politica di chiusura ## (i dati vengono caricati di volta in volta). joseki:lockingPolicy joseki:lockingPolicyNone ; . Fig 5.12 : Dichiarazione di un processore standard joseki:ProcessorSPARQL_FixedDS rdf:type joseki:Processor ; rdfs:label "Processore SPARQL con data-set fisso" ; module:implementation joseki:ImplSPARQL ; # This processor does not accept queries with FROM/FROM NAMED joseki:allowExplicitDataset "false"^^xsd:boolean ; joseki:allowWebLoading "false"^^xsd:boolean ; # Fixed background dataset : multiple read requests are OK joseki:lockingPolicy joseki:lockingPolicyMRSW ; . Fig 5.13 : Dichiarazione di un processore con data-set fisso 49
  • 49. Capitolo 5 Procedure di installazione del Software5.2 Installazione di Joseki in remotoPer una simulazione, che si avvicini sempre più alla realtà, abbiamo installato il serverJoseki su una macchina remota, un server delluniversità. Le procedure di installazione, icomandi da utilizzare per lavvio di Joseki sono gli stessi del paragrafo 5.1, lunicadifferenza sta nella connessione al server remoto .Per connetterci al server remoto apriamo la shell e digitiamo il comando : Scp <sorgente file> -r palma@151.100.106.21 :~ Fig 5.14 : Uso comando scpscp, sta per secure-copy, ed è uno dei programmi utilizzati per scambiare file tra gli hostdi una rete, in questo caso la mia macchina ed il server.In <sorgente file> viene inserito il path dove si trova Joseki, e -r specifica che dovràessere copiato tutto il contenuto della cartella selezionata. Subito dopo viene selezionatol user, il server di riferimento e dove mandare i file, :~ ,indica la directory di base.Naturalmente, per effettuare questa operazione il programma richiede un autenticazioneal server.Una volta terminata loperazione di copia, possiamo connetterci al server remoto tramiteil comando : ssh -l palma 151.100.106.21 Fig 5.15 : Uso comando sshssh è un programma per loggarsi su una macchina remota ed eseguire comandidirettamente su questa, con -l si specifica il nome dellutente che si connette, e poi vieneinserito lindirizzo fisico della macchina.Possiamo riprendere ora tutti i comandi del paragrafo 5.1 e digitarli direttamente sulserver .Per vedere il funzionamento di Joseki, si deve aprire un qualsiasi browser e inserirecome URL : 50
  • 50. Capitolo 5 Procedure di installazione del Software URL: 151.100.106.21 : 2020 Fig 5.16 : Url di riferimento del serverI comandi descritti, non ci garantiscono il continuo funzionamento di Joseki, infatti unavolta chiusa la sessione o il terminale, il processo relativo a Joseki viene troncato dalserver e di conseguenza Joseki cesserà di funzionare.Per far si, che ciò non avvenga, si possono utilizzare due tecniche distinte, la prima siriferisce ad un avvio manuale del servizio utilizzabile in fase di sviluppo/testdellapplicazione, la seconda utilizzabile per lavvio del servizio in automatico, una voltache lapplicazione è terminata e pronta per essere utilizzata.Per avviare manualmente Joseki si effettua un accesso tramite il protocollo ssh al serverove risiede lapplicazione e tramite il comando in Fig 5.17, si manda in esecuzione ilservizio. nohup sh /bin/rdfserver & Fig 5.17 :Uso del comando nohupPrima di lanciare il comando descritto in Fig 5.17 bisogna spostarsi allinterno dellacartella root di Joseki attraverso il comando cd.Il comando in Fig 5.17 in realtà è composto da tre istruzioni distinte: • nohup: che ha la funzione di staccare il processo dal genitore, in quanto lavorando in ssh se non si effettua un detach del processo figlio, alla chiusura della connessione ssh, che può avvenire intenzionalmente o accidentalmente, il processo verrebbe terminato dato che viene terminato il processo padre, cioè la bash creata dalla connessione ssh; • sh ./bin/rdfserver: lancio dello script utilizzato per lavvio di joseki; • &: esegue il comando per lavvio del processo in background, cioè consente di rilasciare lutilizzo della shell una volta avviato il processo senza aspettare la terminazione di questultimo e quindi permettere di chiudere la sessione ssh o di svolgere altre attività. 51
  • 51. Capitolo 5 Procedure di installazione del SoftwareCon la seconda tecnica, Joseki viene eseguito in automatico dal server e il suofunzionamento viene garantito in qualsiasi circostanza. Questa, consiste nel modificareil file rc.local ( mostrato in Fig 5.19 ) posizionato allinterno della directory /etc/rc.d/ inslackware 12.1, il quale è uno script che viene eseguito automaticamente dal sistemauna volta terminata la procedura di startup, essendo uno script di sistema, per effettuarela modifica di rc.local bisogna avere le credenziali di root.La modifica di rc.local consiste nellinserire alla fine dello script i comandi utilizzati perlavvio del server come si vede in Fig 5.18 cd /home/palma/Joseki-3.4.1 sh /home/palma/Joseki-3.4.1/bin/rdfserver & Fig 5.18 : Modifica del file rc.localLa prima riga serve per definire lambiente in cui si deve eseguire lo script di avvio diJoseki, mentre la seconda serve per avviare Joseki in modalità background comedescritto precedentemente. #!/bin/sh # /etc/rc.d/rc.local: Local system initialization script. # Put any local startup commands in here. Also, if you have # anything that needs to be run at shutdown time you can # make an /etc/rc.d/rc.local_shutdown script and put those # commands in there. cd /home/palma/Joseki-3.4.1 sh /home/palma/Joseki-3.4.1/bin/rdfserver & exit 0 Fig 5.19 : Visone del file rc.local 52
  • 52. Capitolo 5 Procedure di installazione del Software5.3 Installazione di JenaAnche se Jena è stato sviluppato come un insieme di librerie java, è possibile far uso dialcune utility a riga di comando descritte nel cap. 4.2.1.Per prima cosa, bisogna scaricare lultima versione di Jena (nel nostro caso è la 2.6.2 ), epoi decomprimere larchivio,verrà creata una sotto-directory chiamata Jena-2.6.2 nelladirectory di home. Per fare ciò si usa il comando : unzip Jena-2.6.2.zip Fig 5.20 : De-compattazione di JenaSempre dalla shell , si deve impostare la directory di root di Jena attraverso il comando : export JENAROOT = ~ / Jena-2.6.2 Fig 5.21 : Set variabile dambiente di JenaInfine, bisogna aggiungere i permessi di esecuzione a tutti i file presenti nella cartella : chmod u+x $JENAROOT/bin/* Fig 5.22 : Aggiunta permessi di JenaE possibile verificare il funzionamento di Jena, utilizzando lopzione --help a una delleutility presenti nella directory /bin, 53
  • 53. Capitolo 6 Risorse RDF pubbliche CAPITOLO 6 Risorse RDF pubblicheIn questo capitolo, vengono mostrate le maggiori basi di dati presenti nel web, comeFreebase , Dbpedia [11] , e il MERLOT [12] ( Multimedia Educational Resource forLearning and Online Teaching ), che rendono pubblicamente disponibili le loro risorse,utilizzando sempre un approccio al Web Semantico .6.1 FreeBaseFreebase è una grande base di dati collaborativa, si tratta, di una raccolta online di datistrutturati non solo in RDF, che vengono raggruppati da fonti differenti, tra cui offre ilsuo contributo "wiki". Freebase mira a creare una grande e unica risorsa globale chepermette alle persone e alle macchine di accedere a informazioni, contenuti, e altro, inmodo più efficiente utilizzando lapproccio del Web Semantico. E stato sviluppato dallasocietà americana di software MetaWeb ed è entrato in esecuzione nel marzo del 2007.Questo sistema contiene informazioni su circa 12 milioni di argomenti o Enti, ogninuovo argomento che viene inserito, ha un ID univoco, modo da poter gestire topic conlo stesso nome, ma con significato diverso.Ad ogni argomento può essere associato a uno o più tipi come ad esempio, persone,luoghi, film ecc ecc, e ogni tipo può avere delle proprietà aggiuntive come la data dinascita per una persona o le coordinate per un luogo. Questi tipi, le relative proprietà e irelativi concetti vengono chiamati Schema.Chiunque può contribuire allinserimento di un nuovo concetto e sulla definizione dinuove proprietà e schemi.FreeBase provvede anche a mettere a disposizione delle API per la creazione, modificao miglioramento degli schemi, e queste ci permettono anche di interrogare le risorsecontenute direttamente da un interfaccia web. 54
  • 54. Capitolo 6 Risorse RDF pubbliche6.1.1 Esempio di risorsa FreebaseCome è stato accennato è possibile esplorare tutte le risorse che Freebase ci offre, ed èpossibile navigare allinterno dei topic.Sotto la voce explore Freebase, troveremo tutti gli argomenti messi a disposizione dalsistema come si vede in Fig 6.1. Ad esempio, scegliendo largomento Science &Tecnology, si aprira una lista di tutte le sotto-argomentazioni presenti. Fig 6.1 : Esempio di Argomentazioni FreebaseScegliendo la tipologia internet, che contiene a sua volta 40152 topic, troveremo unabreve descrizione di internet e tutti i topic vengono catalogati allinterno del tipo stessocome si vede in Fig 6.2. 55
  • 55. Capitolo 6 Risorse RDF pubbliche Fig 6.2 : Raggruppamento dei topicSe scegliamo il topic website, il primo in Fig 6.3, questo contiene a sua volta 4627topic, si nota che questi verranno visualizzati come un risultato di una query e che èconsentito fare delle operazioni direttamente via web su queste risorse, filtrando ilnome, il contenuto e la categoria degli oggetti o aggiungendo e rimuovendo proprietàdelle informazioni. Fig 6.3 : Visualizzazione delle risorsePossiamo inoltre vedere il risultato della ricerca, in formato RDF e non solo, andandosul link in basso alla pagina come in Fig 6.4 . 56
  • 56. Capitolo 6 Risorse RDF pubbliche Fig 6.4 : Scelta del formato6.2 DBpediaLe basi della conoscenza svolgono un ruolo sempre più importante nel migliorarelintelligenza del web e nel sostenere lintegrità delle informazioni. Oggi, la fontecentrale di conoscenza sul Web e data da Wikipedia, e viene mantenuta grazie a migliaiadi contributori.Il progetto DBpedia, sfrutta proprio questo centro di informazioni per lestrazione di datistrutturati e li rende disponibili sul web, utilizzando sempre un approccio al WebSemantico. DBpedia descrive attualmente più di 3,4 milioni di cose, di cui 1,5 milionisono classificati in un ontologia pubblica scaricabile da sito, tra cui 312.000 persone,413.000 posti, 94.000 album musicali, 49.000 film, 15.000 video giochi, 140.000organizzazioni, 146.000 specie e 4.600 malattie .Tutti i data-set di Dbpedia, sono caratterizzati da delle etichette caratteristiche , tra cui3,2 milioni di cose classificate in 92 lingue diverse; 841.000 collegamenti a immagini e5.081.000 link a pagine web esterne; 9.393.000 link esterni in altri data-set RDF,565.000 categorie di Wikipedia, e 75.000 le categorie YAGO. La base di conoscenza ditutta DBpedia consiste di oltre 1 miliardo di triple RDF, di cui 257 milioni sono statiricavati dalla edizione inglese di Wikipedia e 766 milioni sono stati estratti dalleedizioni in altre lingue. 57
  • 57. Capitolo 6 Risorse RDF pubbliche6.2.1 Esempio di risorsa DbpediaTutte le risorse di Dbpedia vengono presentate come dati strutturati e queste possonoessere interrogate attraverso lausilio del linguaggio SPARQL o visualizzate attraverso ilmetodo del Linked Data. Dbpedia, ci offre una piattaforma per linterrogazione dellerisorse, ma questo non toglie che possiamo utilizzare una qualsiasi server perlinterrogazione di dati strutturati come ad esempio Joseki.Tutti i data-set pubblici di Dbpedia sono stati caricati in http://DBpedia.org/sparql,mentre sotto lindirizzo http://dbpedia.org/snorql/ è stato caricato un server genericoSPARQL per linterrogazione delle risorse come si vede in Fig 6.5. Fig 6.5 : Server offerto da DbpediaInoltre, è possibile visualizzare il risultato delle query nel formato più opportunoscegliendo in che modo ricevere il risultato, tutti i namespace per linterrogazionevengono importati automaticamente.Un altro modo per esplorare le risorse in modo automatico, è quello di utilizzaredirettamente il nostro browser, questo approccio viene chiamato Linked Data.Tutte le risorse sono collegate tra loro, e così un utente partendo da un iniziale fonte didati, si può spostare attraverso un web potenzialmente infinito di sorgenti, collegati da 58
  • 58. Capitolo 6 Risorse RDF pubblichelink in RDF. Questo sistema viene utilizzato specialmente da sistemi automatici. Se adesempio vogliamo visualizzare le fonti di dati che esprimono il concetto “SemanticWeb”, queste vengono descritte dalla pagina http://dbpedia.org/page/Semantic_Webcome si vede in Fig 6.6. Fig 6.6 : Rappresentazione della risorsa Semantic WebSotto le voci Property, verranno inserite rispettivamente tutte le proprietà che la risorsa“Semantic Web” possiede, una sorta di namespace per la risorsa. Mentre in Value tutti ivalori contenuti dalla proprietà, questi valori possono essere degli attributi( genericamente in formato testuale ) o dei riferimenti ad altre risorse, questi riferimenti,se aperti, vengono strutturati nel modo precedentemente descritto.Inoltre, è possibile, convertire e visualizzare la pagina della risorsa in diversi formaticome si vede in Fig 6.7. Fig 6.7 : Formati di conversione della pagina 59
  • 59. Capitolo 6 Risorse RDF pubbliche6.3 MerlotIl MERLOT( Multimedia Educational Resource for Learning and Online Teaching ) èuna comunità gratuita aperta di risorse online, destinata principalmente al corpodocente, le persone e gli studenti provenienti da tutto il mondo, per condividere tra loromateriale di apprendimento.Lobiettivo principale del MERLOT, è quello di migliorare lefficacia dellinsegnamentoe dellapprendimento, aumentandone la quantità e la qualità del peer reviewed online dimateriali didattici .Il repository del MERLOT non è composto solamente da materiali di apprendimento,ma anche da assegnazioni, commenti, collezioni personali e pagine Web ContentBuilder, tutte progettate, per migliorare lesperienza di insegnamento di un materialedidattico.Tutti le risorse sono suddivise in 14 differenti tipologie di apprendimento e una vastagamma di materiale è composta anche da commenti e assegnazioni. Le assegnazionisono progetti, documentazioni o attività che possono essere parte del corso per unaclasse, queste sono legate ad un modulo di apprendimento che può riguardare solamenteloggetto di apprendimento o può coinvolgere altre attività.I commenti invece sono le osservazioni individuali delle persone che hanno utilizzatoun materiale, è possibile anche valutarlo attraverso un livello di apprezzamento.6.3.1 Esempio di risorsa MERLOTTutte le risorse vengo suddivise in 14 categorie, come si vede in Fig 6.8, selezionandoad esempio la categoria Learning Object Repository, sulla destra della pagina sarannovisualizzate tutte le risorse riguardanti questa argomentazione. 60
  • 60. Capitolo 6 Risorse RDF pubbliche Fig 6.8 : Categorie delle risorseOgni risorsa, viene catalogata attraverso un nome che la identifica, un tipo ( tutti i tipisono mostrati in Fig 6.8) e la data di inserimento. Se ci sono state modifiche, vieneriportata la data della modifica. Inoltre vengono visualizzati i commenti, i peer review lepersonal Collection e gli esercizi riguardanti la risorsa, come mostrato in Fig 6.9 . Fig 6.9 : Visualizzazione delle risorse 61
  • 61. Capitolo 7 Query su risorse RDF CAPITOLO 7 Interrogazione di risorse RDFIn questo capitolo vengono riportate tutte le query che sono state eseguite utilizzando ilserver Joseki. Sono state raggruppate in 2 categorie: le query effettuate su un data-setlocale al sistema , utilizzando il server Joseki in locale, e le query fatte su data-setpresenti sul web utilizzando il server Joseki installato su una macchina remota (serverdelluniversità allindirizzo 151.100.106.21 sulla porta 2020).7.1 Query su un data-set localeTutte le query effettuate in questo paragrafo fanno riferimento ad un determinato data-set, memorizzato localmente al sistema.Il data-set viene messo a disposizione dal sito www.data.gov, dove è possibile trovaremigliaia di data-set in RDF, contenenti milioni di triple. Per i nostri esempi abbiamousato il dataset-1218.rdf, che fa riferimento alle ricerche tecnologiche effettuate negliStati Uniti.La query mostrata in Fig 7.1 estrae tutte le proprietà che contiene il data-set; queste cipermettono di interrogare il data-set in modo approfondito; PREFIX dc: <http://purl.org/dc/elements/1.1/> PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#> PREFIX xml: <http://www.w3.org/XML/1998/namespace> PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#Property> SELECT ?proprietà FROM <file:///home/daniele/Scaricati/dataset-1218.rdf> WHERE { ?proprietà rdfs:label ?x } Fig 7.1 :Query per lestrazione delle proprietà del data-set 62
  • 62. Capitolo 7 Query su risorse RDFIl risultato della query viene mostrato in Fig 7.2 in formato txt : Fig 7.2 : Risultato della query della Fig 7.1Se ad esempio, come nella query mostrata in Fig 7.3, preleviamo la risorsa ed il titolodi ogni progetto ,otteniamo il risultato in formato XML, ripreso in parte in Fig 7.4 . PREFIX dc: <http://purl.org/dc/elements/1.1/> PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#> PREFIX xml: <http://www.w3.org/XML/1998/namespace> PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#Property> SELECT ?risorsa ?titolo FROM <file:///home/daniele/Scaricati/dataset-1218.rdf> WHERE { ?risorsa <http://www.data.gov/semantic/data/alpha/1218/dataset-1218.rdf#project_title> ?titolo . } Fig 7.3 : Risorsa e titolo delle ricerche 63
  • 63. Capitolo 7 Query su risorse RDF Fig 7.4 : Risultato della query in Fig 7.3Prendiamo ora in considerazione i progetti che devono essere sviluppati. In particolareci interessano il titolo , la data di sviluppo e il sito web del progetto. Per estrarre questeinformazioni dal data-set possiamo utilizzare la query riportata in Fig 7.5. PREFIX dc: <http://purl.org/dc/elements/1.1/> PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#> PREFIX xml: <http://www.w3.org/XML/1998/namespace> PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#Property> SELECT DISTINCT ?titolo ?dataSviluppo ?sitoWeb FROM <file:///home/daniele/Scaricati/dataset-1218.rdf> WHERE { ?x < http://www.data.gov/semantic/data/alpha/1218/dataset- 1218.rdf#project_title > ?titolo . ?x <http://www.data.gov/semantic/data/alpha/1218/dataset- 1218.rdf#start_date> ?dataSviluppo . ?x <http://www.data.gov/semantic/data/alpha/1218/dataset- 1218.rdf#site_website> ?sitoWeb . } Fig 7.5 : Prelevo titolo , data di sviluppo e sito del progettoParte del risultato nel formato XML della query mostrata in Fig 7.5 viene riportato inFig 7.6. 64
  • 64. Capitolo 7 Query su risorse RDF Fig 7.6 : Risultato query della Fig 7.5In Fig 7.7 invece viene mostrata una query che estrae dal data-set: lID del progetto, ilnome dello stesso , il grado di difficoltà del progetto, e infine la data di inizio delprogetto. Il risultato viene filtrato sulla data di inizio del progetto e ordinato in ordineascendente per livello di difficoltà. PREFIX dc: <http://purl.org/dc/elements/1.1/> PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#> PREFIX xml: <http://www.w3.org/XML/1998/namespace> PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#Property> SELECT DISTINCT ?ID_Progetto ?Nome_Progetto ?Livello_di_Ricerca ?Data_Inizio FROM <file:///home/daniele/Scaricati/dataset-1218.rdf> WHERE { ?x <http://www.data.gov/semantic/data/alpha/1218/dataset- 1218.rdf#project_id> ?ID_Progetto . ?x <http://www.data.gov/semantic/data/alpha/1218/dataset- 1218.rdf#project_title> ?Nome_Progetto . ?x <http://www.data.gov/semantic/data/alpha/1218/dataset- 1218.rdf#research_type> ?Livello_di_Ricerca . ?x <http://www.data.gov/semantic/data/alpha/1218/dataset- 1218.rdf#start_date> ?Data_Inizio . FILTER (?Data_Inizio >= "12/12/93") } ORDER BY ASC (?Livello_di_Ricerca) Fig 7.7 : Estrazione ID, nome , Livello e data 65
  • 65. Capitolo 7 Query su risorse RDFIl risultato della query in Fig 7.7 viene riportato in Fig 7.8 : Fig 7.8 : Risultato query 7.77.2 Query su data-set remotiIn questo paragrafo vengono riportate tutte le query che sono state eseguite su data-setpubblici presenti sul web . Si è preferito eseguire le query su una macchina remota ,sulla quale è stato installato il server joseki (cfr 5.2 ).Cominciamo ad eseguire la query mostrata in Fig 7.9, dove vengono prelevate dal data-set specificato, il nome e la data di nozze delle principesse europee , il risultato infineviene filtrato prendendo in considerazione solamente quelle sposate prima del 1974. 66
  • 66. Capitolo 7 Query su risorse RDF PREFIX ged: <http://www.daml.org/2001/01/gedcom/gedcom#> SELECT ?nome_Principessa ?data_nozze FROM <http://www.daml.org/2001/01/gedcom/royal92.daml> WHERE { ?royal ged:title "Princess". ?royal ged:name ?nome_Principessa. ?royal ged:spouseIn ?family. ?family ged:marriage ?marriage. ?marriage ged:date ?data_nozze. FILTER (?data_nozze < "1 GEN 1974"). } Fig 7.9 : Estrazione nome e data di nozze delle principesse europeeIl risultato della query viene mostrato in Fig 7.10 : Fig 7.10 : Risultato query in Fig 7.9Passiamo ora, ad interrogare un nuovo data-set pubblico, che descrive la tavolaperiodica degli elementi. Nella Fig 7.11 viene mostrata un query che preleva il nome , ilpeso atomico , il numero ed il simbolo di tutti i gas nobili presenti sulla tavolaperiodica. Il risultato, viene poi ordinato per numero dellelemento e infine mostrato inFig 7.12. 67
  • 67. Capitolo 7 Query su risorse RDF PREFIX table: <http://www.daml.org/2003/01/periodictable/PeriodicTable#> SELECT ?nome_elemento ?simbolo ?peso_atomico ?numero FROM <http://www.daml.org/2003/01/periodictable/PeriodicTable.owl> WHERE { ?element table:group ?group. ?group table:name "Noble gas". ?element table:name ?nome_elemento. ?element table:symbol ?simbolo. ?element table:atomicWeight ?peso_atomico. ?element table:atomicNumber ?numero. } ORDER BY ASC (?numero) Fig 7.11 : Query sulla tavola periodica degli elementi Fig 7.12 : Risultato della query mostrata nella Fig 7.12Sempre sullo stesso data-set, eseguiamo una query che mostra il nome, il simbolo e ilpeso di tutti gli elementi che hanno peso maggiore delluranio (Fig 7.13). 68
  • 68. Capitolo 7 Query su risorse RDF PREFIX table: <http://www.daml.org/2003/01/periodictable/PeriodicTable#> SELECT ?nome_elemento ?simbolo ?peso FROM <http://www.daml.org/2003/01/periodictable/PeriodicTable.owl> WHERE { ?uranium table:name "uranium". ?uranium table:atomicWeight ?peso_uranio. ?element table:name ?nome_elemento. ?element table:symbol ?simbolo. ?element table:atomicWeight ?peso. FILTER (?peso > ?peso_uranio). } ORDER BY ASC (?peso) Fig 7.13 : nome e simbolo e peso degli elementi con peso > delluranioIl risultato (parziale) della query è riportato in Fig 7.14 : Fig 7.14 : risultato query mostrata in Fig 7.13Nella query mostrata in Fig 7.15, vengono interrogati 2 data-set; da uno prenderemo leinformazioni riguardanti la persona, in particolare il nome e le-mail, dallaltro estraiamotutte le pubblicazioni che ha effettuato nella 2003 Dublin Core conference. 69
  • 69. Capitolo 7 Query su risorse RDF PREFIX foaf: <http://xmlns.com/foaf/0.1/> PREFIX dc: <http://purl.org/dc/elements/1.1/> SELECT ?nome ?e_mail ?titolo FROM <http://www.siderean.com/dc2003/dc2003_presentations.rdf> FROM <http://www.siderean.com/dc2003/dc2003_agents.rdf> WHERE { ?person foaf:publication ?doc. ?doc dc:title ?titolo. ?person foaf:mbox ?e_mail. ?person foaf:name ?nome. } Fig 7.15 : Interrogazione di 2 data-setOgni persona ha contribuito a una pubblicazione, immagazzinata dalla variabile ?doc ,di conseguenza ogni ?doc avrà un ?titolo; ogni persona ha una ?e_mail e un ?nome.Così facendo si mette in relazione il data-set contenente tutte le pubblicazioni conquello che contiene tutti gli agenti della dc (Dublin Core Metadata Initiative).Il risultato della query e mostrato in Fig 7.16 : Fig 7.16 : Risultato delle query in Fig 7.15 70
  • 70. Capitolo 7 Query su risorse RDFNelle query svolte fino ad ora, sono state usate in diverse occasioni, alcuni standard,come VCARD, DC ( Dublin Core ) [10] e FOAF ( Friend of a Friend ). Questi standard,vengono ripresi e commentati nellAppendice B dellelaborato.E possibile interrogare questi standard, attraverso delle query, per prelevarne tutte leproprietà di cui sono composti.In Fig 7.17,viene mostrata la query per estrarre tutte le proprietà che compongono lostandard DC : PREFIX dc: <http://purl.org/dc/elements/1.1/> PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#> PREFIX xml: <http://www.w3.org/XML/1998/namespace> PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#Property> SELECT ?proprietà FROM <http://dublincore.org/2008/01/14/dcelements.rdf> WHERE { ?x rdfs:label ?proprietà } Fig 7.17 : Estrazione proprietà DCIn Fig 7.18, vengono riportate dunque tutte le proprietà che fanno parte dello standardDC , utilizzato per descrivere in RDF un documento sul Web : Fig 7.18 : Proprietà DC 71
  • 71. Capitolo 7 Query su risorse RDFProvvederemo ora, in Fig 7.19, allestrazione di tutte le proprietà dello standardVCARD, utilizzato per descrivere in RDF, tutte le caratteristiche e le generalità di unapersona : PREFIX dc: <http://purl.org/dc/elements/1.1/> PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#> PREFIX xml: <http://www.w3.org/XML/1998/namespace> PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#Property> SELECT ?proprietà FROM <http://www.w3.org/2006/vcard/ns> WHERE { ?x rdfs:label ?proprietà } Fig 7.19 : Estrazione proprietà VCARDParte del risultato della query, mostrata in Fig 7.19, sarà riprodotta in Fig 7.20 : Fig 7.20 : Proprietà standard VCARD 72
  • 72. Capitolo 8 Conclusione e sviluppi futuri CAPITOLO 8 Conclusione e sviluppi futuriNei capitoli precedenti, è stato presentato un server web, Joseki, che ci permette dieffettuare le interrogazioni, mediante lausilio di SPARQL, su risorse sviluppate in RDFe non solo.Come abbiamo visto, nella parte di installazione in remoto, si è riscontrato il problemariguardante il troncamento prematuro del servizio, una volta che si chiudeva la sessioneo il terminale. Questo problema è stato risolto, in un primo momento attraverso luso delcomando nohup e poi modificando il file dei servizi in esecuzione rc.local, di modo cheil server Joseki parta come servizio di base sul server remoto.E stato trattato inoltre, il Resource Description Framework ( RDF ): modello e sintassiutilizzati, oltre a RDF schema.Sul server sono state effettuate alcune query nel linguaggio di interrogazione per meta-dati SPARQL.Sono stati descritti alcuni repository online, che rendono le loro risorse pubbliche e chesfruttano i concetti del Web Semantico, oltre al vocabolario DC che permette diidentificare le proprieta dei documenti per estrarre le informazioni desiderate. Talirepository non esauriscono le risorse disponibili sul web: e infatti plausibile pensare dicreare ulteriori repository, o recuperare ulteriori risorse secondo le necessita di ricerca edi documentazione specialistiche. Tuttavia il sistema messo in piedi durante la tesi(SPARQL+Joseki) consente linterrogazione anche di queste nuove risorse, qualoradovessero essere rese pubbliche e/o accessibili. 73
  • 73. Appendice A conf-joseki.ttl Appendice A : conf-joseki.ttlIn questo appendice, viene mostrato il file di configurazione che è stato utilizzato perlavvio di joseki, tale file è presente allinterno della distribuzione di joseki installata.Tutti i # indicano una parte di commento.# This file is written in N3 / Turtle@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>.@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>.@prefix xsd: <http://www.w3.org/2001/XMLSchema#>.@prefix module: <http://joseki.org/2003/06/module#>.@prefix joseki: <http://joseki.org/2005/06/configuration#>.@prefix ja: <http://jena.hpl.hp.com/2005/11/Assembler#>.## --------------------------------------------------------------## This file is written in N3 / Turtle## It is an RDF graph - order of RDF triples does not matter## to the machine but it does help people who need to edit this file.## Note: web.xml must be in-step with this file.## for each service,## Note: adding rdfs:label to blank nodes will cause Joseki## to print that in log messages.## --------------------------------------------------------------## About this configuration<> rdfs:label "Joseki Configuration File" .## --------------------------------------------------------------## About this server<#server> rdf:type joseki:Server ; # Example of some initialization code. joseki:initialization [ module:implementation 74
  • 74. Appendice A conf-joseki.ttl [ module:className <java:org.joseki.util.ServiceInitSimple> ; rdfs:label "Example initializer" ; ] ]; .## --------------------------------------------------------------## Services## Services are the points that request are sent to.## serviceRef that will be used to match requests to services,## not some resource URI for the description.## Note that the service reference and the routing of incoming## requests by URI as defined by web.xml have to align.# Service 1# General purpose SPARQL processor, no dataset, expects the# request to specify the dataset (either by parameters in the# protocol request or in the query itself).<#service1> rdf:type joseki:Service ; rdfs:label "service point" ; joseki:serviceRef "sparql" ; # web.xml must route this name to Joseki joseki:processor joseki:ProcessorSPARQL ; .# Service 2 - SPARQL processor only handling a given dataset<#service2> rdf:type oseki:Service ; rdfs:label "SPARQL on the books model" ; joseki:serviceRef "books" ; # web.xml must route this name to Joseki# dataset part joseki:dataset <#books> ; 75
  • 75. Appendice A conf-joseki.ttl # Service part. # This processor will not allow either the protocol, # nor the query, to specify the dataset. joseki:processor joseki:ProcessorSPARQL_FixedDS ; .## ---- SPARQL/Update## A pair of services - one for SPARQL queries, one for SPARQL/Update## Previous web.xml must also be updated to include a defintion for the## servlet "SPARQL/Update service processor" and update requests must## be routed to this servlet.## <#serviceUpdate>## rdf:type joseki:Service ;## rdfs:label "SPARQL/Update" ;## joseki:serviceRef "update/service" ;## # dataset part## joseki:dataset <#mem>;## # Service part.## # This processor will not allow either the protocol,## # nor the query, to specify the dataset.## joseki:processor joseki:ProcessorSPARQLUpdate## .## <#serviceRead>## rdf:type joseki:Service ;## rdfs:label "SPARQL" ;## joseki:serviceRef "sparql/read" ;## # dataset part## joseki:dataset <#mem> ; ## Same dataset## # Service part.## # This processor will not allow either the protocol, 76
  • 76. Appendice A conf-joseki.ttl## # nor the query, to specify the dataset.## joseki:processor joseki:ProcessorSPARQL_FixedDS ;## .## --------------------------------------------------------------## Datasets <#books> rdf:type ja:RDFDataset ; rdfs:label "Books" ; ja:defaultGraph [ rdfs:label "books.n3" ; a ja:MemoryModel ; ja:content [ja:externalContent <file:Data/books.n3> ] ; ]; . <#mem> rdf:type ja:RDFDataset ; rdfs:label "MEM" ; ja:defaultGraph [ a ja:MemoryModel ] ; .## --------------------------------------------------------------## Processors joseki:ProcessorSPARQL rdfs:label "General SPARQL processor" ; rdf:type joseki:Processor ; module:implementation joseki:ImplSPARQL ; # Parameters - this processor processes FROM/FROM NAMED joseki:allowExplicitDataset "true"^^xsd:boolean ; joseki:allowWebLoading "true"^^xsd:boolean ; ## And has no locking policy (it loads data each time). ## The default is mutex (one request at a time) 77
  • 77. Appendice A conf-joseki.ttl joseki:lockingPolicy joseki:lockingPolicyNone ; .joseki:ProcessorSPARQL_FixedDS rdfs:label "SPARQL processor for fixed datasets" ; rdf:type joseki:Processor ; module:implementation joseki:ImplSPARQL ; # This processor does not accept queries with FROM/FROM NAMED joseki:allowExplicitDataset "false"^^xsd:boolean ; joseki:allowWebLoading "false"^^xsd:boolean ; joseki:lockingPolicy joseki:lockingPolicyMRSW ; .joseki:ProcessorSPARQLUpdate rdfs:label "SPARQL Update processor" ; rdf:type joseki:Processor ; module:implementation joseki:ImplSPARQLUpdate ; joseki:lockingPolicy joseki:lockingPolicyMRSW ; .joseki:ImplSPARQL rdf:type joseki:ServiceImpl ; module:className <java:org.joseki.processors.SPARQL> .joseki:ImplSPARQLUpdate rdf:type joseki:ServiceImpl ; module:className <java:org.joseki.processors.SPARQLUpdate> .# Local Variables:# tab-width: 4# indent-tabs-mode: nil 78
  • 78. Appendice B VCARD & FOAF Appendice B : VCARD e FOAFNel capitolo 7, vengono eseguite delle query su risorse pubbliche e sono state utilizzatealcune proprietà, queste, vengono messe a disposizione da alcuni standard comeVCARD e FOAF ( Friends of a Friends ), di seguito verranno mostrate le maggioriproprietà che compongono questi due standard.VCARD, definisce uno standard per descrivere un individuo, le proprietà più importantipresenti allinterno di questo standard sono : ● FN : Full Name, definisce il nome completo dellindividuo ● N : Name, solo il nome della persona. ● NICKNAME : soprannome della persona. ● PHOTO: viene memorizzata un url che fa riferimento alla foto dellindividuo. ● BDAY : definisce il giorno del compleanno della persona. ● ADR : è l indirizzo dellindividuo. ● LABEL : un etichetta che può essere assegnata allindividuo. ● TEL : viene memorizzato il numero di telefono ● EMAIL : lemail della persona. ● GEO : è composto da 2 numeri, rispettivamente la longitudine e latitudine in cui si trova la persona. ● TITLE : si riferisce al titolo di studio della persona ● ROLE : il ruolo che la persona ha nella società o in particolare nel lavoro ● ORG : organizzazione dove lindividuo lavora ● CATEGORIES : è la categoria del lavoro intrapreso dalla persona ● NOTE : le possibili note che descrivono la persona ● URL : un indirizzo web di riferimento 79
  • 79. Appendice B VCARD & FOAFFOAF è unontologia comprensibile dal computer atta a descrivere persone, con le loroattività e le relazioni con altre persone e oggetti. Chiunque può usare FOAF perdescriversi. FOAF permette a gruppi di persone di descrivere quel fenomeno noto comesocial network senza la necessità di un database centralizzato.Tutte le proprietà di FOAF vengono raggruppate in 5 categorie, la categoria di base(Fig B1), la categoria per le informazioni personali ( Fig B2 ), la categoria sugli accountonline ( Fig B3 ), la categoria dei progetti e gruppi ( Fig B4 ) e infine la categoria deiprogetti e delle immagini (Fig B5) Fig B.1 Fig B.2 Fig B.3 Fig B.5 80
  • 80. Appendice B VCARD & FOAF Fig B.4 81
  • 81. SitografiaSitografia :[1] SPARQL Query Language for RDF, in : http://www.w3.org/TR/rdf-sparql-query/[2] Jena – A Semantic Web Framework for Java, in :http://jena.sourceforge.net/[3] Documentazione di Jena,, in :http://jena.sourceforge.net/documentation.html[4] Joseki - a SPARQL Server for Jena, in :http://www.joseki.org/[5] Turtle - Terse RDF Triple Language, in :http://www.w3.org/TeamSubmission/turtle/[6] Tim Berners-Lee , Notation 3, in : http://www.w3.org/DesignIssues/Notation3[7] Extensible Markup Language (XML), in : http://www.w3.org/XML/[8] Namespaces in XML 1.0, in : http://www.w3.org/TR/REC-xml-names/[9] URIs, URLs, and URNs: Clarifications and Recommendations, in : http://www.w3.org/TR/uri-clarification/[10] Dublin Core Metadata Element Set, in : http://dublincore.org/documents/dces/ 82
  • 82. Sitografia[11] Dbpedia, in : http://wiki.dbpedia.org/About[12] MERLOT, in : http://www.merlot.org/merlot/index.htm[13] vCard , in : http://en.wikipedia.org/wiki/VCard[14] Resource Description Framework (RDF), in : http://www.w3.org/RDF/[15] W3C , Semantic Web Activity, in : http://www.w3.org/2001/sw/[16] W3C , RDF/XML Syntax Specification, in : http://www.w3.org/TR/rdf-syntax-grammar/[17] Semantic Web History, in : http://www.w3.org/1999/11/11-WWWProposal/[18] W3C, RDF Vocabulary Description Language 1.0: RDF Schema, in : http://www.w3.org/TR/rdf-schema/[19] Resource Description Framework (RDF): Concepts and Abstract Syntax in : http://www.w3.org/TR/2004/REC-rdf-concepts-20040210/[20] RDF Semantics , in : http://www.w3.org/TR/2004/REC-rdf-mt-20040210/[21] Tim Berners-Lee, Primer: Getting into RDF & Semantic Web using N3 in : http://www.w3.org/2000/10/swap/Primer.html 83
  • 83. Sitografia[22] SPARQL Protocol for RDF , in : http://www.w3.org/TR/rdf-sparql-protocol/ 84