Publicatie:Wat is Extensible Markup Language (XML)
| Titel | Wat is XML? (Voorkeurstitel) |
| Locatie | |
| Uitgever | |
| Jaar van uitgave | |
| Rechten | |
| Persistent ID |
Wat is XML?
Extensible Markup Language (XML) is een standaard waarmee je teksten kan voorzien van codes, waardoor ze verwerkt kunnen worden door een computer. XML is in de erfgoedsector voornamelijk gekend als uitwisselingsformaat: bewaarinstellingen die de gegevens uit hun collectiebeheersysteem wensen uit te wisselen met andere computersystemen maken hierbij vaak gebruik van XML. Bovendien wordt XML ook gebruikt voor het publiceren van gegevens op het web en voor het vindbaar maken van gegevens via een zoekmachine.Wat XML aantrekkelijk maakt als uitwisselingsformaat, is zijn vermogen om getransformeerd te worden. XML codes maken het heel eenvoudig om de structuur van gegevens in een XML-document te wijzigen, waardoor je gegevens leesbaar worden voor andere computersystemen. Dat maakt van XML een heel flexibel uitwisselingsformaat. Deze handleiding is gemaakt voor erfgoedmedewerkers die de vraag krijgen om hun catalogi en inventarissen beschikbaar te maken als XML en nog niet vertrouwd zijn met dit uitwisselingsformaat. De handleiding valt uiteen in twee delen. Het eerste deel is erg eenvoudig en maakt je stap voor stap vertrouwd met de beginselen van XML: je leert de structuur van XML-documenten te begrijpen en je leert alles over welgevormde XML. Het tweede deel is technischer en leert je hoe je XML kan valideren en eventueel kan transformeren om je gegevens uitwisselbaar te maken. Wie nog niet vertrouwd is met XML, of enkel geïnteresseerd is in de basisprincipes ervan, begint deze handleiding best vanaf het begin. Wie al wel vertrouwd is met de beginselen van XML, kan het eerste deel overslaan en meteen van start gaan met het tweede deel.
Deel 1
- 1. Extensible Markup Language (XML)
- 2. Elementen, tags en attributen
- 3. XML-verklaring
- 4: Welgevormde XML
Deel 2
- 5: Valide XML
- 6: Document Type Definition (DTD)
- 7: XML Schema
- 8: XML Namespaces
- 9: Standaard XML Schema's
- 10: XML-Transformaties
1: Extensible Markup Language
Extensible Markup Language (XML) is een markeertaal: een computertaal die tekst van aanwijzingen voorziet, waardoor hij door een computer kan worden verwerkt. XML is op dit ogenblik de belangrijkste standaard voor het aanvullen van teksten met meta-informatie: informatie over de informatie in de tekst. XML maakt het mogelijk om een gedetailleerde beschrijving te maken van zowel de structuur als de inhoud van een tekst op een manier die zowel leesbaar is door machines als door de mens.
Naast XML zijn er nog heel wat andere markeertalen in omloop die teksten leesbaar maken voor machines. Standaard:HTML zorgt ervoor dat je tekst leesbaar wordt in een webbrowser. Standaard:SGML is een voorloper van HTML en XML en wordt nog gebruikt in oudere datasets. Standaard:LaTeX is een markeertaal specifiek voor wetenschappelijke publicaties.
Vergelijk de volgende twee voorbeelden:
| originele tekst | tekst in XML |
|---|---|
|
|
Aan de linkerkant zie je een gewoon tekstbestand dat de inhoud weergeeft van een fictieve catalogus. Rechts zie je dezelfde tekst, maar dan aangevuld met XML mark up, aanwijzingen die deze tekst beschrijven en structureren.
Wie vertrouwd is met de bibliotheeksector merkt op dat XML vergelijkbaar is met Standaard:MARC, een markeertaal voor bibliografische records. MARC maakt gebruik van numerieke codes om bibliografische records leesbaar te maken voor machines en ze eenvoudig te transporteren. Hieronder volgt een voorbeeld [1] van een MARC-record:
MARC is een uitwisselingsformaat dat specifiek voor bibliotheekcollecties werd ontwikkeld. Door de ontwikkeling van het web en de wens om ook gegevens van andere types collecties uitwisselbaar te maken, groeide de nood voor een markeertaal die zowel de semantische als formele kenmerken van je gegevens bewaart en waarmee je je gegevens makkelijk op het web kan publiceren.
Vandaag is XML in de erfgoedsector de standaard markeertaal voor de uitwisseling van informatie tussen verschillende computersystemen en voor de publicatie van informatie op het web.
2: Elementen, tags en attributen
XML-documenten verschillen op een aantal punten van gewone tekstdocumenten. Zo bevatten zij een aantal eigenschappen die eigen zijn aan XML. Bekijk het XML-document uit de vorige pagina even opnieuw:
Tags
De structuur en de inhoud wordt in een XML-document weergegeven door middel van <tags>. Tags komen in XML steeds voor in paren: een <begintag> wordt gevolgd door een </eindtag>. Het verschil zie je aan de forwardslash (/) waarmee elke eindtag begint. Tags hebben eerst en vooral een beschrijvende functie: ze geven een inhoudelijke beschrijving van de waarden die ze omsluiten:
<titel>Rum Punch</titel>
en
<auteur>Elmore Leonard</auteur>
waarbij meteen duidelijk is dat Rum Punch de titel van het boek is en Elmore Leonard de auteur ervan. In technische termen stelt men dat "Rum Punch" een instantie is van het concept "titel" , en "Elmore Leonard" een instantie van het concept "auteur".
Elementen
Het geheel van <begintag>, </eindtag> en alles wat er tussen staat noemt men een element. Elementen geven de conceptuele inhoud van je document weer en vormen zo de bouwstenen van je XML-document. Het XML-document uit bovenstaand voorbeeld bevat dus zestien elementen:
1 x <catalogus>waarde</catalogus> 3 x <boek>waarde</boek> 3 x <titel>waarde</titel> 3 x <auteur>waarde</auteur> 3 x <jaar>waarde</jaar> 3 x <prijs>waarde</prijs>
Zo beschrijft het XML-document uit bovenstaand voorbeeld een catalogus die uit drie boeken bestaat en waarvan elk boek een titel, een auteur, een jaar van uitgave en een prijs heeft.
Attributen
Naast tags en waarden kunnen elementen ook attributen bevatten. Die geven extra inhoudelijke informatie die op zich niet in de waarde van het element vervat zit. Attributen bestaan uit een naam, een gelijkheidsteken en een corresponderende waarde. De waarde van elk attribuut staat steeds tussen "dubbele aanhalingstekens". Attributen bevinden zich steeds in de begintag van het element waarover ze informatie geven:
<boek categorie="MISDAAD">
Het XML-document uit bovenstaand voorbeeld bevat één attribuut dat aangeeft tot welke categorie de boeken in de catalogus behoren, namelijk "MISDAAD", "FANTASY" of "CYBERPUNK".
Boomstructuur
In het XML-document uit bovenstaand voorbeeld zijn de waarden die omvat worden door de tags meestal tekstueel van aard: "Rum Punch", "Elmore Leonard", ... . Maar elementen kunnen ook bestaan uit andere elementen. Zo bestaat de waarde die wordt omsloten door de tags <boek> uit vier andere elementen: <titel>, <auteur>, <jaar> en <prijs>:
<catalogus>
<boek>
<titel>waarde</titel>
<auteur>waarde</auteur>
<jaar>waarde</jaar>
<prijs>waarde</prijs>
</boek>
</catalogus>
Deze vier elementen zijn genest of ingebed in het boekelement. Op die manier vormen de elementen een boomstructuur en krijgt het XML-document een zekere hiërarchie.
Helemaal bovenaan de hiërarchie van een XML-document staat een allesomvattend rootelement. In ons voorbeeld is dat het cataloguselement. Het rootelement geeft steeds weer van welke conceptuele inhoud het XML-document een beschrijving is. In ons geval is het de beschrijving van een catalogus. De andere elementen zijn rechtstreeks of onrechtstreeks ingebed in het rootelement: het cataloguselement huist drie boekelementen en elk boekelement huist dan weer een titelelement, een auteurelement, een jaarelement en een prijselement.
Tags hebben dus niet alleen een beschrijvende functie. Naast de waarden die zij omsluiten, staan zij ook in voor de formele structurering ervan. Het zijn immers de tags die door middel van inbedding een bepaalde hiërarchie creëren in het XML-document en die de verhouding van de elementen ten opzichte van elkaar vastleggen.
Zelfbeschrijvend
Kenmerkend voor XML is dat deze markeertaal geen strikt afgebakende set namen bevat voor de tags in een XML-document. De gebruiker is vrij zelf namen te creëren, naargelang de noden van het te beschrijven document. XML-tags zijn dus zelfbeschrijvend. Zo kan een XML-document dat een gedicht beschrijft de tags <gedicht>, <titel>, <auteur>, <strofe> en <vers> bevatten, maar kan een XML-document dat een muziekalbum beschrijft dan weer opgebouwd zijn door middel van de helemaal andere tags <artiest>, <titel>, <jaar>, <tracks> en <nummer>. Datzelfde muziekalbum kan dan weer even goed beschreven en vormgegeven worden door de tags <uitvoerder>, <albumtitel>, <jaartal>, <tracklist> en <track>. De namen die gebruikt worden in de tags kan je volledig zelf kiezen.
Tegenover de vrijheden die XML biedt, staan dan weer een aantal zaken die vereist zijn voor een correct gebruikt van XML, waaronder de Publicatie:XML-verklaring en de criteria voor welgevormde XML. Hoewel XML volledige vrijheid biedt voor het bepalen van de elementen, vereisen catalogi en inventarissen van collecties dat een XML-document een vaste structuur heeft en steeds dezelfde elementen gebruikt. De grammatica van een XML-document kan je vastleggen door middel van een Publicatie:Document Type Definition (DTD) of een Publicatie:XML Schema. Meer daarover lees je in het tweede deel van deze handleiding.
3: XML-verklaring
De XML-verklaring is een verplicht onderdeel van elk XML-document en bevindt zich helemaal bovenaan een dergelijk document. De XML-verklaring is de eerste <tag> in een XML-document die aan het computersysteem meedeelt dat het document dat door de computer ingelezen of verwerkt wordt, een XML-document is.
Een XML-verklaring ziet er als volgt uit:
<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
Naast de naam van de tag - <?xml?> - bevat de XML-verklaring drie attributen:
- version:
Dit attribuut geeft aan welke versie van de markeertaal XML gebruikt wordt. De waarde van dit attribuut is standaard "1.0". - encoding:
Dit attribuut geeft aan welke karakterset gebruikt werd voor het coderen van de waarden in het XML-document. De standaard waarde voor dit attribuut is “Standaard:UTF-8”. Andere mogelijke waarden zijn “UTF-16”, “ISO-10646-UCS-2”, “ISO-10646-UCS-4”, “ISO-8859-1” tot “ISO-8859-9”, “ISO-2022-JP”, “Shift_JIS”, … - standalone:
Dit attribuut is optioneel en verklaart of we al dan niet te maken hebben met een op zichzelf staand XML-document. De standaard waarde voor dit attribuut is "yes" of "no". Op zichzelf staande XML-documenten - standalone="yes" - hebben een interne DTD. Niet op zichzelfstaande XML-documenten - standalone="no" - bevatten een link naar een externe DTD of XSD. Verderop in deze handleiding vind je meer informatie over DTD en XSD.
4: Welgevormde XML
Welgevormdheidscriteria
Om documenten machineleesbaar te maken met behulp van XML moeten ze, naast een Publicatie:XML-verklaring bevatten, ook voldoen aan een reeks welgevormdheidscriteria. Welgevormde XML beantwoordt aan de volgende criteria:
|
|
|
|
|
|
|
|
|
|
|
|
|
|
XML-documenten bewerken
Als een XML-document fouten bevat tegen één van deze criteria, is het niet welgevormd. Als je XML-document niet welgevormd is, kan je in principe gebruik maken van een gewone tekstverwerker om de fouten eruit te halen. Maar de kans dat je op die manier fouten over het hoofd ziet, of net nieuwe fouten maakt, is zeer groot. Daarom is het aangeraden om voor elke wijziging die je aanbrengt in een XML-document, gebruik te maken van een speciaal daarvoor ontwikkelde XML-editor. XML-editors geven een foutmelding telkens je een fout maakt tegen de XML-welgevormdheidscriteria. Op die manier ben je er zeker van dat je XML-document steeds welgevormd blijft. Hieronder vind je enkele nuttige XML-editors:
Ook als je inhoudelijke wijzigingen wil aanbrengen in je XML-document gebruik je best een XML-editor. Hoewel het aangeraden blijft in dat geval de data eerst rechtstreeks te bewerken in je collectiebeheersysteem en vervolgens een nieuwe XML-export te maken.
Welgevormdheid is niet alleen een voorwaarde voor het machineleesbaar maken van XML-documenten; het is ook een voorwaarde om XML-documenten te valideren en te transformeren. Meer over validatie, uitwisselingsstandaarden en transformaties lees je in het tweede deel van deze handleiding.
Opmerking: hier eindigt het eerste deel van deze handleiding. Dat betekent dat je ondertussen vertrouwd zou moeten zijn met de structuur van XML-documenten en met de criteria waaraan ze moeten voldoen alvorens ze welgevormd zijn. Wie doorklikt naar de volgende pagina, komt terecht in het tweede deel van deze handleiding, waar je meer informatie vindt over valide XML, XML-grammatica's (DTD en XML Schema), XML-uitwisselingsstandaarden en XML-transformaties.
Deel 2
Meer XML
Het tweede deel van deze handleiding gaat dieper in op een aantal technische mogelijkheden die XML biedt en hoe je die mogelijkheden kan benutten bij het beheer van je digitale inventaris of catalogus. In de volgende pagina's lees je meer over hoe je de inhoud en structuur van je digitale inventaris consistent kan houden door een XML-document te valideren met behulp van een Publicatie:Document Type Definition (DTD) of een Publicatie:XML Schema; hoe je je digitale inventaris uitwisselbaar kan maken met behulp van XML namespaces en standaard XML Schema's; en hoe je tenslotte de inhoud en structuur van je digitale inventaris kan wijzigen door de XML-documenten te transformeren.
- 5: Valide XML
- 6: Document Type Definition (DTD)
- 7: XML Schema
- 8: XML Namespaces
- 9: Standaard XML Schema's
- 10: XML-Transformaties
5: Valide XML
In deel 1 van deze handleiding werd uitgelegd dat XML zelfbeschrijvend is: je bent vrij om de namen van de tags in je XML-document zelf te kiezen, waardoor je de inhoud en structuur van je document heel nauwkeurig leesbaar kan maken voor een computersysteem. Catalogi en inventarissen hebben echter een strakke formele structuur waarbij elke beschrijving op de zelfde manier is opgebouwd. Wanneer je een inventaris in een XML-document codeert, gebruikt elke beschrijving dezelfde tags en hebben de XML-elementen een vaste volgorde. De grammatica van een in XML gecodeerde catalogus of inventaris wordt dus bij voorkeur a priori vastgelegd.
DTD & XML Schema
De grammatica van een XML-document kan je op twee manieren vastleggen: met een Publicatie:Document Type Definition (DTD) of met een Publicatie:XML Schema. Beide standaarden zijn computertalen die a priori de namen en de structuur van de elementen bepalen waaruit je XML-document kan bestaan. De code van een XML Schema wordt steeds opgeslagen in een apart bestand met de extensie .xsd. DTD's kunnen opgeslagen worden in een apart bestand (externe DTD), maar je kan de code van een DTD ook rechtstreeks opnemen in je XML-document (interne DTD). XML-documenten waarvan de grammatica vastgelegd wordt in een externe DTD's of XML Schema's bevatten steeds een link naar het betrokken DTD- of XSD-bestand. Deze link vind je terug bovenaan het XML-document, net onder de XML-verklaring . XML-documenten kunnen maar één grammatica hebben; ofwel een DTD, ofwel een XML Schema, maar niet allebei.
Opmerking: hoewel DTD nog steeds gebruikt wordt, is het een verouderde standaard aan het worden. Hij wordt doorgaans enkel nog gebruikt om de grammatica van XML-documenten met een eenvoudige structuur vast te leggen. De grammatica van XML-documenten met een complexe structuur wordt het best uitgelijnd in een XML Schema, een complexere en meer flexibele standaard. Ook transformaties van XML-documenten zijn enkel mogelijk door middel van een XML Schema.
Valideren
Valideren is controleren of de namen en de structuur van het XML-document conform zijn aan de grammatica waarnaar ze verwijzen. Valide XML beantwoordt aan twee voorwaarden:
- Je XML-document is welgevormd, d.i. het bevat geen fouten tegen de welgevormdheidscriteria uitgelijnd op de pagina Publicatie:Welgevormde XML.
- Je XML-document is formeel opgebouwd conform de grammatica uitgelijnd in de Publicatie:Document Type Definition (DTD) of het Publicatie:XML Schema.
Om na te gaan of je XML-document valide is, gebruik je een XML-validator. Een XML-validator controleert of je XML-document al dan niet welgevormd is en opgebouwd is conform de grammatica uitgelijnd in de DTD of het XML Schema waarnaar het document verwijst.
De meeste XML-editors bevatten standaard ook een functie om XML te valideren. Hieronder vind je enkele nuttige XML-editors:
Op het net vind je veel online XML-validators. Hieronder vind je een link naar de XML-validator van het World Wide Web Consortium (W3C):
6: Document Type Definition (DTD)
Document Type Definition (DTD) is de oudste standaard die gebruikt wordt voor het uitlijnen van de grammatica van XML-documenten. De DTD van een XML-document definieert de elementen waaruit het document kan bestaan, op welke plaats ze voorkomen en aan welke kenmerken ze moeten voldoen.
DTD’s zijn opgebouwd volgens een heel eigen syntaxis. Bekijk het XML-document van de vorige pagina's even opnieuw. Links zie je het XML-document, rechts de DTD van dat document:
| Het XML-document: | De DTD: |
|---|---|
|
|
|
DTD’s bestaan uit de volgende elementen:
- een DOCTYPE-verklaring: een DOCTYPE-verklaring bepaalt de naam van het root element van het XML-document. De bovenstaande DTD bepaalt allereerst dat het bijhorende XML-document een catalogus is (DOCTYPE catalogus).
- een elementenlijst: een elementenlijst bepaalt de naam en de formele structuur van alle elementen uit het XML-document. In het voorbeeld hierboven geeft de elementenlijst aan dat de catalogus uit één of meerdere boeken bestaat (boek+), dat van elk boek de titel, de auteur, het jaar en de prijs wordt weergegeven en dat de inhoud van alle titel-, auteur-, jaar- en prijselementen uit gewone karakters bestaat (#PCDATA).
- een optionele attributenlijst: een attributenlijst doet hetzelfde als een elementenlijst, maar voor de attributen. In het voorbeeld hierboven lezen we dat het element <boek> steeds voorzien wordt van het attribuut categorie.
Interne en externe DTDs
XML-bestanden kunnen gebruik maken van een interne of een externe DTD. Bekijk de twee volgende voorbeelden:
| interne DTD | externe DTD |
|---|---|
|
|
Interne DTD’s maken deel uit van het eigenlijke XML-document en vinden we volledig terug net onder de XML-verklaring. In het geval van een externe DTD is er een apart DTD-bestand, waarnaar vanuit het XML-bestand wordt gelinkt. In het XML-bestand wordt dan net onder de XML-verklaring de DOCTYPE-verklaring opgenomen met een link naar het externe DTD-bestand. Dat externe DTD-bestand gaat dus meteen van start met de elementenlijst. In de DOCTYPE-verklaring vinden we in dat geval steeds de locatie van het DTD-bestand terug.
Als het externe DTD-bestand zich op hetzelfde systeem bevindt, linken we het met behulp van de vermelding SYSTEM, gevolgd door de naam van het bestand tussen aanhalingstekens:
<!DOCTYPE catalogus SYSTEM "catalogus.dtd">
Als het externe DTD-bestand zich ergens op het web bevindt, linken we het op gelijkaardige wijze met behulp van de vermelding PUBLIC, gevolgd door een standaardindicator die aangeeft dat het om een extern DTD-bestand gaat en de naam van de URL, allebei tussen aanhalingstekens:
<!DOCTYPE catalogus PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.projectcest.be/catalogus.dtd">
DTD’s zijn een vrij eenvoudige manier om de inhoud en de structuur van XML-documenten vast te leggen. Toch wordt deze standaard steeds minder vaak gebruikt. Wanneer je complexere documenten, zoals bijvoorbeeld archiefinventarissen met complexe hiërarchische beschrijvingen wil weergeven in XML, zal je al gauw op de beperkingen van een DTD stoten. Om die beperkingen te verhelpen, zijn XML Schema's in het leven geroepen. Meer daarover lees je op de volgende pagina.
7: XML Schema
Een XML Schema is vergelijkbaar met een externe DTD, maar maakt gebruik van een specifieke XML-syntaxis om de naam en de structuur van de elementen vast te leggen. XML-schema's hebben dezelfde functie als DTD's - het vastleggen van de inhoud en de structuur van XML-documenten -, maar bieden heel wat extra mogelijkheden.
- XML Schema's hebben een syntaxis die toegespitst is op het valideren van documenten met een complexe structuur. Dit maakt ze bij uitstek geschikt voor het valideren van complexe inventarissen en catalogi.
- XML Schema's bieden een brede waaier aan datatypes voor de XML-elementen. Datatypes bepalen welk type waarden het XML-element kan bevatten en welke bewerkingen erop uitgevoerd kunnen worden.
- XML Schema’s bieden ondersteuning voor het transformeren van XML-documenten: het omvormen van de structuur van een XML-document.
- XML Schema's bieden ondersteuning voor XML namespaces. XML Namespaces zijn een eenvoudige manier om in verschillende XML-documenten de XML-elementen en -attributen te voorzien van een unieke naam. Verder in deze handleiding vind je meer informatie over Publicatie:XML Namespaces.
XML Schema syntax
XML Schema’s leggen de inhoud en structuur van XML-documenten vast, maar ze zijn zelf ook volledig opgebouwd als een XML-document met een heel specifieke inhoud en structuur. Bekijk even opnieuw het vertrouwde XML-document en het bijhorende XML Schema:
| Het originele XML-document | Het XML Schema |
|---|---|
|
|
Basiselementen
Een XML Schema maakt gebruik van de volgende elementen voor het bepalen van de grammatica van een XML-document:
- Net als XML-documenten openen XML Schema's met een XML-verklaring die de XML-versie (version) en de gebruikte karakterset (encoding) definieert.
- Het eigenlijke schema opent vervolgens met een allesomvattend schema-element (<xs:schema>), het root-element van ieder XML Schema. De begintag bevat een attribuut dat de standaard namespace van het XML Schema bepaalt (xmlns:xs="http://www.w3.org/2001/XMLSchema"), wat betekent dat alle elementnamen in dit document ontleend worden aan de "XML Schema namespace" en worden vooraf gegaan door het prefix "xs:". Dit attribuut doet weinig meer dan bepalen dat dit XML-document geïnterpreteerd moet worden als een XML Schema. Verder in deze handleiding vind je meer informatie over Publicatie:XML Namespaces.
- Net als de DTD’s beschrijven XML Schema’s de grammatica van XML-documenten. Om de elementen van het XML-document te bepalen gebruikt XML Schema het standaard element <xs:element>. De naam van het element wordt opgenomen als een attribuut: <xs:element name="catalogus">.
Hiërarchie
Omdat XML Schema gebruik maakt van XML, wordt de hiërarchie van de elementen in een XML-document weergegeven door inbedding van de elementen. Op het hoogste niveau vinden we in het voorbeeld hierboven het element <catalogus>, waarbinnen de rest van de elementen ingebed is:
- Het complex-element (<xs:complexType>) verklaart dat <catalogus> een complex element is, wat wil zeggen dat het nog andere elementen en/of attributen bevat. Dat is zo in het geval van het originele XML-document: <catalogus> omvat <boek>. Vervolgens is <boek> ook een complex element omdat het respectievelijk <titel>, <auteur>, <jaar> en <prijs> omvat. Een simple-element (<xs:simpleType>) bevat daarentegen geen andere elementen en/of attributen.
- Het sequence-element (<xs:sequence>) verklaart dat alle subelementen van het moederelement in een vaste volgorde moeten voorkomen. Die volgorde wordt bepaald door de volgorde waarin de elementnamen zijn ingebed in het sequence-element.
Het voorbeeld XML Schema bovenaan de pagina bepaalt dat het root-element van het XML-document <catalogus> is, dat dit element andere elementen bevat (<xs:complexType>) en dat die elementen in een bepaalde volgorde moeten voorkomen (<xs:sequence>). Vervolgens bepaalt het XML Schema dat in <catalogus> het element <boek> is ingebed. Ook dit element kan andere elementen bevatten volgens een bepaalde volgorde.
Het element <boek> kan vier elementen bevatten in de volgorde <titel>, <auteur>, <jaar> en <prijs>.
Datatypes
Naast de naam van de elementen geeft het schema ook het datatype (bvb. type="string") van hun inhoud weer.
- De inhoud van de elementen <titel> en <auteur> zijn van het type string, wat wil zeggen dat hij uit gewone karakters bestaat.
- De inhoud van <jaar> en <prijs> is van numerieke aard. Het datatype decimal laat komma’s toe. Het datatype integer doet dat niet.
Attributen
Nadat alle elementen die kunnen voorkomen in <catalogus> opgesomd zijn, bepaalt het XML Schema de attributen van het catalogus-element
- Het attribuut categorie is ingebed in <xs:element name="catalogus"> door middel van het element <xs:attribute>. Het schema bepaalt dat het attribuut van het datatype string is en dat het verplicht voorkomt.
Uitwisselbaarheid
Met DTD's en XML Schema's kan je de inhoud en structuur van een XML-document vastleggen. Op die manier zorg je ervoor dat je digitale inventaris inhoudelijk en formeel consistent blijft en dat computersystemen je data steeds correct kunnen interpreteren.
Dat is vooral nuttig wanneer de data uit je digitale inventaris wordt uitgewisseld tussen verschillende computersystemen. Dat kan binnen je eigen organisatie gebeuren, bijvoorbeeld wanneer je data uit je collectiemanagementsysteem uitwisselt met het contentmanagementsysteem van je website. Maar het is vooral nuttig wanneer je data wil uitwisselt met externe computersystemen, zoals zoekmachines en websites van andere organisaties waarop je digitale collectie terug te vinden is. Om dit mogelijk te maken zal je afspraken moeten maken met die organisaties over de grammatica die je gebruikt om je data door beide systemen te laten lezen. Om die afspraken zo eenvoudig mogelijk te maken en je data proactief voor zoveel mogelijk computersystemen leesbaar te maken, maak je best gebruik van standaard grammatica's die het makkelijk maken om de informatie uit jouw systeem te mappen naar het systeem van de andere organisatie.
Er zijn twee manieren om het mappen van XML-elementen van het ene systeem naar het andere te vergemakkelijken:
- het gebruik van standaard namen voor XML-tags. Op die manier kunnen verschillende systemen makkelijk de inhoud van XML-elementen interpreteren. In de praktijk kan je standaard namen voor XML-elementen toepassen door gebruik te maken van XML namespaces (zie volgende pagina).
- het gebruik van standaard XML Schema's. Op die manier kunnen verschillende systemen niet alleen de namen van XML-elementen, maar ook de structuur van een XML-document herkennen.
Op de volgende pagina's vind je meer informatie over XML namespaces en standaard XML Schema's en hoe je die kan gebruiken om je digitale inventaris uitwisselbaar te maken.
8: XML Namespaces
Een eenvoudige manier om XML-elementen en -attributen op een eenduidige manier door een computer te laten identificeren, is gebruik maken XML-namespaces. XML-namespaces zijn verzamelingen van "namen" voor XML-elementen die eenduidig identificeerbaar gemaakt worden door die namen op te nemen in een Standaard:URI.
De naam
"boek"
wordt in een namespace bijvoorbeeld aangeduid met:
"http://www.projectcest.be/catalogus/boek”
Door de elementen in een namespace te publiceren, kunnen deze elementen gedeeld worden door verschillende computersystemen en digitale inventarissen en wordt de data in digitale inventarissen makkelijk uitwisselbaar.
Homonymie
XML-namespaces werden aanvankelijk ontwikkeld als een oplossing voor het probleem van homonieme XML-elementen. Stel dat je in eenzelfde XML-document de beschrijving van een roman en een stel speelkaarten identificeert met de tag <boek>, zoals in het volgende voorbeeld:
De tag (<boek>) bevat in dit voorbeeld uiteenlopende XML-elementen met een heel andere conceptuele inhoud. Een computersysteem wordt in verwarring gebracht omdat het een beschrijving van een roman ontvangt, terwijl het een beschrijving van een stel speelkaarten verwacht. Het computersysteem zal je data dus niet correct kunnen lezen (interpreteren), presenteren en verwerken.
Een manier om een computersysteem onderscheid te laten maken tussen beide "boek"-elementen is de naam op te nemen in een Standaard:URI, bijvoorbeeld:
Het eerste deel van de URI is de identifier voor de namespace: http://www.projectcest.be/kaart vertelt de computer dat deze namespace de verzameling is van alle namen waarmee de organisatie "CEST" speelkaarten beschrijft. http://www.projectcest.be/catalogus is een namespace van dezelfde organisatie die namen bevat om boeken te beschrijven. Daarna volgt de naam van het specifieke element. In dit voorbeeld is dat dus "boek". Door URI's te gebruiken in plaats van enkel de naam voor het element, kan een computer onderscheid maken tussen een boek dat een roman beschrijft en een boek dat speelkaarten beschrijft.
Prefix
Om niet steeds de volledige URI op te nemen in een XML-tag, maken XML-documenten gebruik van een prefix waaraan de identifier van de namespaces wordt gekoppeld. Bekijk het volgende voorbeeld:
Merk op hoe de elementen die de roman beschrijven een prefix "cat:" bevatten en de elementen die de speelkaart beschrijven een prefix "bo:". Bovendien wordt de identifier van de namespace vastgelegd door het attribuut "xmlns:prefix" in de moedertag van de beschrijving: het prefix “cat:” is gekoppeld aan de URI “http://www.projectcest.be/catalogus”, het prefix “bo” is gekoppeld aan de URI “http://www.projectcest.be/kaart”.
De keuze van de prefixen en de URI's voor de identificatie van de namespace is volledig vrij. Het staat de maker van een XML-document vrij om de prefix van de namespace te veranderen. Ook voor het maken van URI's heb je de volledige vrijheid. Ze dienen enkel om namen van XML-elementen formeel te laten identificeren door een computersysteem. Als je de URI's uit bovenstaand voorbeeld klikt, leiden ze naar onbestaande pagina's.
Standaard Namespaces
Om je data uitwisselbaar te maken, moet de namespace van je data natuurlijk wel bekend zijn bij andere computersystemen. Dat kan door je namespace op het web te publiceren of, nog beter, gebruik te maken van standaard namespaces. Vaak zijn de grote bewaarinstellingen binnen een bepaalde sector hierin richtinggevend. De Library of Congress beheert bijvoorbeeld een reeks standaarden voor de uitwisseling van data die elk hun eigen namespace hebben (zie bijvoorbeeld Standaard:MODS en Standaard:EAD). Deze namespaces hebben een standaard namespace identifier en een standaard prefix waardoor je data meteen leesbaar is voor computersystemen die bijvoorbeeld de standaard MODS en EAD implementeren.
Het bekendste voorbeeld van een XML-namespace is de Dublin Core namespace (prefix: dc). De Dublin Core namespace wordt gebruikt voor de identificatie en beschrijving van resources die beschikbaar worden gemaakt op het internet. Ook wanneer je digitale representaties van je collectieobjecten op het web publiceert, vragen zoekmachines vaak om de bijhorende metadata beschikbaar te maken als Dublin Core. Dit betekent dat je (een selectie van) de data uit je collectiebeheersysteem eerst moet mappen naar een XML-document met elementen ontleend aan de Dublin Core namespace, vooraleer je de data kan uitwisselen met de zoekmachine. Het bekendste voorbeeld van een dergelijke zoekmachine is Europeana. Europeana is een Europese zoekmachine voor cultureel erfgoed die de data over cultureel erfgoed uitwisselt met behulp van Dublin Core elementen.
9: Standaard XML Schema's
Vetgedrukte tekst Vaak is het delen van namen van elementen niet voldoende om de data uit je inventaris correct te interpreteren. Dit geldt vooral voor inventarissen waarin de beschreven objecten hiërarchisch geordend zijn. Dit is bijvoorbeeld het geval voor archiefinventarissen die gebruik maken van het multi-level description principe ontleend aan Standaard:ISAD(G) of voor bibliotheekcatalogi die gebruik maken van de Standaard:FRBR-entiteiten work-expression-manifestation-item. Voor deze inventarissen is een standaard namespace niet voldoende, maar gebruik je best een standaard XML Schema dat ook de structuur van de data vastlegt.
In een aantal domeinen in de erfgoedsector is er een groeiende consensus rond het gebruik van standaard uitwisselingsformaten voor de uitwisseling van data tussen collectieinventarissen. Dit maakt het mogelijk om op grote schaal data tussen collecties uit te wisselen en zo een groot aantal collecties doorzoekbaar te maken via eenzelfde online portaal. Om geen afbreuk te doen aan de eigenheid van de verschillende soorten mediaresources, worden domein-specifieke XML-Schema's ontwikkeld die de mogelijkheid bieden om je data zeer gedetailleerd te beschrijven. De belangrijkste datastructuren voor domeinspecifieke standaard XML-Schema's zijn:
- Standaard:MODS en MARCXML voor bibliotheken
- Standaard:EAD voor archieven
- Standaard:LIDO voor musea
Naast domeinspecifieke XML Schema's zijn er ook standaard XML-Schema's die alle soorten media resources proberen te vatten. Het meest verspreide grensoverschrijdende XML-schema is Dublin Core (zie ook Dublin Core namespace). Het grote voordeel van Dublin Core is dat het XML-Schema zowat alle bestaande mediaresources van metadata kan voorzien. Het grote nadeel is dan weer dat het schema zeer beperkt is: het kan alle mediaresources beschrijven, maar geen enkel in detail.
Daarnaast bestaan er ook specifieke uitwisselingsstandaarden voor data over digitale representaties:
- Standaard:PREMIS is een XML Schema met uitgebreide mogelijkheden voor het beschrijven van administratieve en structurele metadata over digitale representaties.
- Standaard:ALTO is een XML-Schema voor administratieve en structurele data over documenten die geproduceerd zijn door Optical Character Recognition (OCR).
Opmerking: Het is belangrijk om de aandacht te vestigen op het feit dat deze XML Schema's ontwikkeld werden voor het uitwisselen van data over objecten; niet voor het documenteren van data over objecten (bv. het opnemen van informatie in een collectiebeheersysteem). De hierboven vermelde standaarden bevatten vooral beschrijvende data, die het object identificeren en documenteren, en een selectie administratieve data, die nodig is voor de correcte uitwisseling van de data (rechten, relaties). Voor het beheer van collecties zijn administratieve data nodig die je niet met iemand buiten je organisatie wil delen (standplaatsen, gegevens over verwerving, conditie en conservatierapporten). De gegevens van je digitale inventaris die je in je collectiebeheersysteem bewaard zijn dus vaak veel uitgebreider dan de data die je wil delen met andere computersystemen.
Daarom is het belangrijk om de exportmogelijkheden van je collectiebeheersysteem te bekijken en te onderzoeken of je software de data uit je systeem makkelijk kan exporteren naar een standaard uitwisselingsformaat. In het CEST software register vind je een overzicht van softwareprogramma's voor collectiebeheer en de uitwisselingsstandaarden die ze ondersteunen.
Wanneer je collectiebeheersysteem je data niet in een standaard uitwisselingsformaat kan exporteren, is het noodzakelijk om je data van een XML-document met een softwarespecifiek formaat naar een standaardformaat te mappen. XML biedt een aantal mogelijkheden om de structuur van XML-documenten op eenvoudige wijze te transformeren. Hoe dat in zijn werk gaat, lees je op de volgende pagina.
10: XML-transformaties
XML-transformaties worden mogelijk gemaakt door middel van EXtensible Stylesheet Language (Standaard:XSL), een XML-gebaseerde opmaaktaal speciaal ontwikkeld voor de opmaak en transformatie van XML-documenten. XSL bestaat uit drie onderdelen:
- XSLT (XSL Transformations): een programmeertaal gebruikt voor de transformatie van XML-documenten.
- XPath (XML Path Language): een taal die gebruikt wordt om te navigeren in XML-documenten.
- XML-FO (XML Formatting Objects): een vocabularium waarmee termen/definities worden vastgelegd.
Het transformeren van XML-documenten gebeurt door middel van XSLT. XSLT brengt geen wijzigingen aan in het originele document, maar creëert een nieuw document op basis van de inhoud van het origineel. Eigen aan XSLT is dat je het formaat van de output zelf kan kiezen. Zo kan het nieuwe document ook een XML-document zijn, maar je kan er ook voor kiezen om XSLT je bron(XML)document te laten transformeren naar bijvoorbeeld een Standaard:HTML- of een Standaard:XHTML-document.
XSLT laat je toe elementen en attributen uit XML-documenten te verwijderen, of er net nieuwe aan toe te voegen. Bovendien kan je XSLT ook gebruiken om bestaande elementen van plaats te veranderen, of te verbergen, zodat ze bijvoorbeeld niet getoond worden in een browser.
XSLT maakt gebruik van XPath om gericht op zoek te gaan naar specifieke elementen en attributen uit je XML-document. XPath gaat op zoek naar die stukken van het XML-brondocument die overeen komen met een vooraf gedefinieerde XSL Style Sheet. Wanneer een match gevonden is, zorgt XSLT ervoor dat het stuk van het brondocument dat overeenkomt met de stylesheet, getransformeerd wordt naar het resultaatdocument. De transformatie van het ene XML-document naar een ander heet een mapping.
In wat volgt, worden de basisprincipes van XSLT en XPath duidelijk gemaakt aan de hand van een concreet voorbeeld: we mappen de XML-voorbeeldcatalogus uit deze handleiding door middel van een XSL Style Sheet naar het Dublin Core metadataschema. Wie op zoek is naar een volledige uitleg van alle functionaliteiten van XSLT en XPath, raadpleegt best de XSLT Tutorial van het W3C.
De stylesheet die ervoor zorgt dat de XML-catalogus gemapt wordt naar het Dublin Core metadataschema, ziet er als volgt uit:
|
Op zich kan je de stylesheet lezen zoals elk ander XML-document. De stylesheet gaat van start met een XSL Style Sheetverklaring: een XML-verklaring, gevolgd door het root element van de stylesheet, <xsl:stylesheet>. De begintag van dat element bevat drie attributen: version, een link naar de XSL-namespace (xmlns:xsl) en – omdat we een mapping maken naar het Dublin Core metadataschema – een link naar de Dublin Core namespace (xmlns:dc).
Ingebed in het stylesheetelement, zit <xsl:template>. Dat element bepaalt hoe het uiteindelijke resultaatdocument er zal uitzien. De begintag van het template-element bevat één attribuut: match. De waarde van dat attribuut is "/", wat ervoor zorgt dat de template wordt gelinkt aan de root van het brondocument: <catalogus>.
Het template-element is een mengeling van vertrouwde XML, aangevuld met een aantal typische XSL-elementen die gebruik maken van XPath . Het resultaatdocument zal – analoog aan het brondocument - uiteindelijk de volgende structuur hebben:
|
Daarboven bestaat onze stylesheet uit een aantal typische XSL-elementen, die gebruik maken van XPath:
- <xsl:value-of select=”…”>: extraheert een bepaalde waarde uit het brondocument, en voegt die toe aan het resultaatdocument. XPath zorgt ervoor dat de waarde van “titel” terecht komt in het “dc:title”-element, de waarde van “auteur” in het “dc:creator”-element, de waarde van “jaar” in het “dc:date”-element en de waarde van het attribuut “categorie” in het “dc:subject”-element. Opgelet, om de waarde gekoppeld aan een attribuut te extraheren, laat je de naam van het attribuut vooraf gaan door “@”.
- <xsl:for-each select=”catalogus/boek”>: zorgt ervoor dat XPath de bovenstaande bewerkingen uitvoert voor elk boek van de catalogus uit het brondocument. Merk op hoe dat element het “boek”-element omsluit.
Om de stylesheet te gebruiken en het brondocument te transformeren, heb je een XML-editor nodig. Het resultaat van de transformatie ziet er als volgt uit:
|
![[1]](http://ihome.ust.hk/~lblkt/libauto/marc21.jpg){kind=link}