imported>SchlurcherBot: Bot: http → https

2025-06-17T11:26:11Z

Bot: http → https

Neue Seite

'''XML Schema''', abgekürzt '''XSD''' ''(XML Schema Definition),'' ist eine Empfehlung des [[World Wide Web Consortium|W3C]] zum Definieren von Strukturen für [[Extensible Markup Language|XML]]-Dokumente. Anders als bei den klassischen [[Dokumenttypdefinition|XML-DTDs]] wird die Struktur in Form eines XML-Dokuments beschrieben. Darüber hinaus wird eine große Anzahl von [[Datentyp]]en unterstützt.


''XML Schema'' beschreibt in einer komplexen [[Schemasprache (XML)|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 [[Dateiendung|Endung]] '''.xsd'''. Im Gegensatz zu [[Dokumenttypdefinition|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 [[Dokumenttypdefinition|DTD]] als Normbestandteil von XML selbst kann verwendet werden.

== Datentypen ==
''XML 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 Typen ===
''XML 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 (Programmiersprache)|C]], [[Java (Programmiersprache)|Java]] oder [[SQL]]) spezifiziert sind:
* <code>xs:string</code>
* <code>xs:decimal</code>
* <code>xs:integer</code>
* <code>xs:float</code>
* <code>xs:boolean</code>
* <code>xs:date</code>
* <code>xs:time</code>

Hinzu kommen weitere XML-spezifische atomare Typen, unter anderem:
* <code>QName</code>: qualifizierter Name, global eindeutiger Bezeichner. Aufgebaut aus sogenannten ''NCNames (Non-Colonized Names),'' wobei jeder ''NCName'' bis auf den letzten einen [[Namensraum]] ''(Namespace)'' bezeichnet. Der letzte ''NCName'' entspricht dem lokalen Namen innerhalb des Namensraumes. Die einzelnen ''NCNames'' werden mittels Punkt (.) zu einem ''QName'' zusammengesetzt.
* <code>anyURI</code>: ''Uniform Resource Identifier'' ([[Uniform Resource Identifier|URI]])
* <code>language</code>: Sprachbezeichnung, z. B. de-DE, en-US, fr
* <code>ID</code>: Identifikationsattribut innerhalb von XML-Elementen
* <code>IDREF</code>: Referenz auf einen ID-Wert
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:

* Das folgende Beispiel definiert einen neuen XML-Datentyp mit dem Namen <code>monatInt</code> sowie eine Liste <code>monate</code> dieses neuen Typs:
<syntaxhighlight lang="xml">
<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>
</syntaxhighlight>
Eine Instanz des neuen Typs könnte wie folgt aussehen:
<syntaxhighlight lang="xml">
<monate>
1 2 3 4 5 6 7 8 9 10 11 12
</monate>
</syntaxhighlight>
Die einzelnen Elemente einer Liste werden durch [[Leerraum]] (hier: Leerzeichen) getrennt.

* Zu den einfachen Typen gehören zusätzlich noch sogenannte Vereinigungen (englisch ''{{lang|en|unions}}'').
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 <code>monatsname</code> sowie einen Union-Typ <code>monat</code>:
<syntaxhighlight lang="xml">
<xs:simpleType name="monatsname">
<xs:restriction base="xs:string">
<xs:enumeration value="Jan"/>
<xs:enumeration value="Feb"/>
<xs:enumeration value="Mär"/>

</xs:restriction>
</xs:simpleType>
<xs:simpleType name="monat">
<xs:union memberTypes="monatsname monatInt"/>
</xs:simpleType>
</syntaxhighlight>
XML-Elemente vom Typ <code>monat</code> dürfen entweder ganzzahlige Werte im Bereich 1–12 enthalten oder eine der entsprechenden Monatsbezeichnungen als [[Zeichenkette]]. Gültige Instanzen sind beispielsweise:
<syntaxhighlight lang="xml">
<monat>Jan</monat>
<monat>2</monat>
</syntaxhighlight>

=== Komplexe Typen ===
In 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 <code>pc-Typ</code> mit entsprechenden Kindelementen <code>name</code>, <code>hersteller</code> etc., sowie einem Attribut <code>id</code>:
<syntaxhighlight lang="xml">
<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>
</syntaxhighlight>

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:
* <code>xs:sequence</code>: Eine Liste von Kindelementen wird spezifiziert. Jedes dieser Elemente kann keinmal, einmal oder mehrfach auftreten (Attribute <code>minOccurs</code> und <code>maxOccurs</code>). Falls kein <code>occurs</code>-Attribut vorhanden ist, wird in beiden Fällen der Default-Wert 1 verwendet. Die Elemente innerhalb einer <code>sequence</code> müssen in der angegebenen Reihenfolge auftreten. In dem oben gezeigten Beispiel müssen die Elemente <code>name</code>, <code>hersteller</code> und <code>prozessor</code> genau einmal auftreten, das <code>mhz</code>-Element kann null- oder einmal auftreten, <code>kommentar</code>-Elemente können beliebig oft oder auch gar nicht auftreten.
* <code>xs:choice</code>: Aus einer Liste von Alternativen kann ein Element ausgewählt werden. Das nachfolgende Beispiel definiert einen neuen Typ <code>computer</code>, der als Kindelement entweder ein <code>desktop</code>-Element besitzt (vom Typ <code>pc-Typ</code>) oder ein <code>laptop</code>-Element:
<syntaxhighlight lang="xml">
<xs:complexType name="computer">
<xs:choice>
<xs:element name="desktop" type="pc-Typ"/>
<xs:element name="laptop" type="laptop-Typ"/>
</xs:choice>
</xs:complexType>
</syntaxhighlight>
* <code>xs:all</code>: Mittels des <code>xs:all</code>-Tags lässt sich eine Gruppe von Kindelementen definieren, von denen jedes maximal einmal auftreten darf (<code>min</code>- und <code>maxOccurs</code> der Kindelemente dürfen nur die Werte 0 oder 1 annehmen). Die Reihenfolge der Elemente ist beliebig.

==== Beliebiger Inhalt ====
XML-Elemente mit beliebigem Inhalt lassen sich mittels des Basistyps <code>anyType</code> definieren. Der nachfolgende Code spezifiziert ein <code>kommentar</code>-Element beliebigen Inhalts, d. h. sowohl komplexe XML-Elemente als auch Text können vorkommen.
<syntaxhighlight lang="xml">
<xs:element name="kommentar" type="xs:anyType"/>
</syntaxhighlight>

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:
<syntaxhighlight lang="xml">
<xs:element name="tagname">
<xs:complexType mixed="true">
<xs:sequence>
<xs:element minOccurs="0" maxOccurs="unbounded" name="child" type="xs:integer"/>

</xs:sequence>
</xs:complexType>
</xs:element>
</syntaxhighlight>

==== Leere Elemente ====
Von ''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: <code> </code>). ''XML Schema'' bedient sich an dieser Stelle eines kleinen Tricks: Es wird mittels <code>xs:complexType</code> ein neuer Typ definiert, ohne ein Kindelement anzugeben. Da <code>xs:complexType</code> nach Vorgabe nur komplexe XML-Kindelemente als Inhalt zulässt, bleibt das jeweilige Element in diesem Fall leer.

