Die Syntax von XML Schema

• Struktur eines XML Elements
  
• Definition eines Elementtyps: complexType
  
• Deklaration von Elementen: element
  
• Deklaration von Attributen: attribute
  
• Einfache Datentypen: simpleType
  
• Schlüsselbeziehungen: key, keyref
  
• Typdefinition ausgehend von bestehenden Typen: extension
  
• Exkurs: Namensräume in XML (Schema)
  
• Ein Schema aus mehreren Schema Dokumenten: include / import
  
• Kommentare in XML Schema

Jedes XML Dokument und damit auch jedes XML Schema besteht aus einer Folge von tags mit folgendem Aufbau:

Start tag: Leeres tag = Inhalt von Element1: Schließendes tag:

<Elementname1 Attributname1="Attributwert1">     <Elementname2/> </Elementname1>

Leere tags werden durch ein "/" abgeschlossen. Elemente können beliebig tief geschachtelt werden.

Das XML Schema Element complexType dient zur Definition eines Elementtyps, welcher weitere Unterelemente beinhalten kann.
Beispiel: Die Darstellung einer Adresse in einem XML Dokument:

<billTo country="US">
  <name>Robert Smith</name>
  <street>8 Oak Avenue</street>
  <city>Old Town</city>
  <state>PA</state>
  <zip>95819</zip>
</billTo>

Der dazugehörige Ausschnitt aus einer XML Schema Beschreibung sieht folgendermaßen aus:

<xsd:element name="billTo" type="USAddress"/>

<xsd:complexType name="USAddress">
  <xsd:sequence>
    <xsd:element name="name" type="xsd:string"/>
    <xsd:element name="street" type="xsd:string"/>
    <xsd:element name="city" type="xsd:string"/>
    <xsd:element name="state" type="xsd:string"/>
    <xsd:element name="zip" type="xsd:decimal"/>
  </xsd:sequence>
  <xsd:attribute name="country" type="xsd:NMTOKEN" use="fixed" value="US"/>
</xsd:complexType>

In der ersten Zeile wird das Element "billTo" deklariert, als Elementtyp ist der im folgenden definierte Typ "USAddress" angegeben.
Die complextype Definition enthält in diesem Fall fünf weitere Element Definitionen und eine Attributbeschreibung.
Die Reihenfolge der Elemente ist festgelegt (sequence). Die inneren Elemente sind vom Datentyp xsd:string bzw. xsd:decimal, dabei handelt es sich um in XML Schema vordefinierte einfache Datentypen (built-in datatypes).
Alternativ zum sequence-tag sind die tags all (alle Subelemente müssen vorkommen oder gar keins, Reihenfolge egal) sowie choice (genau eines der Subelement muss verwendet werden). Darüberhinaus besteht die Möglichkeit, Elemente durch ein umschließendes group -tag zu Gruppen zusammenzufassen.
Ein einmal definierter Elementtyp kann innerhalb eines Schemas beliebig oft zur Deklaration eines Elementes verwendet werden, wobei die Definition im Dokument unterhalb der Deklarationen stehen muss.

Zur Deklaration eines Elements in XML Schema reicht, wie im obigen Beispiel gesehen, die Angabe des Namens und eines Typs als Attribute des element Elements:

<xsd:element name="street" type="xsd:string"/>

Durch die Attribute minOccurs und maxOccurs kann zusätzlich angegeben werden, wie oft das Element mindestens bzw. maximal hintereinander im XML Dokument erscheinen darf. Der Defaultwert ist jeweils 1.
Wird das Attribut type weggelassen, folgt die Typdefinition als complexType oder simpleType unmittelbar innerhalb des element-tags.
Das folgende Beispiel beschreibt das gleiche Adressformat wie oben, jedoch ohne die Möglichkeit der Wiederverwendung eines Elementtyps (Anonyme Type Definition):

<xsd:element name="billTo">
  <xsd:complexType>
    <xsd:sequence>
      <xsd:element name="name" type="xsd:string"/>
      <xsd:element name="street" type="xsd:string"/>
      <xsd:element name="city" type="xsd:string"/>
      <xsd:element name="state" type="xsd:string"/>
      <xsd:element name="zip" type="xsd:decimal"/>
    </xsd:sequence>
    <xsd:attribute name="country" type="xsd:NMTOKEN" use="fixed" value="US"/>
  </xsd:complexType>
</xsd:element>

Attributdeklarationen erscheinen innerhalb einer Elementbeschreibung am Schluss.
Beispiel für eine Attributdeklaration:

<xsd:complexType name="PurchaseOrderType">
  <xsd:element name="billTo" type="USAddress"/>
  <xsd:attribute name="orderDate" type="xsd:date"/>
</xsd:complexType>

Der entsprechende Ausschnitt aus einem XML Dokument:

<purchaseOrder orderDate="1999-10-20">
  <billTo country="US">
    <name>Robert Smith</name>
    <street>8 Oak Avenue</street>
    <city>Old Town</city>
    <state>PA</state>
    <zip>95819</zip>
  </billTo>
</purchaseOrder>

Durch Angabe weiterer Attribute innerhalb des attribute-Element lassen sich weitere Eigenschaften des Attributs festlegen (Optionalität, Defaultwerte, fixe Werte, etc).

XML Schema stellt von sich aus eine große Menge von einfachen Datentypen zur Verfügung, von denen der Anwender weitere Datentypen ableiten kann.
Einige Beispiele:

• Angabe eines Wertebereichs:
  
  <xsd:element name="quantity">
  xsd:simpleType>
    <xsd:restriction base="xsd:positiveInteger">
      <xsd:maxExclusive value="100"/>
    </xsd:restriction>
  </xsd:simpleType>
</xsd:element>
  
  Der Wertebereich eines Basistyps (hier xsd:positiveInteger) wird nach oben hin auf 100 begrenzt.
  
  
• Definition eines String-Musters durch reguläre Ausdrücke:
  
  <xsd:simpleType name="SKU">
  <xsd:restriction base="xsd:string">
    <xsd:pattern value="\d{3}-[A-Z]{2}"/>
  </xsd:restriction>
</xsd:simpleType>
  
  Der Basistyp wird durch einen regulären Ausdrück eingeschränkt. Die Syntax der regulären Ausdrücke entspricht der von Perl (Im Beispiel: drei Ziffern, ein "-", zwei Großbuchstaben).
  
  
• Explizites Angeben aller möglichen Werte:
  
  <xsd:simpleType name="Studienfach">
  <xsd:restriction base="xsd:string">
    <xsd:enumeration value="WI"/>
    <xsd:enumeration value="MI"/>
    <xsd:enumeration value="II"/>
    <xsd:enumeration value="DI"/>
    <xsd:enumeration value="AI"/>
  </xsd:restriction>
</xsd:simpleType>
  
  
• Listentypen:
  
  <xsd:simpleType name="Studienfachliste">
  <xsd:list itemType="Studienfach"/>
</xsd:simpleType>

<xsd:simpleType name="ZweiStudienfaecher">
  <xsd:restriction base="Studienfachliste">
    <xsd:length value="2"/>
  </xsd:restriction>
</xsd:simpleType>

Zunächst wird ein Listentype aus den Elementen des vorigen Beispels definert. Das Trennzeichen der einzelnen Listenelementen ist das Leerzeichen.
  Ein Listentyp kann im folgenden genauer definiert werden, etwa wie im Beispiel durch Festlegung der Anzahl der Elemente.

Der Wert eines keyref-Elements muss übereinstimmen mit einem Wert (Schlüssel) an anderer Stelle im Dokument, welcher durch das key-Element beschrieben wird. Ist dies nicht der Fall, weist der parser einen Fehler aus. Der Schlüssel kann, im Gegensatz zum ID-Element der DTD's, auch aus mehreren Element- und/oder Attributwerten bestehen.
Die Beschreibung des Schlüssels erfolgt durch XPath-Ausdrücke innerhalb der selector- bzw. field- tags.
Beispiel:

<xsd:element name="Person" minOccurs="1" maxOccurs="30">
  <xsd:complexType>
    <xsd:sequence>
      <xsd:element name="Vorname" type="xsd:string"/>
      <xsd:element name="Nachname" type="xsd:string"/>
    <xsd:/sequence>
    <xsd:attribute name="PersonlD" type="xsd:integer"/>
  </xsd:complexType>
</xsd:element>

<xsd:key name="PersonKey">
  <xsd:selector>Person</xsd:selector>
  <xsd:field>@PersonID</xsd:field>
</xsd:key>

<xsd:element name="Projektleiter">
  <xsd:keyref refer="PersonKey"/>
</xsd:element>


Das key-Element definiert den Schlüssel, in diesem Fall das Attribut "PersonID" des Elements "Person". Besteht der Schlüssel aus mehreren Elementen und Attributen, wird dies durch ein Folge von field-tags ausgedrückt.
Im Beispiel muss der Inhalt des Elements "Projektleiter" dem Attributwert eines Elements "Person" entsprechen:

