XML validatie

Uit Yapf

XML kan een complexe informatiestructuur bevatten waarin elementen niet allemaal verplicht zijn. Dit maakt het lastig om te controleren of alles wat in een XML staat er ook in hoort te staan en of alles wat erin moet staan er ook echt in staat. De eerste vorm van validatie van XML ging via DTD's maar dat was beperkt en onhandig en is vervangen door XMLSchema (XSD).

XMLSchema gebruikt XML om de structuur van XML op te geven. Het komt er eigenlijuk op neer dat je de XML nabouwt in XMLSchema en per element aangeeft hoe dat element eruitmoet zien, hoevaak het voor moet komen etc.

De definities van de elementen zijn herbruikbaar, uitbreidbaar en opdeelbaar in aparte XSD bestanden waardoor het allemaal erg flexibel en overzichtelijk wordt.

My First Schema

<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified" attributeFormDefault="unqualified">
  <xs:element name="data" />
</xs:schema>

Dit schema valideert de XML-tag data en stelt verder geen andere eisen dan dat deze tag bestaat.

Om de inhoud van een element te definieren kun je er een type aan toekennen. Dit kan op twee manieren, met het type attribuut of met een geneste definitie. Het type attribuut verwijst ofwel naar een standaardtype of naar een defnitie van een type elders in het schema.

<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified" attributeFormDefault="unqualified">
  <xs:element name="data" type="xs:string" />
</xs:schema>

Sequence

Alle elementen die voorkomen moeten voorkomen in de volgorde waarin ze in de sequence gedefinieerd worden. ==All== elementen moeten 1x voorkomen, maar de volgorde maakt niet uit.

Choice

De inhoud moet voldoen aan precies één van de definities.

Dit voorbeeld valideert een XML waarin een data tag zit met daarin óf twee keer een element genaamd a óf één element genaamd b'. Dit faalt dus ook als er zowel een a als een b in zit.

<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified" attributeFormDefault="unqualified">
	<xs:element name="data">
		<xs:complexType>
			<xs:choice>
				<xs:element name="a" maxOccurs="2" />
				<xs:element name="b" />
			</xs:choice>
		</xs:complexType>
	</xs:element>
</xs:schema>

Noot: bij choice is het belangrijk om te onthouden dat de gemiddelde XSD parser niet vooruit kan kijken. Dat betekent dat dit niet kan:

<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified" attributeFormDefault="unqualified">
	<xs:element name="data">
		<xs:complexType>
			<xs:choice>
				<xs:sequence>
					<xs:element name="w" />
					<xs:element name="z" />
				</xs:sequence>
				<xs:sequence>
					<xs:element name="w" />
					<xs:element name="q" />
				</xs:sequence>
			</xs:choice>
		</xs:complexType>
	</xs:element>
</xs:schema>

Deze XSD bepaalt dat data moet zijn gevuld met óf de serie w,z óf de serie w,q. Het probleem is nu dat de parser moet kiezen welke van de twee opties hij gaat valideren op het moment dat hij een w tegenkomt. Hij kan niet vooruitkijken dus hij moet de eerste pakken die vraagt om een w. Als de z vervolgens niet bestaat dan faalt de validatie, ook als het tweede element een q was. Dat wist de parser niet van tevoren, hij kan niet vooruitkijken.

Refactoring

Typen uitbreiden

Je kunt een gedefinieerd type uitbreiden door het te gebruiken als de base van een complexContent element binnen een complexType.

<xs:complexType name="mijntype">
  <xs:sequence>
    <xs:element name="standaardelement" type="xs:string"/>
  </xs:sequence>
</xs:complexType>
 
<xs:complexType name="mijntype_uitgebreid">
  <xs:complexContent>
    <xs:extension base="mijntype">
      <xs:sequence>
        <xs:element name="uitgebreid_element" type="xs:string"/>
        <xs:element name="en_nog_een_element" type="xs:string"/>
      </xs:sequence>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Om aan mijntype_uitgebreid te voldoen moet een element nu alle drie de genoemde elementen bevatten.

Opdelen in bestanden

XSD schema's kunnen worden opgedeeld in herbruikbare blokjes die kunnen worden ge-include in andere schema's.

Herbruikbaar blokje:

<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified">
<xs:complexType name="productlist">
  <xs:sequence>
    <xs:element name="product" type="xs:string" maxOccurs="unbounded" />
  </xs:sequence>
</xs:complexType>

Schema waarin het blokje wordt gebruikt.

<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified">
  <!-- Laad het herbruikbare blokje -->
  <xs:include schemaLocation="herbruikbaarblokje.xsd" />
 
  <xs:element name="aanbiedingen" type="productlist" />
</xs:schema>

Elementen

Een element in XSD staat voor een element in XML en beschrijft dan ook de structuur ervan. Een element heeft een bepaald type en dat kan een standaardtype zijn zoals string, integer of datetime, of het kan een complexer type zijn wat subelementen bevat.

Element declaratie

<xs:element name="data" type="xs:string"/>

<xs:element name="data">
</xs:element>

Attributen

Het bestaan van attributen en de waarden ervan, kun je afdwingen met het <xs:attribute /> element.

De waarde kun je opgeven als een vaste waarde, een serie vaste waarden of een bereik.

<!--
Dit elementtype heeft een verplicht attribuut ''categorySetting''
en die moet de waarde ''154'' bevatten om valide te zijn.
-->
<xs:complexType name="A">
  <xs:attribute name="categorySetting" fixed="154" use="required" />
</xs:complexType>
 
<!--
Dit elementtype heeft een verplicht attribuut ''categorySetting''
en diens waarde moet ''154''  of ''201'' bevatten om valide te zijn.
-->
<xs:complexType name="A">
  <xs:attribute name="categorySetting" use="required" >
    <xs:simpleType>
      <xs:restriction base="xs:string">
        <xs:enumeration value="154" />
        <xs:enumeration value="201" />
      </xs:restriction>
    </xs:simpleType>
  </xs:attribute>
</xs:complexType>

Extra tags

Het kan gebeuren dat een XML niet helemaal gevalideerd kan worden omdat er extra tags in staan waarvan je vooraf niet weet wat hun structuur zal zijn. Om de validatie van de rest van het document toch kloppend te krijgen heeft XSD het any element ingevoerd. Hiermee geef je vrij letterlijk aan de parser op dat er op die plek iets zal staan en wat het ook is: het is wel goed zo.

In het volgende element moet een element A staan, gevolgd door een element B. Wat daarna komt is optioneel: any. Noot dat minOccurs op nul staat en maxOccurs op unbounded, dus dit element mag ontbreken of meerdere keren voorkomen. Anders gezegd; vanaf hier maakt het niet meer uit wat er in page staat, het valideert.

Noot ook het attribuut processContents wat hier op skip staat. Als processContent niet op skip staat zal de parser gaan controleren of de inhoud van het onbekende element voldoet aan het schema. Als de inhoud onbekend is kun je het dus niet valideren en zet je processContent op skip.

<xs:element name="page">
  <xs:complexType>
    <xs:sequence>
      <xs:element name="A" type="xs:string" />
      <xs:element name="B" type="xs:string" />
      <xs:any minOccurs="0" maxOccurs="unbounded" processContents="skip" />
    </xs:sequence>
  </xs:complexType>
</xs:element>