=== Ableitung neuer Typen ===
Neue 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 (Programmierung)|Vererbung]] im Sinne der [[Objektorientierung]], da keine Eigenschaften vergleichbar den Methoden oder Attribute objektorientierter [[Klasse (objektorientierte Programmierung)|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 [[Typumwandlung]]en sind jedoch möglich).

Die ''Ableitung'' eines neuen Typs kann auf zweierlei Arten erfolgen: Erweiterung oder Einschränkung.

==== Erweiterung eines Typs ====
Die 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 <code>pc-Typ</code> um ein Element <code>ram</code> erweitert:
<syntaxhighlight lang="xml">
<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>
</syntaxhighlight>
Der neu definierte XML-Typ <code>myPC-Typ</code> besteht aus allen Kindelementen des Typs <code>pc-Typ</code> sowie dem Element <code>ram</code>. Letzteres wird, wie in einer <code>xs:sequence</code>-Definition, an die bisherigen Kindelemente angehängt. 
Da keine Substituierbarkeit gegeben ist, darf an einer Stelle an der ein Element vom Typ <code>pc-Typ</code> erwartet wird nicht ohne weiteres ein Element vom Typ <code>myPC-Typ</code> verwendet werden.

==== Einschränkung eines Typs ====
Durch 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 <code>myPC2-Typ</code> von <code>pc-Typ</code> abgeleitet. In diesem Fall darf maximal ein <code>kommentar</code>-Element auftreten (im Gegensatz zu einer beliebigen Anzahl beim Typ <code>pc-Typ</code>)
<syntaxhighlight lang="xml">
<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>
</syntaxhighlight>

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 <code>monatInt</code> wird als Einschränkung des Typs Integer auf den Wertebereich 1–12 definiert. Grundsätzlich stehen die folgenden Primitive zur Verfügung, um Einschränkungen auf einfachen Typen zu beschreiben:
* <code>length</code>, <code>maxLength</code>, <code>minLength</code> – Beschränkt die Länge eines Strings oder einer Liste.
* <code>enumeration</code> – Beschränkung durch Angabe alternativer Werte
* <code>pattern</code> – Beschränkung durch Angabe eines [[Regulärer Ausdruck|regulären Ausdrucks]]
* <code>minExclusive</code>, <code>minInclusive</code>, <code>maxExclusive</code>, <code>maxInclusive</code> – Einschränkung des Wertebereichs.
* <code>totalDigits</code>, <code>fractionDigits</code> – Einschränkung der Dezimalstellen (Gesamtzahl und Nachkommastellen)
* <code>whiteSpace</code> – Behandlung von Leerzeichen und Tabs

Die folgenden Beispiele veranschaulichen die Verwendung dieser Komponenten:

* Körpertemperatur, 3 Dezimalstellen, 1 Nachkommastelle, Minimal- und Maximalwert
<syntaxhighlight lang="xml">
<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>
</syntaxhighlight>
* Deutsche Postleitzahlen, optionales „<code>D </code>“ gefolgt von fünf Ziffern
<syntaxhighlight lang="xml">
<xs:simpleType name="plz">
<xs:restriction base="xs:string">
<xs:pattern value="(D )?[0-9]{5}"/>
</xs:restriction>
</xs:simpleType>
</syntaxhighlight>
* Größenangabe
<syntaxhighlight lang="xml">
<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>
</syntaxhighlight>

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 <code>pc-Typ</code> weitere Typen nur durch das Setzen weiterer Einschränkungen abgeleitet werden dürfen – und nicht durch das Hinzufügen neuer Kindelemente.

== Elementdefinition ==
Wie 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 <code>pc-Typ</code> innerhalb einer Liste von pc-Elementen:
<syntaxhighlight lang="xml">
<xs:element name="pc-liste">
<xs:complexType>
<xs:sequence>
<xs:element name="pc" type="pc-Typ" maxOccurs="unbounded"/>
</xs:sequence>
</xs:complexType>
</xs:element>
</syntaxhighlight>
Ein entsprechendes XML-Element könnte wie folgt aussehen:
<syntaxhighlight lang="xml">
<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>
</syntaxhighlight>
In diesem Beispiel erfolgt die Spezifikation des [[Anonymer Datentyp|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 [[Normalisierung (Datenbank)|Normalformen]] für relationale Datenbanken).

== Weiterführende Konzepte und Eigenschaften ==
=== Eindeutige Schlüssel ===
Vergleichbar den [[Primärschlüssel]]n in [[Relationale Datenbank|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 <code>pc</code>-Kindelementen:
<syntaxhighlight lang="xml">
<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>
</syntaxhighlight>
Die beiden Elemente <code>unique</code> und <code>key</code> selektieren mit einem [[XPath]] Pfadausdruck (im Beispiel: <code>pc</code>) eine Menge von <code>pc</code>-Elementen. Für diese Menge muss die jeweilige Eindeutigkeits- bzw. Schlüsselbedingung erfüllt werden.
Im obigen Beispiel wird festgelegt, dass die Kombination der Elemente <code>name</code> und <code>hersteller</code> für jedes <code>pc</code>-Element innerhalb dieser Liste eindeutig sein muss. Durch das <code>key</code>-Element wird festgelegt, dass das Attribut <code>id</code> innerhalb dieser Liste eindeutig sein muss und von außerhalb referenziert werden kann.

Das folgende Beispiel zeigt die Referenzierung dieses Schlüssels mit dem Attribut <code>refer</code> und dem Schlüsselwort <code>@references</code>.
<syntaxhighlight lang="xml">
<xs:keyref name="idFremdKey" refer="idKey">

<xs:selector xpath="computerFremd"/>
<xs:field xpath="@references"/>
</xs:keyref>
</syntaxhighlight>
; Beachte:
Mit <code>refer</code> bezieht man sich auf das <code>name</code>-Attribut einer Schlüsselbedingung, nicht auf das Schlüsselfeld. Die Werte in <code>references</code> müssen also immer unter den Schlüsseln zu den <code>computern</code> zu finden sein. (Hintergrund dieses Konstrukts ist die Sicherstellung der [[Referentielle Integrität|referentiellen Integrität]], wie man sie von relationalen Datenbanksystemen her kennt.)

=== Import, Include und Redefine ===
''XML Schema'' erlaubt es, fremde Schemata wiederzuverwenden. 
Hierzu stehen sowohl der <code>include</code>- als auch der <code>import</code>-Tag zur Verfügung sowie die Möglichkeit einer neuen Definition bzw. Anpassung fremder Schemata beim Einbinden.

; <code>include</code>
Typdefinitionen innerhalb eines Namensraumes, die auf mehrere Dateien verteilt sind, lassen sich mittels <code>include</code> zusammenfügen.
<syntaxhighlight lang="xml">
<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>
</syntaxhighlight>
* Mehrere Schemata können inkludiert werden.
* <code>targetNamespace</code> des <code>harddisk.xsd</code> muss mit dem des inkludierenden Schemas übereinstimmen.
; <code>redefine</code>
Gleiches Beispiel wie gerade. Annahme es gäbe einen <code>complexType</code> <code>Hersteller</code> im Schema <code>harddisk.xsd</code>.
<syntaxhighlight lang="xml">
<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">

<complexType name="Hersteller">
<complexContent>

<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>
</syntaxhighlight>
* <code>redefine</code> kann an Stelle von <code>include</code> verwendet werden.
* Der Name des Typs ändert sich dabei nicht.

; <code>import</code>
Der <code>import</code>-Tag erlaubt es, Elemente aus anderen Namensräumen zu importieren, mit einem Präfix zu versehen und
damit Schema-Bestandteile aus unterschiedlichen Namensräumen wiederzuverwenden. 
Annahme ist, dass es einen definierten Typ <code>superTyp</code> in <code>pcTeile</code> gibt.
<syntaxhighlight lang="xml">
<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>
</syntaxhighlight>

== Verwendung von XML-Schemata ==
Zur Verwendung eines XML-Schemas in einer XML-Datei kann das Attribut <code>schemaLocation</code> des Schema-Instance-Namensraums verwendet werden, um die Adresse des Schemas bekannt zu machen.
Somit ist es einer Anwendung wie beispielsweise einem XML-Parser möglich, das Schema zu laden, sofern es ihm nicht schon bekannt ist. Alternativ kann der Anwendung das Schema aber auch über andere Wege bekannt gemacht werden, z. B. über Konfigurationsdateien. Letztere Möglichkeit ist jedoch nicht standardisiert und somit von Anwendung zu Anwendung verschieden.

In folgendem Beispiel wird ausgedrückt, dass der Standard-Namensraum <code>http://www.w3.org/1999/xhtml</code> ist und dann angegeben, dass das XML-Schema für diesen Namensraum unter <code>www.w3.org/1999/xhtml.xsd<ref>{{Webarchiv | url=http://www.w3.org/1999/xhtml.xsd | wayback=20001110050100 | text=www.w3.org/1999/xhtml.xsd}}</ref></code> aufzufinden ist.

<syntaxhighlight lang="xml">
<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">
</syntaxhighlight>

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 <code>noNamespaceSchemaLocation</code>.

<syntaxhighlight lang="xml">
<html xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="http://www.w3.org/1999/xhtml.xsd">
</syntaxhighlight>

== Beispiel ==
<syntaxhighlight lang="xml">
<?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>
</syntaxhighlight>

Dies entspricht, abgesehen vom Namensraum, folgender [[Dokumenttypdefinition|DTD]]

<syntaxhighlight lang="xml">
<!ELEMENT doc (head, body)>
<!ELEMENT head (title)>
<!ELEMENT title (#PCDATA)>
<!ELEMENT body (#PCDATA)>
</syntaxhighlight>

Eine XML-Struktur, die dem Schema entspricht, ist diese:

<syntaxhighlight lang="xml">
<?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>
</syntaxhighlight>

== Siehe auch ==
* [[Liste der XML-Namensräume]]
* [[RELAX NG]]
* [[WSDL]]
* [[Schematron]]
* ''[[Document Structure Description]]'' (DSD)
* [[railML]]

== Literatur ==
* {{Literatur |Autor=[[Alfons Kemper]], André Eickler |Titel=Datenbanksysteme – Eine Einführung |Verlag=Oldenbourg Wissenschaftsverlag |Ort=München |Datum=2004 |ISBN=3-486-27392-2}}
* {{Literatur |Autor=Helmut Vonhoegen |Titel=Einstieg in XML |TitelErg=''Aktuelle Standards: XML Schema, XSL, XLink'' |Auflage=5. |Verlag=Galileo Press |Datum=2009 |ISBN=978-3-8362-1367-7}}
* {{Literatur |Autor=Margit Becher |Titel=XML – DTD, XML-Schema, XPath, XQuery, XSLT, XSL-FO, SAX, DOM |Verlag=W3L Verlag |Ort=Witten |Datum=2009 |ISBN=978-3-937137-69-8}}
* {{Literatur |Autor=Marco Skulschus, Marcus Wiederstein |Titel=XML Schema |Verlag=Comelio Medien |Ort=Berlin |Datum=2009 |ISBN=978-3-939701-22-4}}
* {{Literatur |Autor=Eric van der Vlist |Titel=XML Schema |Verlag=O’Reilly |Ort=Köln |Datum=2003 |ISBN=978-3-89721-345-6 |Online=[https://www.data2type.de/xml-xslt-xslfo/xml-schema online]}}

== Weblinks ==
* ''W3C XML Schema Specification: [https://www.w3.org/TR/xmlschema-0/ Primer,] [https://www.w3.org/TR/xmlschema-1/ Structures,] [https://www.w3.org/TR/xmlschema-2/ Datatypes]'' und ''[https://www.w3.org/XML/Schema Miscellaneous;]'' deutsche Übersetzungen: [https://web.archive.org/web/20031008133141/http://edition-w3c.de/TR/2001/REC-xmlschema-0-20010502/ Einführung,] [https://web.archive.org/web/20070310004358/http://www.edition-w3c.de/TR/2001/REC-xmlschema-1-20010502/ Strukturen,] [https://web.archive.org/web/20021205223145/http://edition-w3c.de/TR/2001/REC-xmlschema-2-20010502/ Datentypen]
* [https://www.data2type.de/xml-xslt-xslfo/xml-schema/ Einführung in XML Schema und Referenz]

== Einzelnachweise ==
<references />

{{Navigationsleiste W3C-Standards}}

{{Normdaten|TYP=s|GND=4803276-1}}

[[Kategorie:XML-basierte Sprache]]
[[Kategorie:XML]]

XML Schema - Versionsgeschichte

imported>SchlurcherBot: Bot: http → https