XML SchemaXML Schema, abgekürzt XSD (XML Schema Definition), ist eine Empfehlung des W3C zum Definieren von Strukturen für XML-Dokumente. Anders als bei den klassischen XML-DTDs wird die Struktur in Form eines XML-Dokuments beschrieben. Darüber hinaus wird eine große Anzahl von Datentypen unterstützt. XML Schema beschreibt in einer komplexen Schemasprache Datentypen, einzelne XML-Schema-Instanzen (Dokumente) und Gruppen solcher Instanzen. Ein konkretes XML-Schema wird auch als eine XSD (XML Schema Definition) bezeichnet und hat als Datei üblicherweise die Endung .xsd. Im Gegensatz zu DTDs kann bei Verwendung von XML-Schemata zwischen dem Namen des XML-Typs und dem in der Instanz verwendeten Namen des XML-Tags unterschieden werden. Neben XML Schema gibt es weitere Konzepte zur Definition von XML-Strukturen, wie RELAX NG oder Schematron. Auch DTD als Normbestandteil von XML selbst kann verwendet werden. DatentypenXML Schema unterscheidet zwischen einfachen (atomaren) Datentypen und komplexen Datentypen. Der Begriff Typ bezeichnet im nachfolgenden Text jeweils die abstrakte Spezifikation der Struktur eines Abschnitts innerhalb eines XML-Dokumentes. Datentypen in XML Schema werden klassifiziert in eingebaute bzw. vordefinierte (built-in) und benutzerdefinierte (user defined) Datentypen. In der Spezifikation des W3C für XML Schema sind 19 voreingestellte primitive Datentypen (z. B. boolean, string, float, date und NOTATION) und weitere 25 davon abgeleitete primitive Datentypen (wie ID und integer) definiert. Einfache TypenXML Schema stellt einige grundlegende atomare Datentypen bereit. Die atomaren Datentypen enthalten die „klassischen“ Typen, wie sie zum Teil auch in anderen Typsystemen (z. B. C, Java oder SQL) spezifiziert sind:
Hinzu kommen weitere XML-spezifische atomare Typen, unter anderem:
Einfache XML-Datentypen dürfen weder XML-Kindelemente enthalten noch XML-Attribute besitzen. Außer den atomaren Datentypen gehören Listen und Unions (bestehend aus atomaren Elementen und Listen) zu den einfachen Typen:
<xs:simpleType name="monatInt">
<xs:restriction base="xs:integer">
<xs:minInclusive value="1"/>
<xs:maxInclusive value="12"/>
</xs:restriction>
</xs:simpleType>
<xs:simpleType name="monate">
<xs:list itemType="monatInt"/>
</xs:simpleType>
Eine Instanz des neuen Typs könnte wie folgt aussehen: <monate>
1 2 3 4 5 6 7 8 9 10 11 12
</monate>
Die einzelnen Elemente einer Liste werden durch Leerraum (hier: Leerzeichen) getrennt.
Ein neuer Typ wird als Vereinigungsmenge bereits bestehender Typen definiert. Jede Instanz wählt dann ihren Typ aus dieser Menge.
Das nachfolgende Beispiel definiert einen weiteren Typ <xs:simpleType name="monatsname">
<xs:restriction base="xs:string">
<xs:enumeration value="Jan"/>
<xs:enumeration value="Feb"/>
<xs:enumeration value="Mär"/>
<!-- und so weiter … -->
</xs:restriction>
</xs:simpleType>
<xs:simpleType name="monat">
<xs:union memberTypes="monatsname monatInt"/>
</xs:simpleType>
XML-Elemente vom Typ <monat>Jan</monat>
<monat>2</monat>
Komplexe TypenIn Ergänzung zu den einfachen Typen bieten komplexe XML-Datentypdefinitionen die Möglichkeit, Elementenstrukturen zusammenhängend zu definieren. Solche Strukturen können weitere Elemente und Attribute beinhalten. Das folgende Beispiel definiert einen neuen Typ <xs:complexType name="pc-Typ">
<xs:sequence>
<xs:element name="name" type="xs:string"/>
<xs:element name="hersteller" type="xs:string"/>
<xs:element name="prozessor" type="xs:string"/>
<xs:element name="mhz" type="xs:integer" minOccurs="0"/>
<xs:element name="kommentar" type="xs:string" minOccurs="0" maxOccurs="unbounded"/>
</xs:sequence>
<xs:attribute name="id" type="xs:integer"/>
</xs:complexType>
Die Möglichkeiten zur Definition komplexer Typen sollen hier nur exemplarisch erläutert werden. Der interessierte Leser sei auf die unten angegebenen Links zu den Seiten des W3C verwiesen. Die Kindelemente eines komplexen Typs können auf drei unterschiedliche Arten kombiniert werden:
<xs:complexType name="computer">
<xs:choice>
<xs:element name="desktop" type="pc-Typ"/>
<xs:element name="laptop" type="laptop-Typ"/>
</xs:choice>
</xs:complexType>
Beliebiger InhaltXML-Elemente mit beliebigem Inhalt lassen sich mittels des Basistyps <xs:element name="kommentar" type="xs:anyType"/>
Sollen in dem Inhalt Text und Tags in beliebiger Reihenfolge vorkommen können, muss der Wert für das Attribut "mixed" auf "true" gesetzt werden: <xs:element name="tagname">
<xs:complexType mixed="true">
<xs:sequence>
<xs:element minOccurs="0" maxOccurs="unbounded" name="child" type="xs:integer"/>
<!-- Weitere Elemente … -->
</xs:sequence>
</xs:complexType>
</xs:element>
Leere ElementeVon leeren XML-Elementen spricht man, wenn das jeweilige Element aus nur einem einzelnen XML-Tag besteht und keine weiteren XML-Elemente oder Text umschließt (z. B. der XHTML-Zeilenumbruch: Ableitung neuer TypenNeue Datentypen lassen sich zum einen durch die Definition eines neuen Typs erstellen (siehe vorheriger Abschnitt) oder durch die Ableitung eines neuen Typs aus bereits bestehenden. Bei der Ableitung eines neuen Typs handelt es sich nicht um eine Vererbung im Sinne der Objektorientierung, da keine Eigenschaften vergleichbar den Methoden oder Attribute objektorientierter Klassen vererbt werden. Vielmehr handelt es sich hier um die Wiederverwendung bestehender Typdefinitionen. Dementsprechend ist bei der Ableitung neuer Typen auch keine implizite Substituierbarkeit gegeben, wie sie in anderen Typsystemen üblich ist (explizite Typumwandlungen sind jedoch möglich). Die Ableitung eines neuen Typs kann auf zweierlei Arten erfolgen: Erweiterung oder Einschränkung. Erweiterung eines TypsDie Erweiterung eines bisherigen Typs (engl. extension) um weitere Eigenschaften, d. h. neue Elemente oder Attribute werden hinzugefügt.
Im folgenden Beispiel wird der oben definierte Typ <xs:complexType name="myPC-Typ">
<xs:complexContent>
<xs:extension base="pc-Typ">
<xs:sequence>
<xs:element name="ram" type="xs:integer"/>
</xs:sequence>
</xs:extension>
</xs:complexContent>
</xs:complexType>
Der neu definierte XML-Typ Einschränkung eines TypsDurch Einschränkung bereits bestehender Typen (engl. restriction) lassen sich ebenfalls neue Definitionen ableiten. Zu diesem Zweck müssen alle Elementdefinitionen des Basistyps wiederholt werden, verändert um die jeweiligen restriktiveren Einschränkungen. Im folgenden Beispiel wird ein neuer Typ <xs:complexType name="myPC2-Typ">
<xs:complexContent>
<xs:restriction base="pc-Typ">
<xs:sequence>
<xs:element name="name" type="xs:string"/>
<xs:element name="hersteller" type="xs:string"/>
<xs:element name="prozessor" type="xs:string"/>
<xs:element name="mhz" type="xs:integer" minOccurs="0"/>
<xs:element name="kommentar" type="xs:string" minOccurs="0" maxOccurs="1"/>
</xs:sequence>
</xs:restriction>
</xs:complexContent>
</xs:complexType>
Zusätzlich zu der Einschränkung komplexer Typen ist es auch möglich, neue Typen als Einschränkung einfacher Typen zu definieren. Ein Beispiel für eine solche Definition befindet sich bereits im Abschnitt zu den einfachen Typen. Ein neuer Typ
Die folgenden Beispiele veranschaulichen die Verwendung dieser Komponenten:
<xs:simpleType name="celsiusKörperTemp">
<xs:restriction base="xs:decimal">
<xs:totalDigits value="3"/>
<xs:fractionDigits value="1"/>
<xs:minInclusive value="35.0"/>
<xs:maxInclusive value="42.5"/>
</xs:restriction>
</xs:simpleType>
<xs:simpleType name="plz">
<xs:restriction base="xs:string">
<xs:pattern value="(D )?[0-9]{5}"/>
</xs:restriction>
</xs:simpleType>
<xs:simpleType name="size">
<xs:restriction base="xs:string">
<xs:enumeration value="XS"/>
<xs:enumeration value="S"/>
<xs:enumeration value="M"/>
<xs:enumeration value="L"/>
<xs:enumeration value="XL"/>
</xs:restriction>
</xs:simpleType>
Bei der Definition eines Typs ist es möglich festzulegen, ob und auf welche Art von diesem Typ weitere XML-Elementtypen abgeleitet werden dürfen. So kann man zum Beispiel festlegen, dass von einem Typ ElementdefinitionWie im vorangegangenen Abschnitt erläutert erlaubt es XML Schema, neue XML-Datentypen zu definieren und diese bei der Definition eigener XML-Elemente zu verwenden. Das folgende Beispiel veranschaulicht die Verwendung des bereits definierten Typs <xs:element name="pc-liste">
<xs:complexType>
<xs:sequence>
<xs:element name="pc" type="pc-Typ" maxOccurs="unbounded"/>
</xs:sequence>
</xs:complexType>
</xs:element>
Ein entsprechendes XML-Element könnte wie folgt aussehen: <pc-liste>
<pc>
<name>Dimension 3100 </name>
<hersteller>Dell</hersteller>
<prozessor>AMD</prozessor>
<mhz>3060</mhz>
<kommentar>Arbeitsplatzrechner</kommentar>
</pc>
<pc>
<name>T 42</name>
<hersteller>IBM</hersteller>
<prozessor>Intel</prozessor>
<mhz>1600</mhz>
<kommentar>Laptop</kommentar>
</pc>
</pc-liste>
In diesem Beispiel erfolgt die Spezifikation des anonymen Listentyps direkt innerhalb der Elementdefinition, während die Spezifikation des pc-Typs extern erfolgt. Bei dem Entwurf eines komplexen XML-Schemas sollte sowohl die Wiederverwendbarkeit und Erweiterbarkeit der einzelnen XML-Elementtypen als auch die Lesbarkeit des Schemas selbst berücksichtigt werden. Die Verwendung anonymer XML-Elementtypen als Teil größerer Elemente gewährleistet im Allgemeinen eine bessere Lesbarkeit kleinerer XML-Schemata. Die Definition und Benennung einzelner, kleinerer und wiederverwendbarer XML-Elementtypen hingegen ermöglicht eine stärkere Modularisierung der XML-Schema-Struktur. Aufgrund der Vielzahl möglicher Anwendungsszenarien haben sich bisher noch keine allgemeingültigen Entwurfsprinzipien für XML-Schemata herausgebildet (vergleichbar den Normalformen für relationale Datenbanken). Weiterführende Konzepte und EigenschaftenEindeutige SchlüsselVergleichbar den Primärschlüsseln in relationalen Datenbanken lassen sich mittels XML Schema eindeutige Schlüssel definieren. XML Schema unterscheidet zwischen der Eindeutigkeit (engl. unique) und der Schlüsseleigenschaft. Das nachfolgende Beispiel definiert ein neues Element pc-list mit einer Liste von <xs:element name="pc-list">
<xs:complexType>
<xs:sequence>
<xs:element name="pc" type="pc-Typ" maxOccurs="unbounded"/>
</xs:sequence>
</xs:complexType>
<xs:unique name="hersteller-name">
<xs:selector xpath="pc"/>
<xs:field xpath="name"/>
<xs:field xpath="hersteller"/>
</xs:unique>
<xs:key name="idKey">
<xs:selector xpath="pc"/>
<xs:field xpath="@id"/>
</xs:key>
</xs:element>
Die beiden Elemente Das folgende Beispiel zeigt die Referenzierung dieses Schlüssels mit dem Attribut <xs:keyref name="idFremdKey" refer="idKey">
<!-- idKey von obigem Beispiel -->
<xs:selector xpath="computerFremd"/>
<xs:field xpath="@references"/>
</xs:keyref>
Mit Import, Include und RedefineXML Schema erlaubt es, fremde Schemata wiederzuverwenden.
Typdefinitionen innerhalb eines Namensraumes, die auf mehrere Dateien verteilt sind, lassen sich mittels <schema xmlns="http://www.w3.org/2001/XMLSchema"
xmlns:pcTeile="http://www.example.com/pcTeile"
targetNamespace="http://www.example.com/pcTeile">
…
<include schemaLocation="http://www.example.com/schemata/harddisk.xsd"/>
<include schemaLocation="http://www.example.com/schemata/ram.xsd"/>
…
</schema>
Gleiches Beispiel wie gerade. Annahme es gäbe einen <schema xmlns="http://www.w3.org/2001/XMLSchema"
xmlns:pcTeile="http://www.example.com/pcTeile"
targetNamespace="http://www.example.com/pcTeile">
…
<redefine schemaLocation="http://www.example.com/schemata/harddisk.xsd">
<!-- redefinition of Hersteller -->
<complexType name="Hersteller">
<complexContent>
<!-- redefinition of Hersteller mit ''restriction'' oder auch ''extension'' etc. -->
<restriction base="pcTeile:Hersteller">
<sequence>
<element name="hersteller" type="string" minOccurs="10" maxOccurs="10"/>
</sequence>
</restriction>
</complexContent>
</complexType>
</redefine>
…
<include schemaLocation="http://www.example.com/schemata/ram.xsd"/>
…
</schema>
Der <schema xmlns="http://www.w3.org/2001/XMLSchema"
xmlns:pcTeile="http://www.example.com/pcTeile"
targetNamespace="http://www.example.com/firma">
…
<import namespace="http://www.example.com/pcTeile"/>
…
<…
<xs:attribute name="xyz" type="pcTeile:superTyp"/>
…/>
…
</schema>
Verwendung von XML-SchemataZur Verwendung eines XML-Schemas in einer XML-Datei kann das Attribut In folgendem Beispiel wird ausgedrückt, dass der Standard-Namensraum <html xmlns="http://www.w3.org/1999/xhtml"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.w3.org/1999/xhtml
http://www.w3.org/1999/xhtml.xsd">
Die Definition gilt für das XML-Element, bei dem die Attribute angegeben sind, und alle Kinderelemente. Soll Elementen, die keinem Namensraum angehören, ein XML-Schema zugeordnet werden, so geschieht dies, wie im folgenden Beispiel gezeigt, mittels des Attributes <html xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="http://www.w3.org/1999/xhtml.xsd">
Beispiel<?xml version="1.0" encoding="UTF-8"?>
<schema xmlns="http://www.w3.org/2001/XMLSchema"
xmlns:bsp="http://de.wikipedia.org/wiki/XML_Schema#Beispiel"
targetNamespace="http://de.wikipedia.org/wiki/XML_Schema#Beispiel"
elementFormDefault="qualified">
<element name="doc">
<complexType>
<sequence>
<element ref="bsp:head"/>
<element name="body" type="string"/>
</sequence>
</complexType>
</element>
<element name="head">
<complexType>
<sequence>
<element name="title" type="string"/>
</sequence>
</complexType>
</element>
</schema>
Dies entspricht, abgesehen vom Namensraum, folgender DTD <!ELEMENT doc (head, body)>
<!ELEMENT head (title)>
<!ELEMENT title (#PCDATA)>
<!ELEMENT body (#PCDATA)>
Eine XML-Struktur, die dem Schema entspricht, ist diese: <?xml version="1.0" encoding="UTF-8"?>
<doc xmlns="http://de.wikipedia.org/wiki/XML_Schema#Beispiel">
<head>
<title>
Dies ist der Titel
</title>
</head>
<body>
Dies ist der Text.
</body>
</doc>
Siehe auchLiteratur
Weblinks
Einzelnachweise
Standards des World Wide Web Consortiums (W3C)
|
