Questa sezione descriverà un metodo per specificare dati RDF in XML.
Se non hai familiarità con RDF, o hai una comprensione limitata, leggi la sezione precedente. Se provi a leggere prima questa sezione, probabilmente sarà difficile comprendere RDF.
Spesso avrai bisogno di memorizzare RDF in un file o trasferire i
dati da qualche altra parte. C'è un formato XML comune per
memorizzare RDF. Questo formato è detto RDF/XML. Ci sono diverse
altre maniere di memorizzare dati RDF, ma questo formato è il
più comune. Alcune persone si riferiscono erroneamente a questo
formato come RDF. In realtà RDF è il modello descritto
nella sezione precedente, in cui la sintassi è propriamente
detta RDF/XML.
Un semplice file RDF/XML apparirà come quello qui sotto. Il
tag RDF è il nodo radice e circonda i dati. Le triple non sono
ancora nel file; le aggiungeremo tra un momento. Dichiariamo gli spazi
di nomi nel tag RDF, come gli altri vocabolari XML.
<?xml version="1.0"?>
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns:people="http://www.xulplanet.com/rdf/people/">
</rdf:RDF>
Dichiariamo due spazi di nomi, quello rdf, e uno spazio di nomi 'people' per i nostri scopi.
Guardiamo questa semplice tripla RDF:
<http://www.xulplanet.com/rdf/people/Sandra> -> name -> Sandra
Ci sono tre parti di informazione che avranno bisogno di essere
memorizzati, la risorsa soggetto, il predicato e il target. Nella
sezione precedente non abbiamo messo il predicato 'name' in uno spazio
di nomi per semplicità. Comunque avremo bisogno di aggiungere
uno spazio di nomi, e per gli scopi di questo esempio, ne creeremo uno.
Questi sono i dati che dobbiamo memorizzare:
Soggetto: <http://www.xulplanet.com/rdf/people/Sandra>
Predicato: <http://www.xulplanet.com/rdf/people/name>
Oggetto: Sandra
Aggiungiamo la tripla sopra al file. E' una tripla che descrive una
relazione risorsa->letterale. Questo tipo di relazione può
essere descritta con un singolo tag, con due attributi:
<?xml version="1.0"?>
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns:people="http://www.xulplanet.com/rdf/people/">
<rdf:Description rdf:about="http://www.xulplanet.com/rdf/people/Sandra"
people:name="Sandra"/>
</rdf:RDF>
Il tag Description può essere usato per descrivere una tripla. Questo tag è nello spazio di nomi rdf. L'attributo about
è usato per specificare il soggetto nella tripla. Per l'oggetto
della tripla 'Sandra', lo assegnamo all'attributo 'people:name'. Con la
qualificazione dello spazio di nomi, questo attributo si espande al
valore'http://www.xulplanet.com/rdf/people/name', che è il predicato nella tripla.
Perciò, per specificare una tripla, sfruttiamo i nostri
namespaces e assegnamo un valore target agli attributi usando gli
stessi nomi come predicati. Potremmo aggiungere un attributo per ogni
tripla che vogliamo aggiungere che abbia lo stesso soggetto.
<rdf:Description rdf:about="http://www.xulplanet.com/rdf/people/Sandra"
people:name="Sandra"
people:gender="female"/>
Non serve ripetere il tag Description ogni volta; aggiungi
solo ulteriori attributi allo stesso tag. Comunque, non è
sbagliato usare tag multipli. Per esempio, si può ottenere lo
stesso risultato con
<rdf:Description rdf:about="http://www.xulplanet.com/rdf/people/Sandra"
people:name="Sandra"/>
<rdf:Description rdf:about="http://www.xulplanet.com/rdf/people/Sandra"
people:gender="female"/>
Ricorda che in RDF, l'ordine delle triple non è importante.
Ecco perché questa sintassi alternativa è accettabile.
Dal momento che l'ordine non è importante, potremmo mettere i
tags o attributi in un ordine differente e avremmo le stesse triple.
RDF/XML ha diverse vie alternative di specificare la stessa cosa.
Guardiamone un'altra. Invece di usare la forma attributo, potremmo
usare un tag per specificare il predicato. Per esempio, la tripla di
sopra potrebbe essere scritta:
<rdf:Description rdf:about="http://www.xulplanet.com/rdf/people/Sandra">
<people:name>Sandra</people:name>
</rdf:Description>
Qui l'attributo predicato è stato rimpiazzato da un tag.
Entrambe le forme producono lo stesso risultato, ma potrebbe esserci
una ragione per preferire l'uno o l'altro. La forma attributo è
più breve e quindi è utile per specificare molti
predicati. La forma tag è più pratica quando il valore
è lungo, per una migliore leggibilità. Potrebbe essere
usata anche se il valore ha delle virgolette, che non possono essere
messe in un attributo senza usare caratteri di escape. Inoltre, la
forma tag ti permette di usare lo stesso predicato più volte:
<rdf:Description rdf:about="http://www.xulplanet.com/rdf/people/Sandra">
<people:name>Sandra</people:name>
<people:name>Sandy</people:name>
</rdf:Description>
Questo crea due triple con la stessa risorsa soggetto e predicato, ma con diversi valori oggetto. Abbiamo visto queste triple nella sezione precedente. Non saremmo in grado di fare questo solo con gli attributi, dato che un tag non può avere lo stesso attributo due volte.
E' accettabile mischiare le due forme se necessario. Per esempio, quello che segue rappresenta tre triple.
<rdf:Description rdf:about="http://www.xulplanet.com/rdf/people/Sandra"
people:name="Sandra">
<people:name>Sandy</people:name>
<people:gender>female</people:gender>
</rdf:Description>
Avrai anche bisogno di specificare relazioni risorsa-risorsa come questa:
<http://www.xulplanet.com/rdf/people/Sandra> -> sibling ->
<http://www.xulplanet.com/rdf/people/Kevin>
Non puoi usare la forma attributo per questo tipo di triple,
poiché possono essere usati solo per valori letterali. Comunque,
puoi usare una forma tag modificata. Comunque, invece di mettere il
valore dentro i tag di apertura e chiusura, puoi usare l'attributo resource.
<rdf:Description rdf:about="http://www.xulplanet.com/rdf/people/Sandra"
people:name="Sandra">
<people:sibling rdf:resource="http://www.xulplanet.com/rdf/people/Kevin"/>
</rdf:Description>
Qui usiamo l'attributo resource per indicare che il fratello (elemento dello stesso livello NdT) della risorsa Sandra è un'altra risorsa <http://www.xulplanet.com/rdf/people/Kevin>. Nota che questo attributo deve essere nello spazio di nomi rdf. Questo attributo è usato per specificare oggetti risorsa, mentre il testo nel tag è usato per specificare oggetti letterali. Nota la somiglianza di forma con l'attributo about. L'attributo about è usato per i soggetti (la parte sinistra di una tripla) e l'attributo resource è utilizzato per gli oggetti (target) (la parte destra della tripla).
Nell'esempio sopra, abbiamo anche specificato il nome di Sandra con
un attributo. Accade spesso di raggruppare tutte le triple legate a uno
stesso soggetto insieme in un file. Se volessimo aggiungere qualche
tripla per Kevin, dovremmo ugualmente usare un altro tag Description:
<rdf:Description rdf:about="http://www.xulplanet.com/rdf/people/Sandra"
people:name="Sandra">
<people:sibling rdf:resource="http://www.xulplanet.com/rdf/people/Kevin"/>
</rdf:Description>
<rdf:Description rdf:about="http://www.xulplanet.com/rdf/people/Kevin"
people:name="Kevin"/>
Il secondo tag Description è usato per dichiarare un'altra
tripla, stavolta per un'altra risorsa soggetto, dal momento che
l'attributo about è diverso. C'è un'altra forma che puoi
comunque usare, visto che probabilmente vuoi descrivere due persone in
relazione nello stesso file. Invece di usare scrivere la seconda
descrizione separata, possiamo metterla direttamente nel tag sibling
<rdf:Description rdf:about="http://www.xulplanet.com/rdf/people/Sandra"
people:name="Sandra">
<people:sibling>
<rdf:Description rdf:about="http://www.xulplanet.com/rdf/people/Kevin"
people:name="Kevin"/>
</people:sibling>
</rdf:Description>
Questo produrrà lo stesso insieme di triple. Comunque invece
del fratello che punta alla risorsa, la quale è descritta
separatamente, include direttamente la descrizione della risorsa. Non
avremo più bisogno dell'attributo resource, visto che la risorsa
è specificata nell'attributo about.
Puoi continuare a nidificare informazioni in altri elementi ad ogni livello. Comunque, non devi necessariamente farlo. A volte, puoi preferire descriverli separatamente. Dal momento che l'ordine delle triple non ha importanza in RDF, puoi specificare liberamente nella maniera più consona al tipo di dati. Per esempio, per descrivere le persone, probabilmente metteresti Kevin separato se avessi molte altre triple addizionali per descriverlo, per migliorare la leggibilità.
Forse ti chiedi che cosa accadrebbe se avessi tralasciato l'attributo about sopra, come in questo frammento:
<rdf:Description rdf:about="http://www.xulplanet.com/rdf/people/Sandra">
<people:sibling>
<rdf:Description people:name="Kevin"/>
</people:sibling>
</rdf:Description>
Questo produrrà la stessa struttura grafica, Kevin
sarà il fratello di Sandra, ma Kevin non avrà un URI.
Questo crea un nodo anonimo, che non ha un URI, ma è comunque un
nodo nel grafico RDF. Quando usi un'API RDF, puoi ottenere una
referenza di un noto attraverso il suo URI, ma potresti non essere in
grado di ottenere un nodo anonimo. Invece avrai bisogno di attraversare
le triple per trovarlo.
Siccome si specifica il tipo di un nodo tramite una tripla, come
tutte le altre informazioni in RDF, puoi usare la stessa forma per
specificare il tipo di nodo. Ecco la tripla che vogliamo memorizzare:
<http://www.xulplanet.com/rdf/people/Sandra> -> rdf:type ->
<http://xmlns.com/wordnet/1.6/Person>
Ecco la tripla nella forma RDF/XML
<?xml version="1.0"?>
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns:people="http://www.xulplanet.com/rdf/people/">
<rdf:Description rdf:about="http://www.xulplanet.com/rdf/people/Sandra"
<rdf:type resource="http://xmlns.com/wordnet/1.6/Person"/>
</rdf:Description>
</rdf:RDF>
Non è diverso dallo specificare qualunque altra tripla. Usiamo il predicato rdf:type e puntiamo al tipo Person. Comunque, siccome i tipi sono usati spesso in RDF, c'è una scorciatoia che puoi prendere.
<?xml version="1.0"?>
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns:wordnet="http://xmlns.com/wordnet/1.6/"
xmlns:people="http://www.xulplanet.com/rdf/people/">
<wordnet:Person rdf:about="http://www.xulplanet.com/rdf/people/Sandra"/>
</rdf:RDF>
Questo ha lo stesso significato, ma è molto più semplice. L'attributo about è ancora presente come prima, ma il tag Description è stato rimpiazzato dal tipo stesso. Lo spazio di nomi 'wordnet' è stato aggiunto al tag RDF. Quando qualificato, questo fa sì che il tag 'wordnet:Person' divenga 'http://xmlns.com/wordnet/1.6/Person', che come noterai è il tipo che vogliamo.
La differenza è che il tag Description è stato
rimpiazzato dal tipo, che è come questa forma verrà
analizzata. Si può ipotizzare che quando vedi un tag con un
elemento about, il tag è il tipo di quella risorsa.
In verità si potrebbe dire che quando si usa un tag Description, significa che il tipo non è conosciuto, o non è importante. Quando vuoi specificare il tipo di risorsa, rimpiazza il tag con forma Description con il tipo di risorsa. Ecco perché i tipi sono sempre risorse, visto che non potresti usare il tag se fossero letterali.
Chiaramente puoi usare la sintassi type anche quando nidifichi le triple:
<wordnet:Person rdf:about="http://www.xulplanet.com/rdf/people/Sandra"
people:name="Sandra">
<people:sibling>
<wordnet:Person rdf:about="http://www.xulplanet.com/rdf/people/Kevin"
people:name="Kevin"/>
</people:sibling>
</wordnet:Person>
Qui indichiamo che sia Sandra che Kevin sono del tipo Person. Una
cosa a cui fare attenzione è che può essere difficile
legggere se usi troppo la nidificazione, visto che può diventare
poco chiaro capire quali tag sono usati come tipi e quali come
predicati. Comunques, si alternano sempre. Nell'esempio sopra, il tag
esterno è un tipo, il tag seguente è un predicato, e ppoi
un tipo. Il tag seguente dovrebbe essere di nuovo un predicto. Questo
concetto viene a volte chiamato striping, a causa dell'alternanza di
tipi e predicati.
Per i tipi di liste incorporati, Seq, Bag e Alt, puoi specificare il tipo nella stessa maniera. Basta rimpiazzare il tag Description o il tag tipo con rdf:Seq (per un tipo Seq).
<rdf:Seq rdf:about="http://www.xulplanet.com/rdf/people/KarensKids"/>
E' come specificare gli altri tipi. Alla risorsa <http://www.xulplanet.com/rdf/people/KarensKids>
viene dato un tipo rdf:Seq. Naturalmente, vorremo aggiungere dei
bambini alla lista di questa risorsa:
<rdf:Seq rdf:about="http://www.xulplanet.com/rdf/people/KarensKids">
<rdf:_1 rdf:resource="http://www.xulplanet.com/rdf/people/Sandra"/>
<rdf:_2 rdf:resource="http://www.xulplanet.com/rdf/people/Kevin"/>
<rdf:_3 rdf:resource="http://www.xulplanet.com/rdf/people/Jack"/>
</rdf:Seq>
Come facciamo con tutte le triple, le aggiungiamo nella risorsa e le
facciamo puntare a tre risorse figlio. Diciamo che Karen abbia 20
figli. Se dopo averlo scritto capissimo di aver fatto un errore e
dimenticato un figlio, avremmo bisogno di inserirlo e rinumerare gli
altri nella lista. Ricorda, che questo non è necessario, dal
momento che si possono saltare i numeri. Comunque, sarebbe insolito da
leggere. RDF/XML fornisce un tag speciale per risolvere questi problemi
<rdf:Seq rdf:about="http://www.xulplanet.com/rdf/people/KarensKids">
<rdf:li rdf:resource="http://www.xulplanet.com/rdf/people/Sandra"/>
<rdf:li rdf:resource="http://www.xulplanet.com/rdf/people/Kevin"/>
<rdf:li rdf:resource="http://www.xulplanet.com/rdf/people/Jack"/>
</rdf:Seq>
Invece di usare i numeri, possiamo usare il tag li, che penserà a mantenere la continuità. Il primo elemento sarà etichettato 1 (più esattamente rdf:_1 some sopra), il secondo 2, il terzo 3. Possiamo inserire un figlio senza spostare gli altri. Questo tag segue un modello simile a quello usato in HTML per le liste.
I tags li non sono usati direttamente come predicati. Se dovessi usare un'API RDF per trovare dati, non troveresti nessun predicato li, sarebbero stati tradotti nella forma numero. Questo tag è usato solo per convenienza quando si scrive RDF in XML.
Nota che il tag li ha un attributo risorsa, come lo avevano diversi esempi prima. Come sempre questo indica che <http://www.xulplanet.com/rdf/people/Sandra>
è l'oggetto della tripla. Come prima, potremmo anche nidificare
gli elementi in questo tag:
<rdf:li>
<wordnet:Person rdf:about="http://www.xulplanet.com/rdf/people/Sandra" people:name="Sandra"/>
</rdf:li>
Questo combina diversi concetti di cui abbiamo parlato. Il figlio target nella lista è ancora la risorsa <http://www.xulplanet.com/rdf/people/Sandra>, ma le è stato dato un nome e un tipo
Questo è un esempio completo della famiglia di Karen:
<?xml version="1.0"?>
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns:wordnet="http://xmlns.com/wordnet/1.6/"
xmlns:people="http://www.xulplanet.com/rdf/people/">
<wordnet:Person rdf:about="http://www.xulplanet.com/rdf/people/Karen" people:name="Karen">
<people:children>
<rdf:Seq rdf:about="http://www.xulplanet.com/rdf/people/KarensKids">
<rdf:li>
<wordnet:Person rdf:about="http://www.xulplanet.com/rdf/people/Sandra" people:name="Sandra"/>
</rdf:li>
<rdf:li>
<wordnet:Person rdf:about="http://www.xulplanet.com/rdf/people/Kevin" people:name="Kevin"/>
</rdf:li>
<rdf:li>
<wordnet:Person rdf:about="http://www.xulplanet.com/rdf/people/Jack" people:name="Jack"/>
</rdf:li>
</rdf:Seq>
</people:children>
</wordnet:Person>
</rdf:RDF>
Questo creerà le triple dalla sezione precedente, insieme ad
alcune altre. Creerà un totale di 13 triple. Un nome per ognuna
delle 4 persone, un tipo per ogni persona, un tipo per la Seq, uno per
ognuno dei tre elementi della lista e uno per il predicato children.
Ci sarebbero altre cose da dire sulla sintassi RDF/XML, ma
questo dovrebbe essere tutto il necessario per una comprensione di base.
Il parser RDF di Mozilla è stato scritto prima del completamento delle specifiche RDF. Perciò ci sono due differenze. La prima è che il parser è un pò più negligente di quanto dovrebbe essere, perciò gli attributi resource e about non devono essere nello spazio di nomi rdf per funzionare. La seconda è che per Seq, Bag e Alt, viene usato il predicato 'rdf:instanceOf' di una precedente bozza, invece di 'rdf:type'. Questo si applica solo ai tipi lista, non agli altri tipi.
Nessuno di questi dovrebbe crearti problemi, comunque, forse volevi esserne a conoscenza.