<Person PersonlD="26">
  <Vorname>Volker</Vorname>
  <Nachname>Racho</Nachname>
</Person>

gültig:
<Projektleiter>26</Projektleiter>

ungültig;
<Projektleiter>55</Projektleiter>


Naheliegende Einsatzmöglichkeit von Schlüsselbeziehungen in XML Dokumenten ist die Abbildung von relationalen Datenbankstrukturen (Primärschlüssel etc.).

Die Fähigkeit, logische Beziehungsregeln zwischen den Elementen eines Dokumentes zu beschreiben, ist eine Eigenschaft von XML Schema, die über die Ausdrucksmächtigkeit beispielsweise von kontextfreien Grammatiken hinausgeht.

In XML Schema besteht die Möglichkeit, bestehende Elementtypedfinitionen zu erweitern und so neue Elementtypen zu schaffen (Vererbung).
Im Beispiel wird der Typ "Address" erweitert um zwei weitere Elemente, es entsteht ein neuer Typ "USAddress":

<xsd:element name="shipTo" type="Address"/>

<xsd:complexType name="Address">
  <xsd:sequence>
    <xsd:element name="name" type="xsd:string"/>
    <xsd:element name="street" type="xsd:string"/>
    <xsd:element name="city" type="xsd:string"/>
  </xsd:sequence>
</xsd:complexType>

<xsd:complexType name="USAddress">
  <xsd:complexContent>
    <xsd:extension base="Address">
      <xsd:sequence>
        <xsd:element name="state" type="xsd:string"/>
        <xsd:element name="zip" type="xsd:positiveInteger"/>
      </xsd:sequence>
    </xsd:extension>
  </xsd:complexContent>
</xsd:complexType>

In der XML document instance muss anschließend festgelegt werden, welcher Typ verwendet werden soll. Das Schlüsselwort type hierfür entstammt dem XML Schema instance Namensraum:

<shipTo xsi:type="ipo:USAddress">
  <name>Robert Smith</name>
  <street>8 Oak Avenue</street>
  <city>Old Town</city>
  <state>PA</state>
  <zip>95819</zip>
</billTo>

Durch das Attribut "final" innerhalb einer Typdefinition, kann explizit festgelegt werden, ob von diesem Typ weitere Typen abgeleitet werden dürfen.

Die Einführung von Namensräume (namespaces) in XML dient der Vermeidung von Namenskonflikten insbesondere bei Verwendung zusammengesetzter und u.U. nicht selbsterstellter Dokumentdefinitionen.
Jeder Namensraum ist durch einen URI eindeutig beschrieben. Verwendet ein XML Dokument Elemente/Attribute aus verschiedenen Namensräumen, so müssen diese durch ein Präfix vor jedem Element/Attribut unterschieden werden.

In XML Schema erfolgt die Definition von Namensräumen und deren Präfixe im einleitenden schema-tag:

<xsd:schema xmlns:xsd="http://www.w3.org/2000/10/XMLSchema">

Das Präfix xsd wird per Konvention verwendet zur Kennzeichnung der Elemente und Attribute aus dem Namensraum von XML Schema.

Durch das include -Element können mehrere XML Schema Dokumente zu einem zusammengefügt werden. Voraussetzung hierfür ist, das die Schema Dokumente Regeln für den gleichen Zielnamensraum (target namespace) zur Verfügung stellen.
Dieser Mechanismus erlaubt einen modularen Aufbau von Schema Dokumenten sowie das Anlegen von Bibliotheken für häufig verwendete Beschreibungsregeln.
Beispiel:
<include schemaLocation="http://www.example.com/schemas/address.xsd"/>

Sollen Schema Dokumente aus anderen Zielnamensräumen eingebunden werden, so ist dies durch Einbindung des gesamten zusätzlichen Namensraum möglich:

<import namespace="http://www.example.com/IPO"/>

Kommentare innerhalb eines XML Schema Dokuments stehen innerhalb des annotation-Elements.
Das annotation-Element hat zwei Kindelemente: documentation für menschliche Leser und appinfo zur Übermittlung von Informationen an die Applikation, die das XML Dokument verarbeiten soll.

Beispiel:

<xsd:annotation>
  <xsd:documentation>
    Purchase order schema for Example.com.
    Copyright 2000 Example.com. All rights reserved.
  </xsd:documentation>
  <xsd:appinfo>
    123
  </xsd:appinfo>
</xsd:annotation>