Scuola Politecnica e delle Scienze di Base
Corso di Laurea in Ingegneria Informatica
Elaborato finale in BASI DI DATI
VIRTUOSO DB:CARATTERISTICHE
Anno Accademico 2013/2014
Candidato:
MINOCCHI MARIO
matr. N46000420
A mio Padre …Un esempio di Vita
Indice
Indice .................................................................................................................................................. III
Introduzione ........................................................................................................................................ 4
Capitolo 1: Introduzione al Web Semantico ........................................................................................ 6
1.1 L'architettura del Web Semantico ................................................................................. 7
1.2 URI ovvero Uniform Resource Identifiers ..................................................................... 8
1.3 RDF ovvero Resource Description Framework ............................................................ 9
1.4 L'RDF Data Model ...................................................................................................... 10
1.5 RDF Schema ................................................................................................................ 12
1.6 I metadati...................................................................................................................... 13
1.7 RDF ed XML ............................................................................................................... 14
1.8 Ontologie ...................................................................................................................... 15
Capitolo 2: I Triple Store ................................................................................................................... 17
2.1 Triple Store benchmark ................................................................................................ 17
Capitolo 3: Virtuoso ........................................................................................................................... 20
3.1 Architettura .................................................................................................................. 22
3.2 Blocco .......................................................................................................................... 22
3.3 Le operazioni................................................................................................................ 22
3.4 L'integrità dei dati ........................................................................................................ 22
3.5 Componenti e file ......................................................................................................... 23
3.6 Protocolli implementati ................................................................................................ 23
3.7 API di supporto ............................................................................................................ 23
3.8 Virtuoso RDF Triple Store ........................................................................................... 23
Conclusioni ........................................................................................................................................ 25
Bibliografia ........................................................................................................................................ 26
Introduzione
Al giorno d'oggi grazie all'enorme sviluppo avuto dall'informatica, dell'elettronica e al costo,
fondamentalmente, contenuto di apparecchi capaci di collegarsi a internet, l'espressione "lo cerco
sul web" è diventata abituale. Ciò ci fa riflettere anche su cosa sia diventato il web negli anni: un
serbatoio di conoscenza. Attraverso la rete, infatti, è possibile fare svariate cose, come consultare un
libro , chattare, fare acquisti online, e tutto ciò è in continua e rapida evoluzione. Basta pensare che
negli anni '90 il web era composto da poche pagine testuali, con il tempo al testo si sono aggiunti
contenuti multimediali che hanno dato alle pagine una grafica più ricca. Il contenuto, memorizzato
su poche migliaia di macchine e sviluppato da pochi "specialisti", ha iniziato a crescere in quantità
smisurata. Se ciò da un lato ha ampliato le possibilità del web rendendolo una sorta di enciclopedia
universale multimediale, un gestore di servizi da remoto e un centro di comunicazione mondiale,
dall'altro ha reso le ricerche più complesse all'utente finale che è sempre più obbligato a terminare
la ricerca "manualmente" scegliendo il risultato desiderato tra tutti quelli restituiti da un motore di
ricerca. Ciò avviene perché i tradizionali motori di ricerca effettuano ricerche di tipo sintattico
restituendo, infatti, le pagine che contengono le keywords presenti nelle query degli utenti,
indipendentemente dal contesto in cui esse sono utilizzate oppure restituiscono pagine secondo
algoritmi differenti, ad esempio basati sulla popolarità. Per venire incontro a tale problema, negli
ultimi anni, le aziende proprietarie dei motori di ricerca stanno investendo nello sviluppo di nuove
tecnologie che permettano alle macchine di interpretare il senso delle parole in maniera simile a
come succede tra essere umani. Il loro obiettivo è quello di creare sistemi d'information retrieval
capaci di estrarre e indicizzare i concetti più significativi dei testi in modo da rendere le ricerche
effettuate tramite i loro portali sempre più precise. Di fronte a questa moltitudine di informazioni,
l’importanza dei motori di ricerca assume un ruolo significativo. Per qualsiasi utente di Internet,
utilizzare un motore di ricerca e non trovare ciò che si sta cercando, può essere frustrante. È
interessante, infatti, notare come, di fronte alla notevole quantità di risultati pervenuti, un’altissima
percentuale di utenti (il 30%) non superi mai la seconda/terza pagina di risultati.
Questa schematizzazione dei risultati è dovuta agli attuali algoritmi di ricerca basati sull’aspetto
sintattico dell’informazione, essi restituiscono le pagine contenenti le keywords presenti nelle query
degli utenti, indipendentemente dal contesto in cui esse sono utilizzate oppure restituiscono pagine
secondo algoritmi differenti, ad esempio basati sulla popolarità. La fiducia dell’utente verso la
qualità di ricerca del motore è, e deve essere dunque, totale, e affinché esso soddisfi le sue
aspettative è fondamentale assicurare la bontà degli algoritmi di analisi. Negli ultimi anni le aziende
proprietarie dei motori di ricerca stanno investendo nello sviluppo di nuove tecnologie che
permettano alle macchine di interpretare il senso delle parole similmente agli esseri umani. La loro
aspirazione è quella di creare sistemi di information retrieval capaci di estrarre ed indicizzare
semanticamente i concetti più significativi dei testi affinché le ricerche effettuate attraverso i loro
portali risultino sempre più precise.
Nella prima parte di questo elaborato di tesi focalizzeremo l’attenzione sullo studio degli elementi
chiave del Semantic Web, estensione del Web attuale che punta, attraverso la creazione di dati
elaborabili e comprensibili direttamente dalle macchine e attraverso l’uso della logica e dei
linguaggi di rappresentazione della conoscenza ,a massimizzare l’efficienza degli algoritmi di
ricerca. Grazie al Semantic Web, infatti, la ricerca di documenti non sarà più incentrata sul
significato lessicale della singola parola chiave come avveniva nella ricerca sintattica ma sul
significato che assumono più concetti legati tra loro (ricerca semantica). A tal proposito verrà
quindi introdotto un linguaggio di codifica RDF, Resource Description Framework, per raggiungere
la cosiddetta interoperabilità semantica. Al di sopra di questo strato si pone il livello ontologico.
Recentemente il termine "ontologia" (formale) è entrato in uso nel campo dell'intelligenza artificiale
e della rappresentazione della conoscenza, per descrivere il modo in cui diversi schemi vengono
combinati in una struttura dati gerarchica che contiene tutte le entità rilevanti, le relazioni esistenti
4
fra di esse, le regole, gli assiomi ed i vincoli specifici del dominio. Nel prosieguo del lavoro
effettueremo una panoramica sulle principali applicazioni sviluppate in grado di memorizzare triple
RDF, i cosiddetti triplestore e, tramite la scelta di opportuni parametri prestazionali ,verrà fornita
poi una classificazione degli stessi. A seguire una descrizione di Virtuoso con tutte le sue principali
caratteristiche.
5
Capitolo 1: Introduzione al Web Semantico
Lo scenario attuale del World Wide Web è quello di un enorme insieme di testi collegati in qualche
modo tra loro. Una peculiarità essenziale del WWW è la sua universalità; il potere di
un link ipertestuale deriva dal fatto che "qualunque cosa può essere collegata a qualunque altra cosa
da chiunque". I testi sono creati ad uso e consumo dei soli utenti umani, gli unici allo stato attuale in
grado di comprendere i contenuti delle pagine che stanno visitando. Possiamo distinguere i
collegamenti tra le pagine in due classi:
collegamenti sintattici: sono legati al funzionamento di un qualche codice di
programmazione. Sono piuttosto solidi (un link localizza una risorsa attraverso
un URL univoco, anche se si pone un problema di updating)
collegamenti descrivono il significato di un collegamento. Questi ultimi sono invece
piuttosto deboli (i.e. generici e vaghi), cioè oltre a portare in un determinato luogo un
collegamento dovrebbe descrivere il luogo verso cui porta (capacità semantica)
Gli utenti umani si orientano nel Web grazie alla loro esperienza di navigazione e alla capacità di
evocazione che possono avere parole o espressioni chiave. L'esperienza è un aspetto molto
importante di cui tutti ci serviamo: impariamo che determinati contenuti si possono reperire sotto
determinati portali, che l'aspetto di un sito può dirci qualche cosa sul genere (formale o informale)
delle informazioni. Essa si costruisce nel tempo ma non è molto legata ad aspetti tecnici, al codice e
alle applicazioni che costituiscono un sito. L'altro aspetto, quello delle parole chiave, è più legato al
codice. Queste caratteristiche non appartengono invece a nessuna applicazione, che in definitiva
non è in grado (tranne qualche eccezione limitata e molto complessa, quindi non significativa) di
interpretare il contenuto delle pagine .
Il termine Web Semantico è stato proposto per la prima volta nel 2001 da Tim Berners-Lee. Da
allora il termine è stato associato all'idea di un Web nel quale agiscano agenti intelligenti (creati
senza ricorrere all'intelligenza artificiale ad alti livelli), applicazioni in grado di comprendere il
significato dei testi presenti sulla rete e perciò in grado di guidare l'utente direttamente verso
l'informazione ricercata, oppure di sostituirsi a lui nello svolgimento di alcune operazioni. Un
agente dovrebbe essere in grado di:
comprendere il significato dei testi presenti sulla rete
creare percorsi in base alle informazioni richieste dall'utente, guidandolo poi verso di esse
(in alcuni casi si può anche sostituire all'utente)
spostarsi di sito in sito collegando logicamente elementi diversi dell'informazione richiesta
Come caratteristica ulteriore, dovrebbe verificare l'attendibilità di una informazione (tramite
ricerche incrociate o in dipendenza dal contesto) utilizzando un meccanismo che potremmo
assimilare alle famigerate catene di S. Antonio.
Utilizzando questa tecnologia si può automatizzare la ricerca delle pagine, poiché all'atto della
creazione del contenuto delle pagine le informazioni sono definite ed inserite secondo precise
regole semantiche (per questo è stato coniato il termine Web Semantico).
Il Web Semantico è quindi un nuovo modo di concepire i documenti per il World Wide Web .
6
Secondo la definizione di Tim Berners-Lee. Le possibilità offerte dal Web Semantico sono tante e
tali che non si sono ancora approfondite le sue potenzialità. Per questo, più che di tecnologia, si
parla divisione del Web Semantico.
<
1.1 L’architettura del Web Semantico
Scrivere del codice in grado di compiere operazioni semantiche dipende dallo schema utilizzato per
archiviare le informazioni. Lo schema (ad esempio uno schema XML) è un insieme di regole
sull'organizzazione dei dati. Può definire relazioni fra i dati e può anche esprimere vincoli tra classi
di dati.
L'idea del Web Semantico nasce estendendo l'idea di utilizzare schemi per descrivere domini di
informazione. Dei metadati (sono le informazioni comprensibili da una macchina e relativi ad una
risorsa Web o qualche altra cosa, che possono essere estratti da una risorsa o possono essere
trasferiti con il documento) devono mappare i dati rispetto a classi, o concetti, di questo schema di
dominio. In questo modo si hanno strutture in grado di descrivere e automatizzare i collegamenti
esistenti fra i dati.
.
Il Web Semantico è, come l'XML, un ambiente dichiarativo, in cui si specifica il significato dei dati,
e non il modo in cui si intende utilizzarli. La semantica dei dati consiste nel dare alla macchina
delle informazioni utili in modo che essa possa utilizzare i dati nel modo corretto, convertendoli
eventualmente. Riassumendo, il Web Semantico si compone di tre livelli fondamentali:
1. i dati
2. i metadati riportano questi dati ai concetti di uno schema
3. nello schema si esprimono le relazioni fra concetti, che diventano classi di dati
Il Web Semantico ha quindi una architettura a livelli, che però non è stata ancora sviluppata
completamente. Ciò avverrà nei prossimi anni. Vediamo ora il diagramma più in dettaglio:
1. il Web Semantico si basa sullo standard [11] URI (Uniform Resource Identifiers), per la
definizione univoca di indirizzi Internet
7
2. al livello superiore si trova XML (eXtensible Markup Language), che gioca un ruolo di base
con i namespace e gli XML Schema. Con XML è possibile modellare secondo le proprie
esigenze, e senza troppi vincoli, la realtà che si considera: per questo è un linguaggio che
porta con sé alcune informazioni sulla semantica degli oggetti. Questa libertà lo rende poco
adatto, però, a definire completamente la struttura e l'interscambio di informazioni tra
diverse realtà, quindi è stata favorita la creazione di un nuovo linguaggio
3. RDF (Resource Description Framework) e RDF Schema, che costituiscono il linguaggio per
descrivere le risorse e i loro tipi. Derivano da XML
4. al livello superiore si pone il livello ontologico. Una ontologia permette di descrivere le
relazioni tra i tipi di elementi (per es. "questa è una proprietà transitiva") senza però fornire
informazioni su come utilizzare queste relazioni dal punto di vista computazionale
5. la firma digitale è di significativa importanza in diversi strati nel modello astratto
del Web Semantico. La crittografia a chiave pubblica è una tecnica nota da qualche anno,
ma non ancora diffusa su larga scala, forse perché impone una scelta binaria tra fiducia o
non fiducia, mentre sarebbe necessaria una infrastruttura in cui le parti possano essere
riconosciute e accettate in specifici domini. Con questo accorgimento, la firma digitale
potrebbe essere utilizzata per stabilire la provenienza delle ontologie e delle deduzioni, oltre
che dei dati
6. il livello logico è il livello immediatamente superiore. A questo livello le asserzioni esistenti
sul Web possono essere utilizzate per derivare nuova conoscenza. Tuttavia, i sistemi
deduttivi non sono normalmente interoperabili, per cui invece di progettare un unico sistema
onnicomprensivo per supportare il ragionamento, si potrebbe pensare di definire un
linguaggio universale per rappresentare le dimostrazioni. I sistemi potrebbero quindi
autenticare con la firma digitale queste dimostrazioni ed esportarle ad altri sistemi che le
potrebbero incorporare nel Web Semantico
1.2 URI ovvero Uniform Resource Identifiers
Se vogliamo intraprendere una conversazione, o vogliamo scrivere un testo qualsiasi, dobbiamo
prima identificare in maniera univoca l'argomento che vogliamo trattare, altrimenti non potremo
riferirci ad esso.
Nel Web Semantico è stato definito un sistema di identificatori unificato: sono gli Uniform Resource
Identifiers (URI). Il nome deriva dal fatto che ogni elemento identificato viene considerato
una risorsa. Gli URI sono utilizzati da RDF per codificare l'informazione in un documento, ed
assicurano che i concetti non sono solo parole in un documento, ma sono vincolanti.
Gli URI costituiscono la tecnologia di base ideale con la quale costruire un Web globale. Possiamo
definire un URI per un qualsiasi oggetto, e qualsiasi cosa che ha un URI può essere condiderato
sul Web. Gli URI sono il fondamento del Web : mentre ogni parte del Web stesso può essere
rimpiazzata, gli URI no. Anche per identificare le pagine sul Web utilizziamo identificatori: sono i
tipi più comuni di URI, gli indirizzi URL (Uniform Resource Locator). Guardando più in profondità
si può notare che un URL comunica al computer dove trovare una risorsa specifica. Diversamente
da altre forme di URI, un URL allo stesso tempo identifica e localizza. Poiché il Web è troppo
8
esteso per essere essere controllato da una qualsiasi organizzazione, gli URI in massima parte sono
decentralizzati. Nessuna persona o organizzazione controlla chi li produce o cosa ne fa. Questa
flessibilità rende gli URI potenti, ma porta alcuni problemi. Ad esempio, poiché chiunque può
creare un URI, inevitabilmente avremo più URI che rappresentano la stessa cosa; e non c'è modo
per determinare se due URI puntano alla stessa risorsa. Perciò non siamo in grado di dire con
esattezza cosa significa un URI.
Una pratica comune per creare URI è quella di iniziare da una pagina Web. La pagina descrive
l'oggetto che deve essere identificato e spiega che l'URL della pagina è l'URI per tale oggetto. Il
punto d'arrivo sarà che qualsiasi istanza rappresenterà sia la risorsa fisica, sia la pagina Web che la
descrive.
Ciò
è
noto
come
problema
dell'identificazione
delle
pagine Web.
Questo è un fatto importante da comprendere. Un URI non è un insieme di direttive che indicano
al computer dove trovare un file specifico nel Web (sebbene lo faccia anche), ma è un nome per una
risorsa (una cosa), accessibile o meno attraverso Internet. L'URI può o no fornire un modo per
ottenere più informazioni su una risorsa. Altri metodi per fornire informazioni sugli URI e le risorse
che essi identificano sono in via di sviluppo. è anche vero che l'abilità di dire cose su di un URI è
una parte importante del Web Semantico. Ma non dobbiamo assumere che un URI fa qualcosa di
più che fornire un identificatore per una risorsa.
David Connelly del W3C ha realizzato una pagina in cui ha raccolto gli schemi URI che sono stati
definiti.
1.3 RDF ovvero Resource Description Framework
RDF (Resource Description Framework) è uno standard proposto dal W3C come set di linguaggi
dichiarativi basato su sintassi XML ed adatto a descrivere la struttura di una parte della realtà. Per
realtà intendiamo qualsiasi risorsa sia possibile identificare sulla rete con un indirizzo univoco,
mentre per descrizione indichiamo l'insieme delle proprietà, degli attributi e delle relazioni con altre
realtà.
RDF è lo strumento base per la codifica, lo scambio e il riutilizzo di metadati strutturati, e consente
l'interoperabilità tra applicazioni che si scambiano sul Web informazioni machine-understandable. I
settori nei quali RDF può essere utilizzato o portare vantaggi sono i più disparati:
descrizione del contenuto di un sito Web , o di una pagina, o di una biblioteca digitale
implementazione di agenti software intelligenti, per lo scambio di conoscenza e un utilizzo
migliore delle risorse Web
classificazione del contenuto, per applicare criteri di selezione
descrizione di un insieme di pagine, che rappresentano un singolo documento logico
stabilire i criteri di proprietà intellettuale delle singole pagine
esprimere criteri di privacy preference degli utenti e le privacy policies di un sito Web
con il meccanismo della firma digitale, contribuire alla creazione del Web of Trust, per le
applicazioni nel commercio elettronico, la cooperazione, etc..
9
RDF, quindi, non descrive la semantica, ma fornisce una base comune per poterla esprimere,
permettendo di definire la semantica dei tag XML. RDF è costituito da due componenti:
RDF Model and Syntax: definisce il modello di dati RDF e la sua codifica XML, senza
definire alcun livello di gerarchia o di relazione
RDF Schema: permette di definire specifici vocabolari per i metadati e creare nessi tra
oggetti
Quindi da una parte avremo i dati, dall'altra uno schema che definisce come i dati si strutturano e
come sono in relazione fra loro; c'è bisogno anche di un livello intermedio in cui tenere traccia di
come un dato specifico (istanza) può essere espresso a partire dallo schema.
1.4 L'RDF Data Model
RDF fornisce un modello per descrivere le risorse che possono avere delle proprietà (o anche
attributi o caratteristiche). Per RDF una risorsa è un qualsiasi oggetto che sia identificabile
univocamente mediante un URI. L'RDF Data Model è quindi basato su tre tipi di oggetti:
Risorse: una risorsa può essere rappresentata da una pagina, un gruppo di pagine,
un'immagine, un server o una qualsiasi altro elemento che abbia un URI
Proprietà: una proprietà è una specifica caratteristica o attributo di una risorsa; una proprietà
può anche descrivere relazioni con altre risorse
Asserzioni: una asserzione è costituita dall'insieme di una risorsa, una proprietà e uno
specifico valore per quella proprietà e descrive le caratteristiche di una risorsa e le relazioni
con altre risorse
Talvolta, è necessario far riferimento a più di una risorsa (un documento può essere composto da
una serie di componenti). Per questo scopo RDF definisce tre tipi di container:
Bag: è una lista non ordinata di risorse o costanti. Viene utilizzato per dichiarare che una
proprietà ha valori multipli, senza alcun significato particolare attribuito al loro ordine (per
esempio, i componenti di una commissione). Sono ammessi valori duplicati.
Sequence: è una lista ordinata di risorse o costanti. Viene utilizzato per dichiarare che una
proprietà ha valori multipli, e che il loro ordine è significativo (per esempio un insieme di
nomi di cui si voglia preservare l'ordine alfabetico). Sono ammessi valori duplicati.
Alternative: è una lista di risorse o costanti che rappresentano una alternativa per il valore
(singolo) di una proprietà. Può essere utilizzato, per esempio, per fornire titoli alternativi in
varie lingue.
È possibile definire proprietà sia dell'intero container che dei singoli elementi.
Non bisogna confondere i container e le proprietà multiple: una risorsa può essere soggetto in più
10
asserzioni, sempre con lo stesso predicato (per esempio, Calvino è autore di "Se una notte d'inverno
un viaggiatore", "Le fiabe italiane", "Il barone rampante",...). Si noti che è semanticamente diverso
il caso in cui si ha una singola asserzione il cui oggetto è un container contenente vari esemplari.
Per esempio, l'asserzione: "La commissione composta da X, Y e Z ha adottato una decisione", non
implica che ogni membro della commissione abbia espresso lo stesso parere, come invece sarebbe
nel caso di un'asserzione multipla.
In alcuni casi, può essere utile poter certificare la credibilità di una particolare asserzione, cioè
formulare delle asserzioni relative ad altre asserzioni. Per esempio prendendo la risorsa:
http://www.nomesito.it/Dorati/Tesina.html
has Author Antonella Dorati
viene vista da RDF come un fatto. Invece, l'asserzione:
Alessio Crisologo dice che la risorsa
http://www.nomesito.it/Dorati/Tesina.html
has Author Antonella Dorati
non afferma un fatto relativo alla risorsa
http://www.nomesito.it/Dorati/Tesina.html
ma un fatto relativo all'affermazione di Alessio Crisologo. Per esprimere questo fatto in RDF,
dobbiamo modellare l'asserzione come una risorsa con quattro proprietà:
soggetto: identifica la risorsa che viene descritta dall'asserzione modellata, quindi il soggetto
è la risorsa relativamente alla quale era stato formulato l'asserzione originale
(http://www.nomesito.it/Dorati/Tesina.html, nell'esempio)
predicato: identifica la proprietà originale nell'asserzione modellata. Il valore del predicato è
una risorsa che rappresenta la specifica proprietà nell'asserzione originale (nel nostro
esempio, Author)
oggetto: identifica il valore della proprietà nell'asserzione modellata. Il valore dell'oggetto è
l'oggetto nell'asserzione originale (nel nostro esempio:"Antonella Dorati")
tipo descrive il tipo della nuova risorsa
Una nuova risorsa con queste quattro proprietà rappresenta l'asserzione originale, e può essere
utilizzata come oggetto di altre asserzioni e avere ulteriori asserzioni che lo riguardano. Nell'ambito
della comunità che si interessa di Knowledge Representation, questo processo prende il nome
di reificazione, e il modello di asserzione reified statement.
11
1.5 RDF Schema
I namespace XML forniscono un metodo per identificare in maniera non ambigua la semantica e le
convenzioni che regolano l'utilizzo delle proprietà identificando l'authority che gestisce il
vocabolario. Uno degli esempi più noti di queste autority è la Dublin Core Initiative che definisce,
ad esempio, il campo Subject and Keywords nel seguente modo:
Name: Subject and Keywords
Identifier: Subject
Definition: The topic of the content of the resource.
Comment: Typically, a Subject will be expressed as keywords,
key phrases or classification codes that describe a topic of
the resource. Recommended best practice is to select a value
from a controlled vocabulary or formal classification scheme.
Si può quindi utilizzare un namespace XML per identificare in maniera non ambigua lo schema per
il vocabolario Dublin Core puntando alla risorsa Dublin Core che ne definisce la semantica.
L'RDF Data Model permette di definire un modello semplice per descrivere le relazioni tra le
risorse. Tuttavia non fornisce alcun meccanismo per dichiarare queste proprietà, né per definire le
relazioni tra queste proprietà ed altre risorse. RDF Schema permette di definire dei vocabolari,
quindi l'insieme delle proprietà semantiche individuato da una particolare comunità. RDF Schema
permette definire significato, caratteristiche e relazioni di un insieme di proprietà, compresi
eventuali vincoli sul dominio e sui valori delle singole proprietà. Inoltre, implementando il concetto
(transitivo) di classe e sottoclasse, consente di definire gerarchie di classi, con il conseguente
vantaggio che gli agenti software possono utilizzare queste relazioni per svolgere i loro compiti.
12
1.6 I metadati
Adesso
abbiamo
uno
schema,
costruito
per
la
risorsa
localizzabile
all'URL
http://www.nomesito.it/nomecorso/nomecorso.html.
Descriviamo ora qualche metadato e cerchiamo di capire come questa risorsa si relaziona al nostro
schema. La dichiarazione iniziale non necessita del namespace rdfs.
<?xml version='1.0' encoding='ISO-8859-1'?>
<rdf:RDF
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns:a=" http://www.nomesito.it/data/nomeontologia#">
<a:Corso rdf:about="http://www.nomesito.it/nomecorso/nomecorso.html">
<a:Titolo="nomecorso"/>
</a:Corso>
<a:Argomento rdf:about="http://www.nomesito.it/nomecorso/nomecorso.html"
a:Titolo="nomeargomento1"/>
</a:Argomento>
<a:Argomento rdf:about="http://www.nomesito.it/nomecorso/nomecorso.html"
a:Titolo="nomeargomento2"/>
</a:Argomento>
</rdf:RDF>
Per il momento abbiamo prodotto dei metadati molto semplici. Abbiamo detto che la prima risorsa è
un corso dal titolo nomecorso. Poi abbiamo detto che questa stessa risorsa è legata a due argomenti
diversi. I metadati sono costituiti tutti da asserzioni. Ogni asserzione è costituita, da un punto di
vista logico, da una tripla in cui sono presenti tre elementi fondamentali:
soggetto
predicato
oggetto
Il soggetto sarà generalmente la classe di uno schema ma potrà anche essere la classe di uno schema
diverso (usando l'URI per identificarla), il predicato sarà sempre una proprietà della classe (che può
però puntare ad un'altra classe), l'oggetto un dato: può essere o una stringa, oppure un'altra classe
dello schema, o ancora una classe di schemi differenti (per collegare due schemi fra di loro).
Queste triple possono essere scritte utilizzando tag XML. In RDF, in un documento si fanno
asserzioni che determinati oggetti hanno proprietà con certi valori. Questa struttura è un modo
naturale per descrivere la maggior parte dei dati processati dalle macchine. Soggetto e oggetto sono
identificati da un URI, come si usa nei link alle pagine Web. I predicati sono ugualmente identificati
da URI; ciò permette a chiunque di definire nuovi concetti solo definendo un URI ad essi da
13
qualche parte nel Web.
Le triple di RDF formano ragnatele di informazioni su cose che sono in relazione.
Poiché RDF utilizza queste informazioni per codificare queste informazioni in un documento,
l'URI assicura che questi concetti non sono solo parole in un documento ma sono legati ad una
definizione unica che chiunque può trovare sul Web.
Per ottenere maggiore espressività questa regola può essere espansa. In realtà le classi dello schema
possono essere espresse come URL. Ogni schema è identificabile da un namespace e attraverso
il namespace di uno schema si può identificare la classe. La nostra classe #Argomento, sostituendo
il cancelletto con lo schema dichiarato in cima al documento, potrebbe essere espansa come
http://miosito/rdfs/nomeschema/Argomento
In questo modo si può notevolmente ampliare la capacità espressiva delle asserzioni RDF.
La struttura a tripla delle asserzioni è molto flessibile e abbastanza potente. La potenza può essere
ampliata se si collegano fra loro più asserzioni. Le asserzioni si possono collegare facilmente
tramite degli ID.
<a:Corso rdf:about="http://www.nomesito.it/nomecorso/nomecorso.html">
<a: Livello_di_Spec=
"http://www.nomesito.it/data/nomeontologia/model.rdf#ID_13"/>
</a:Corso>
<a:Specializzazione
rdf:about="http://www.nomesito.it/data/nomeontologia/model.rdf#ID_13"
a:Preparazione_Utenti="alta"/>
</a:Specializzazione>
<a:Specializzazione
rdf:about="http://www.nomesito.it/data/nomeontologia/model.rdf#ID_13"
a:Utenti="http://www.nomesito.it/data/nomeontologia/model.rdf#ID_14"/>
</a:Specializzazione>
<a:Utenti
rdf:about="http://www.nomesito.it/data/nomeontologia/model.rdf#ID_14"
a:nome="nomeutenti"/>
</a:Specializzazione>
1.7 RDF ed XML
Rispetto a XML, di cui è un figlio, RDF ha alcuni vantaggi, come per esempio la possibilità di
definire agevolmente il tipo e le proprietà degli oggetti (si tratta sempre di un insieme definito di
risorse, proprietà e valori). RDF limita e focalizza alcune caratteristiche di XML per renderlo un
linguaggio rivolto alla descrizione di un oggetto, delle sue proprietà, e delle relazioni con gli altri
oggetti.
Le differenze tra RDF e XML sono fondamentalmente due:
RDF è stato pensato espressamente per esprimere metadati. XML fa molte cose, e può anche
essere usato per descrivere metadati, ma generalmente ha un rapporto molto più stretto con i
14
dati, contiene già in sé dei dati che possono essere richiamati. RDF esprime metadati, nel
senso più proprio: descrive contenuti di un documento che in esso non sono presenti
XML è centrato su una struttura a inclusione, riesce perciò ad esprimere senza difficoltà le
relazioni di parentela o di essere parte di, ma per le altre relazioni dimostra dei limiti. Se
volessi esprimere una relazione associativa fra due classi, cioè dire che esse hanno una
relazione ma non sono incluse una nell'altra, con XML devo ricorrere agli ID e agli IDREF
1.8 Ontologie
Gli RDF Schema hanno però alcune limitazioni. Non è ad esempio possibile definire due classi
come equivalenti, magari perché realizzate da autori diversi (che quindi possono avere utilizzato
diversi identificatori per definire il medesimo concetto). Non è neppure possibile limitare
puntualmente il numero di proprietà da usare (per esempio: ogni corso ha uno e un solo argomento).
Per colmare queste lacune sono allora state introdotte le ontologie o OWL (Web Ontology
Language), collezioni di informazioni.
Il più comune tipo di ontologia per il Web ha una tassonomia e un insieme di regole di inferenza.
La tassonomia definisce classi di oggetti e relazioni tra di essi. Classi, sottoclassi, e relazioni tra
entità sono un tool potente per l'uso per il Web. Possiamo esprimere un largo numero di relazioni
tra le entità assegnando proprietà alle classi e permettendo che le sottoclassi ereditino tali proprietà.
L'OWL è un vocabolario XML che consente di definire, come gli RDF Schema, classi, proprietà e
relazioni. A differenza degli RDF Schema, che estende, OWLaumenta le inferenze che un software
è in grado di compiere. Utilizzando OWL è possibile riconoscere che due parti di un documento
stanno descrivendo la stessa realtà, utilizzando però una terminologia diversa.
Riprendiamo l'esempio precedente, e supponiamo che il corso sia stato espresso in termini
di <NomeCorso> invece di < Corso >.
Le ontologie sono utilizzate per definire dei metadati che descrivano dei testi. Il loro utilizzo
permette di recuperare documenti esprimendo query complesse. Si parte da concetti semplici, ma si
può raffinare la ricerca esprimendo vere e proprie asserzioni composte da un soggetto un predicato
ed un oggetto. Si può insomma fare una richiesta del tipo: aziende (soggetto) che hanno come
servizio (predicato) la fornitura di scarpe (oggetto).
Questa query è radicalmente diversa da quella che si potrebbe fare ad un motore di ricerca. In
questo caso si potrebbero proporre tutti e tre i concetti di azienda di servizio e di scarpe, ma non
potremmo mai esprimere il legame fra di essi. Da qui derivano appunto le imprecisioni dei motori
di ricerca .
L'uso di ontologie nella navigazione di basi di dati è certamente interessante ma molto riduttivo. Le
ontologie sono innanzi tutto degli schemi e come tali hanno lo scopo di organizzare un dominio.
Questo può essere molto utile nei processi produttivi di una comunità ristretta. Una informazione
solitamente non ha valore solo in una fase del processo produttivo, la stessa informazione può
essere utile in situazioni diverse. Più spesso non è l'intera unità informativa ad essere recuperabile
ma una parte di essa. Questo richiede uno schema di organizzazione dei dati in grado di suddividere
il dominio in tutte le classi di oggetti che hanno un ruolo nei suoi processi. Le ontologie
diventeranno probabilmente lo strumento più potente a disposizione di queste politiche; e se queste
ultime intendono servirsi di Internet come infrastruttura, i linguaggi del Web Semantico diventano
una risorsa applicativa indispensabile.
Anche se i livelli più alti dell'architettura potranno richiedere diversi anni prima di poter
raggiungere uno stadio in cui siano effettivamente implementati e affidabili, già esiste una quantità
15
significativa di lavoro nel settore delle ontologie. Le soluzioni pratiche includono l'uso di XSLT per
derivare RDF da documenti XML, la comparsa di database e motori di ricerca RDF di tipo
generalizzato, interfacce grafiche generalizzate e specifiche per RDF.
La prima cosa che dobbiamo perciò chiederci quando modelliamo un ontologia è questa: cosa
vogliamo dire o fare dei nostri oggetti, come li chiamiamo in causa. In alcuni casi potremmo voler
descrivere documenti che trattano di quegli oggetti. In altri casi possiamo aver bisogno di tenere
traccia di un processo produttivo. In altri ancora tenere traccia delle scelte e delle attività operate da
un utente.
Il processo nel quale dovrà essere inserito lo schema, diventa il punto focale della modellazione. Se
siamo in grado di metterlo in luce con chiarezza sapremo quali oggetti descrivere. Solitamente si
definiscono ontologie di scopo (task ontology) quelle che rappresentano la struttura dei processi. Le
ontologie che forniscono gli oggetti specifici della nostra applicazione vengono invece
dette ontologie di dominio (domain ontology).
16
Capitolo 2 : I Triplestore
I triplestore sono dei database realizzati appositamente per la memorizzazione ed il recupero di
triple RDF. Proprio come un database relazionale, è possibile memorizzare le informazioni in un
triplestore e poi le recuperarle attraverso un linguaggio di query, in questo caso SPARQL.
Si distinguono i seguenti triplestore in base alla loro architettura:
In-memory: essi memorizzano il grafo RDF nella memoria principale.
Native: una seconda categoria ora dominante è quella dei triplestore nativi. Essi
implementano un database engine completo, ottimizzato per l’elaborazione di dati RDF ed
opera indipendentemente da ogni altro Database Management System (DBMS). I dati sono
memorizzati direttamente sul file system.
Non-native non-memory: tali triplestore sono impostati per essere eseguiti su database di
terze parti, usufruiscono delle funzionalità di archiviazione e recupero dei DBMS esistenti.
È possibile dividere questo modello in:
Generic Schemas in cui i dati RDF vengono memorizzati a prescindere da qualsiasi
ontologia in una tabella simile alla struttura tripla di un RDF, ossia in una tabella a tre
colonne (soggetto-predicato-oggetto). Il vantaggio di tale approccio è chiaramente la
flessibilità ottenuta dalla rappresentazione dei dati, il principale svantaggio è l’elevato
numero di selfjoins che sono necessari per rispondere alle query non banali.
Ontology-specific Schemas in cui i dati RDF non vengono memorizzati in una singola
tabella ma viene creato uno schema che rifletta le proprietà strutturali delle ontologie in atto.
Si possono distinguere tre sottomodelli:
1) “Horizontal representation” oppure “one-table-per-class schema”: ogni classe dell’ontologia
si riflette in una tabella del database che contiene tutte le istanze di tale classe. Lo svantaggio
principale di tale approccio è quello di ristrutturare le tabelle del database ogni volta che cambia
l’ontologia e, inoltre, manca il sostegno per valori multipli della proprietà.
2) ”Decomposition storage model” oppure “one-table-per-property schema”: ogni proprietà si
riflette in una tabella composta da due colonne (soggetto e oggetto). Lo svantaggio di questo
modello è l’inefficienza delle query quando si tratta di query complesse perché genera molti join tra
le tabelle proprietà.
3) “Hybrid Schemas”: sono più comuni e combinano i vantaggi di entrambi i modelli.
2.1 Triplestore benchmark
Oltre allo sviluppo dei database RDF e di linguaggi di interrogazione adeguati ai triplestore, sono
state realizzate anche appropriate tecniche di valutazione (benchmark). I benchmark principali
messi a disposizione e quelli più usati sono:
SPARQL (Simple Protocol And RDF Query Language): è un linguaggio per l'interrogazione e il
recupero dei dati espressi in RDF nonché un protocollo di accesso ai dati per il Web Semantico, e il
15 gennaio 2008 è stato standardizzato dallo SPARQL Working Group del W3C. SPARQL consiste
di tre specifiche:
- SPARQL Query Language specification che costituisce il nucleo.
- SPARQL Query Results Format specification che descrive un formato XML per serializzare il
risultato di una query.
-SPARQL Protocol for RDF specification che definisce protocolli semplici HTTP e SOAP per fare
le query in remoto su basi di dati RDF: permette a un generico cliente di interrogare uno o più
17
endpoint SPARQL (interfaccia per gli utenti nella forma di un’applicazione stand-alone oppure
web-based) inviando una richiesta espresa nel linguaggio di interrogazione e ricevendo come
risposta il risultato in un formato XML.
Di fronte ad una grande quantità di documenti RDF pubblicata in rete, inizia a prendere forma un
Web leggibile per le macchine. In questo contesto è necessario disporre di un meccanismo per
individuare informazioni specifiche nel Web di Dati. È in questo contesto che si colloca SPARQL.
I vantaggi principali di avere un linguaggio come SPARQL sono:
- fare le query a dei grafici RDF per ricevere informazioni specifiche.
- fare le query ad un server remoto RDF e ricevere indietro i risultati in streaming.
- eseguire delle query in automatico verso insiemi di dati RDF per generare resoconti.
Entrando più nell’aspetto sintattico,consideriamo a titolo di esempio, una semplice query SPARQL:
PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
SELECT ?c
WHERE
{
?c rdf:type rdfs:Class .
} RDF (Triplestore) Database
30
Questa query recupera tutti i modelli di triple in cui la proprietà è rdf: type e l'oggetto è rdfs: Class.
In altre parole, questa query, una volta eseguita, recupera tutte le classi. Si noti che, come abbiamo
visto in precedenza il meccanismo dei namespace per scrivere RDF in XML, SPARQL ci permette
di definire dei prefissi per i namespace e utilizzare questi nel modello di query, per rendere le query
più breve e più leggibile. SPARQL non assume alcun impegno esplicito per supportare la
semantica RDFS. Pertanto, il risultato di una query dipende dall’opportunità o meno che il sistema
che sta rispondendo alla query supporti la semantica RDFS.
Le query SPARQL hanno una struttura del tipo SELECT-FROM-WHERE:
- SELECT specifica la proiezione: il numero e l'ordine dei dati recuperati.
- FROM viene utilizzata per specificare la risorsa interrogata, questa clausola è facoltativa, quando
non specificata possiamo semplicemente assumere che stiamo interrogando la base di conoscenza di
un particolare sistema.
- WHERE impone limitazioni sulle possibili soluzioni nella forma di template grafici e vincoli
booleani (in SPARQL usando una condizione di filtro). Oltre a prevedere la clausola SELECT
come in SQL, offre anche altri costrutti. E’ possibile infatti prevedere che:
- non si conosce a priori lo schema dei dati. Per risolvere questo problema SPARQL ha la clausola
DESCRIBE, che permette di ottenere una descrizione della risorsa cercata.
- si presenti la necessità di sapere se un certo enunciato o un certo pattern di dati sia presente nella
sorgente dati. Per questo motivo SPARQL propone la clausola ASK.
• Lehigh University Benchmark (LUBM): è stato sviluppato per facilitare la valutazione dei
repository del Semantic Web in modo standard e sistematico. Il benchmark ha lo scopo di valutare
le prestazioni di tali archivi su un set di dati di grandi dimensioni. L’ontologia utilizzata dal
benchmark è chiamata Univ-Bench, descrive le università e i dipartimenti e le attività che si
verificano in esse. Il benchmark è formato da 14 query, scritte in SPARQL, scelte affinché fossero
più realistiche possibili e tenessero conto di fattori come la dimensione dell’input, la selettività, la
complessità ecc.
• Berlin SPARQL Benchmark (BSBM): fornisce un benchmark sulle prestazioni delle query
utilizzando SPARQL. Il BSBM è composto da 12 query che vengono eseguite a frequenze diverse,
nel contesto di un caso d'uso e-commerce. Il caso d’uso di e-commerce è realizzato eseguendo più
volte variazioni delle 12 query in un “mix query” composto da 25 query che simulano una ricerca di
prodotti da parte di un singolo consumatore. Questo benchmark include un generatore di dati e un
18
test suit. Il generatore di dati è in grado di costruire una quantità scalabile di dati in formato
RDF/XML basati su un caso d’uso di e-commerce. Il funzionamento del test suite, invece, si basa
su un caso d’uso preso dalla vita reale, l’esecuzione delle varie query imitano il comportamento
degli operatori umani. Nella sua ultima versione sono stati aggiunti altri due casi d’uso uno
‘Explore and Update’, in cui si simulano operazioni di scrittura/lettura con l’aggiunta di update
query, e l’altro ‘Intelligence Business’, in cui si simula l’escuzione di domande analitiche sui
dataset.
19
Capitolo 3 : Virtuoso
Openlink Virtuoso è un innovativo data server multi-modello, esso offre una soluzione,
indipendente dalla piattaforma, per la gestione dei dati, l'accesso e l’integrazione.
L’architettura ibrida del server Virtuoso consente di offrire le funzionalità del server tradizionale
all’interno di un offerta unica che copre le seguenti aree:
Relational Data Management ;
RDF Data Management ;
XML Data Management ;
Free Text Content Management & Full Text Indexing ;
Document Web Server ;
Linked Data Server ;
Web Application Server ;
Web Services Deployment (SOAP or REST) ;
Virtuoso è quindi un database ibrido che combina in un unico sistema le funzionalità di un
tradizionale RDBMS, ORDBMS, virtual database, RDF, XML, web application server e file server.
Piuttosto che avere server dedicati per ogni funzionalità sopra elencate Virtuoso fornisce un accesso
trasparente alle fonti di dati esistenti, che sono in genere banche dati di fornitori di database diversi.
Come DBMS relazionale offre un po' tutte le caratteristiche che offrono gli RDBMS tipici come
MySQL e simili. Ovviamente supporta il linguaggio SQL, inoltre mette a disposizione molte
funzioni utili. Per quanto riguarda invece le sue funzionalità come Triple Store, il modello di dati
utilizzato è il modello a grafo, che è quello utilizzato dalla maggior parte dei Triple Store che non si
basano su database relazionali. E' possibile interrogarlo tramite il linguaggio SPARQL , eseguire
update tramite SPARUL ed è possibile importare ed esportare dati in formato RDF. I formati di
serializzazione RDF supportati sono HTML+RDFa, RDF-JSON, N3, Turtle, TriG, TriX e
RDF/XML. Virtuoso ha guadagnato un notevole interesse in quanto è utilizzato per ospitare molti
importanti Linked open Date (ad esempio, DBpedia). Virtuoso viene offerto sia in una versione
open-source che in una commerciale.
20
Un'altra caratteristica molto interessante è che è molto semplice esporre le funzionalità di Virtuoso
come web services. Infatti supporta può essere interrogato sia utilizzando SOAP che REST.
Si possono scrivere delle stored procedures e pubblicarle direttamente come servizi, con tanto di
generazione automatica del WSDL.
Inoltre è possibile in qualche modo riutilizzare anche i web service scritti in Java, modificando un
po il codice per eseguire una sorta di wrap. E' possibile riutilizzare anche i servizi scritti in
linguaggi della piattaforma .NET. Infine è disponibile un'estensione per poter utilizzare Virtuoso
come motore BPEL4WS.
Grazie a questa è possibile organizzare le orchestrazioni dei servizi facendone il deploy
direttamente nel DBMS. Inoltre poter gestire i dati, i servizi e magari anche le orchestrazioni da un
unico punto semplifica parecchio la gestione. La versione open source ovviamente ha qualche
limitazione, non supporta infatti la replicazione dei dati e quello che chiamano "Virtual Database
Engine", che permette di eseguire query SQL su database multipli remoti.
Su sistemi come Ubuntu, per esempio, sono disponibili già i binari installabili dal gestore di
pacchetti. Su Windows invece per poterlo compilare c'è bisogno di strumenti come Visual Studio
ecc.
21
3.1 Architettura
Virtuoso è stato progettato per sfruttare il supporto threading del sistema operativo e più CPU. .Più
thread possono funzionare la minima interferenza con l'altro. La base di dati ha in ogni momento
uno stato checkpoint pulito e un insieme di cambiamenti impegnati o non impegnati a questo stato
checkpoint. In questo modo è possibile fare una copia di backup dello stato checkpoint mentre le
operazioni procedono sullo stato commit.
Un file di registro delle transazioni registra tutte le transazioni dall'ultimo checkpoint. File di log
delle transazioni possono essere conservati e archiviati per un tempo indefinito, fornendo una
completa, storia recuperabile del database.
Un singolo set di file è utilizzata per memorizzare tutte le tabelle. Un insieme separato di file viene
utilizzato per tutti i dati temporanei. La dimensione massima di un set di file è di 32 terabyte, per
4G × 8K pagine.
3.2 Blocco
Virtuoso fornisce blocco dinamico, iniziando con i blocchi a livello di riga e l'escalation di blocchi a
livello di pagina quando un cursore in possesso di una grande percentuale di righe di una pagina o
quando si ha una storia di bloccaggio intere pagine. Virtuoso SQL fornisce i mezzi per la lettura
esclusiva e per l'impostazione di isolamento delle transazioni.
3.3 Le operazioni
Tutti e quattro i livelli di isolamento sono supportati: lettura dirty, leggere commesso, lettura
ripetibile e serializzabile. Il livello di isolamento può essere specificata operazione per operazione
all'interno di una singola transazione. Virtuoso può anche agire come un gestore di risorse e / o
coordinatore di transazione sotto Distributed Transaction Coordinator di Microsoft ( MS DTC )
3.4 L'integrità dei dati
Virtuoso ORDBMS database supporta l'integrità di entità e integrità referenziale . Virtuoso assicura
che le relazioni tra i record nelle tabelle correlate siano valide applicando l'integrità
referenziale . Vincoli di integrità sono:
NOT NULL - Entro la definizione di una tabella, Virtuoso consente ai dati di contenere un valore
NULL. Questo valore NULL non è davvero un valore a tutti ed è considerata l'assenza di valore. Il
vincolo di NOT NULL forza un valore da dare a una colonna.
Unique Key - Unicità per una colonna o un insieme di colonne significa che i valori in quella
colonna o insieme di colonne devono essere diversa da tutte le altre colonne o un insieme di
colonne in tale tabella. Una chiave univoca può contenere valori NULL in quanto sono per
definizione un valore non-valore unico.
Chiave primaria - chiave primaria sono molto simile chiavi univoche, tranne che essi sono
progettati per identificare in modo univoco una riga in una tabella. Essi possono essere costituiti da
una singola colonna o più colonne. La chiave primaria non può contenere un valore NULL.
22
Vincolo CHECK - Virtuoso fornisce su una colonna di un vincolo di integrità che richiede
determinate condizioni che devono essere soddisfatte prima che i dati viene inserito o
modificato. Se i controlli non sono soddisfatti, allora l'operazione non può essere completata.
3.5 Componenti e file
Virtuoso è costituito da componenti client e server. Questi componenti tipicamente comunicano con
un server Virtuoso locale o remoto, che comprendono:
Driver Virtuoso per ODBC , JDBC , ADO.NET e OLE DB
una interfaccia utente di amministrazione di database web-based
ISQL (Interactive SQL) e ISQO Utilities
Documentazione ed esercitazioni
Esempi
Le installazioni sono dotati di due database: uno di default e un database demo.
3.6 Protocolli implementati
Virtuoso supporta una vasta gamma di protocolli Web & Internet standard di settore che
includes: HTTP , WebDAV , CalDAV , CardDAV , SOAP , UDDI , WSDL , WS-Policy , WS-Security , WSReliableMessaging , WS-Routing , WS-Referral , WS-Attachment , WSBPEL , SyncML , GData , SPARQL , SPARUL , NNTP
3.7 API di supporto
Per lo sviluppatore e sistemi di applicazione di database integratore, Virtuoso implementa una serie
di API di accesso ai dati standard del settore (client e server) che include: ODBC , JDBC , OLE
DB , ADO.NET , ADO.NET Entity Framework , XMLA
Content syndication e il supporto per il formato di interscambio
Per lo sviluppatore di applicazioni Web e sindacato contenuti (s) editori e consumatori, Virtuoso
supporta standard quali: Atom , RSS 2.0 , RSS 1.0 , OPML , XBEL , FOAF , SIOC
3.8 Virtuoso RDF Triple Store
Molti database relazionali sono stati utilizzati per la memorizzazione di triple RDF . Sono presenti
anche approcci non-relazionali, come l'utilizzo di indici bitmap come supporto di memorizzazione
primario per triple sono state attuate.
Virtuoso offre l'IRI come un tipo di dati incorporato, distinto da qualsiasi altro dato. Questo
consente una rappresentazione a colonna singola di un oggetto di un triple. Dal momento che un
qualsiasi valore è una parte chiave valida con un ordine ben definito di confronto tra i tipi di dati
non comparabili, gli indici possono essere costruiti utilizzando l'oggetto di un triple. In casi
selezionati, l'indicizzazione di testo può essere desiderata per gli oggetti di alcuni triple. Questo non
è direttamente supportato in SPARQL. Le regole del cast typing di SPARQL e SQL differiscono.
Con queste caratteristiche in luogo, SPARQL può essere efficacemente tradotto in SQL senza
23
introdurre comandi supplementari inutili o altro disordine. Inoltre Virtuoso può fornire un mix di
tutte queste opzioni di archiviazione.
24
Conclusioni
Nonostante il web sia uno strumento utile per il recupero, l'elaborazione e la trasmissione delle
informazioni e della conoscenza, rimane, ancora e soprattutto, una gigantesca biblioteca di pagine
HTML (statiche e dinamiche) online. I motori di ricerca attuali sono in grado, secondo ben precise
istruzioni, di disporre e visualizzare le informazioni in una certa maniera, ma non hanno capacità di
riconoscerle o attribuire loro un particolare significato per elaborarle, questo poiché effettuano solo
ricerche di tipo sintattico basate su insieme di parole chiave.
Il linguaggio, proposto dal W3C, per la rappresentazione delle informazioni riguardo le risorse del
Web è RDF (Resource Description Framework). L’RDF ci permette di effettuare semplici
affermazioni sulle risorse, tali affermazioni sono costituite da una tripla soggetto-predicato-oggetto
in cui il soggetto è la parte che identifica ciò che l'affermazione descrive, il predicato è la parte che
identifica la proprietà o le caratteristiche del soggetto e l’oggetto è la parte che identifica il valore
della proprietà. Nascono così i primi database realizzati appositamente per la memorizzazione ed il
recupero di triple RDF, i cosiddetti triplestore.
L’obiettivo principale di elaborato di tesi è stato quello di introdurre i concetti relativi al Web
semantico e approfondire le tematiche riguardanti i triple store. Abbiamo introdotto un tipo di triple
store come Virtuoso analizzandone le caratteristiche principali, gli ambiti applicativi, i pregi e i
difetti.
25
Bibliografia
[1]T. Berners-Lee, J. Hendler, O. Lassila, May 2001 “The Semantic Web”, Scientific American
[2]http://aprogrammerblog.blogspot.it/2012/06/virtuoso-universal-server-un-dbms-per.html17/09/2014
[3] http://www.websemantico.org/articoli/approcciwebsemantico.php- 18/09/2014
[4] Ontologia, http://it.wikipedia.org/wiki/Ontologia_(informatica)
[5] Triplestore, http://en.wikipedia.org/wiki/Triplestore
[6] http://en.wikipedia.org/wiki/Virtuoso_Universal_Server - 23/09/2014
[7] http://docs.openlinksw.com/virtuoso/ - 23/09/2014
[8] http://virtuoso.openlinksw.com/dataspace/doc/dav/wiki/Main/VOSTriple - 29/09/2014
26
27
