Alles nach Schema X?
Ein Seminarvortrag von Kilian Kiko im Rahmen des WWW-Technologieseminars von Dr. Kredel im Sommersemester 2001. Universität Mannheim, Deutschland.

1. Einleitung


1.1. XML

Link zur XML-Vorlesung aus dem WS00/01
  • Metasprache
  • Werkzeug zur Definition von Sprachen
  • Trennung von Daten(Inhalt) und Semantik
  • Teil von SGML(einfach, knapp, allgemein)
  • 1.2. Was ist Schema?

    Link zur XML Schema-Vorlesung aus dem WS00/01

  • Sprache zur Definition von XML-Vokabularen
  • Inventar an XML-Markup-Konstrukten um Schemas schreiben zu können
  • Eine Kollektion(Vokabular) von Typdefinitionen und Elementdeklarationen (XML Schema/Grammars)

  • 1.3. Zweck von Schema

    XML Schema dient zum definieren, beschreiben und katalogisieren von XML-Vokabularien für Klassen von XML Dokumenten. 

    Validierung von XML Dokumenten:

  • Struktur: Elemente, Attribute
  • Datentypen
  • Entities und Notations
  • Default-Werte

  • 1.3.1 Einsatzgebiete

  • Publishing and syndication
  • Verteilung von Informationen durch Verlagsdienste. Schemas beschreiben die Struktur der Dokumente: headlines, news stories, thumbnail images, cross-references, etc. Untersützung für verschiedene Schemaversionen.
  • Electronic commerce transaction processing
  • Bibliotheken von Schemas beschreiben Wirtschaftstransaktionen zwischen Märkten und Unternehmen.
  • Supervisory control and data acquisition
  • Schemas können von Servern eingesetzt werden, um die Gültigkeit ausgehender Nachrichten zu versicheren. Der Client kann feststellen, welchen Teil einer Nachricht er versteht. Unter anderem: Mediendienste, Sicherheitssysteme, Fabrikautomatisierung, Prozeßsteuerung.
  • Traditional document authoring/editing governed by schema constraints
  • Schemas können Autoren bei der Erstellung von Dokumenten führen: Bei einem technischen Bericht kann die Anwendung versichern, daß der Autor immer weiß, ob er ein Datum oder eine Teilenummer einzutragen hat.

  • Query formulation and optimization
  • Datenbanken können Schemas erstellen, mit deren Hilfe Benutzer korrekte Anfragen stellen können.

  • Open and uniform transfer of data between applications, including databases
  • Das Mapping der Austauschdaten zwischen Applikationen kann durch Schemas deutlich erleichtert werden.

  • Metadata Interchange
  • Wachsendes Interesse am Austausch und Gebrauch von Metadaten, insbesondere DBMS, query, datawarehousing. RDF, dublin core, OMG-XMI

     

    2. Geschichte und Entwicklung


    2.1. XML DTD

    Dokument Type Definition innerhalb von XML 


  • W3C Recommendation 10. Feb. 1998
  • "wellformed" XML Dokumente auch ohne DTD
  • "valid" XML Dokumente nur bezüglich einer DTD
  • Beschränkung auf 10 "Datentypen" (eigentlich nur ein Typ CDATA)
  • Dokumenten-orientierte Sichtweise
  • Eigene Sprachkonstrukte


  • 2.2. Ersatz durch Schema

    XML Schema sollte die Nachteile von DTDs aufheben und diese erweitern.


  • Entwicklung seit 1999
  • W3C Recommendation 02. Mai. 2001
  • Beschreibung der Strukturen in XML
  • Daten-orientierte Sichtweise
  • 37 Datentypen(integer, date, byte, string)
  • Namespaces
  • Vererbung(kind-of-Beziehungen)
  • Objektorientierung

  •  

    3. Schemarama Teil 1


    3.1. Allgemeines

    Derzeit existiert ein gutes Dutzend verschiedener Dokumenten Definitions Sprachen, der größte Teil ist proprietär und soll hier nicht weiter behandelt werden.

    Zu den wichtigen (open-source) Sprachen gehören:

    TREX- Tree Regular Expressions for XML von James Clark als Vorschlag der OASIS (Organization for the Advancement of Structured Information Standards)

    RELAX- REgular LAnguage Description for XML von Murata Makoto, welche bei der ISO eingereicht wurde

    Schematron von Rick Jelliffe vom Academia Sinica Computing Centre.

    Sowie seit Anfang Juni 2001 RELAX NG von der OASIS als TREX (und RELAX) Nachfolger, auf den wir aufgrund des zeitlichen Vorlaufs nicht mehr eingehen können.


    Weitere Sprachen:
    Sprache Entwickler
    XDR XML-Data Reduced (in BizTalk) Microsoft
    DSD Document Structure Description AT&T
    SOX Schema for Object-Oriented XML Commerce One
    DCD Document Content Description IBM und Microsoft

    3.2. Konkurrierende Ansätze

    Gründe:

  • Lange Entwicklungszeit von Schema
  • Uneinigkeit über strukturdefinierenden Teil von Schema
  • Komplett andere Ansätze: rule-based-schema
  • Kritik an Wirtschaftsnähe des W3C

  • 3.3. Grammars Versus Rules

    Grammars Rule-based
    Verwendung einer grammatischen Struktur Verwendung von in XPath ausgedrückten Regeln
    geschlossen offen
    einfaches: leicht einfaches: komplex

    komplexes: schwer

    komplexes: einfach
    co-occurrence: nicht möglich alle Bedingungen
    context sensitive: nicht möglich ohne Einschränkung möglich
    Structural patterns: monolithisch, pattern/source matching Structural rules: "on-the-fly"-validation: triggers

    4. XML Schema


    4.1. Allgemeines

    Aufteilung auf 3 Dokumente:
    Part 0: Primer
    Part 1: Structures
    Part 2: Datatypes

    4.2. XML Schema Teil 1: Structures

    Nun zu unserem Beispiel Dokument, welches eine Folge der TV-Serie Futurama beschreiben soll:

    <?xml version="1.0" encoding="utf-8"?>
    
    <folge nr="S03E07" cd="13">
     <title> The Day the Earth stood stupid </title>
     <untertitel> 80% Entertainment by Volume </untertitel>
     <autor>  Matt Groening </autor>
     <ersteSendung>2001-02-18</ersteSendung>
     <charaktere>
      <charakter ersteFolge="S01E01" hautpCharakter="true">
       <name> Bender </name>
       <freund-von> Philip J. Fry </freund-von>
       <qualifikation> Bending robot </qualifikation>
       <hauptbeschaeftigung> Trinken Stehlen Leutereinlegen</hauptbeschaeftigung>
       <roboter/>
      </charakter>
      <charakter ersteFolge="S01E01" hauptCharakter="true">
       <vorName> Philip </vorName>
       <zuName> J. </zuName>
       <nachName> Fry </nachName>
       <freund-von> Bender </freund-von>
       <qualifikation>delivery boy</qualifikation>
       <hauptbeschaeftigung>in-Unterhosen-Rumhängen Slurm-Trinken</hauptbeschaeftigung>
       <mensch/>
      </charakter>
     </charaktere>
    </folge>
    

    Die passende DTD:
    <!ELEMENT folge (titel,untertitel?,autor+,ersteSendung?,charaktere) >
    <!ELEMENT title (#PCDATA) >
    <!ELEMENT untertitel (#PCDATA) >
    <!ELEMENT autor (#PCDATA) >
    <!ELEMENT ersteSendung (#PCDATA) >
    <!ELEMENT charaktere (charakter*) >
    <!ELEMENT charakter (name|(vorName,zuName?,nachName),freund-von?,
    					qualifikation,hauptbeschaeftigung,
    					(roboter|mensch|alien)) >
    <!ELEMENT name (#PCDATA) >
    <!ELEMENT vorName (#PCDATA) >
    <!ELEMENT zuName (#PCDATA) >
    <!ELEMENT nachName (#PCDATA) >
    <!ELEMENT freund-von (#PCDATA) >
    <!ELEMENT qualifikation (#PCDATA) >
    <!ELEMENT hauptbeschaeftigung (#PCDATA) >
    <!ELEMENT roboter EMPTY >
    <!ELEMENT mensch EMPTY >
    <!ELEMENT alien EMPTY >
    <!ATTLIST folge nr ID #REQUIRED cd CDATA #IMPLIED>
    <!ATTLIST charakter ersteFolge IDREF #REQUIRED
    		 hauptCharakter CDATA "false">
    

    Das XML Schema:
    Angabe des XML Schema-Namespaces:
    <?xml version="1.0" encoding="utf-8"?>
    <xsd:schema xmlns:xsd="http://www.w3.org/2000/10/XMLSchema">
    

    XML Schema: DATATYPES
    Definition des folge-Elementes als root-Element
    vom Typ complexType (russian doll design):
     <xsd:element name="folge">
      <xsd:complexType>
       <xsd:sequence>
        <xsd:element name="titel" type="xsd:string"/>
        <xsd:element name="untertitel" type="xsd:string" minOccurs="0"/>
        <xsd:element name="autor" type="xsd:string" maxOccurs="3"/>
        <xsd:element name="ersteSendung" type="xsd:date" minOccurs="0"/>
        <xsd:element name="charaktere">
         <xsd:comlexType>
    	  <xsd:sequence>
    	   <xsd:element name="charakter" type="charakter" minOccurs="0" maxOccurs="unbounded"/>
    	  </xsd:sequence> 
    	 </xsd:complexType>
        </xsd:element>
       </xsd:sequence>
       <xsd:attribute name="nr" type="xsd:ID" use="required"/>
       <xsd:attribute name="cd" type="xsd:positiveInteger"/>
      </xsd:complexType>
     </xsd:element>
    
     <xsd:complexType name="charakter">
      <xsd:sequence>
       <xsd:choice>
        <xsd:element name="name" type="xsd:string"/>
        <xsd:group ref="nameGruppe"/>
       </xsd:choice>
       <xsd:element name="freund-von" type="xsd:string"/>
       <xsd:element name="qualifikation" type"xsd:string"/>
       <xsd:element name="hauptbeschaeftigung" type="xsd:string"/>
       <xsd:choice>
        <xsd:element name="roboter" type="xsd:string"/>
        <xsd:element name="mensch" type="xsd:string"/>
        <xsd:element name="alien" type="xsd:string"/>
       </xsd:choice>
      </xsd:sequence>
      <xsd:attributeGroup ref="charakterAttributes"/>
     </xsd:complexType> 
     
     <xsd:group name="nameGruppe">
      <xsd:sequence>
       <xsd:element name="vorName" type="xsd:string"/>
       <xsd:element name="zuName" type="xsd:string" minOccurs="0"/>
       <xsd:element name="nachName" type="xsd:string"/>
      </xsd:sequence>
     </xsd:group>
     
     <xsd:attributeGroup name="charakterAttributes">
      <xsd:attribute name=="ersteFolge" type="IDREF" use="required"/>
      <xsd:attribute name="hauptCharakter" type="xsd:boolean" default="false"/>
     </xsd:attributeGroup>
    
    </xsd:schema>
    

    Flat catalog-design: alle referenzierten Elemente top-level! (DTD kompatibel):

    <?xml version="1.0" encoding="utf-8"?>
    <xsd:schema xmlns:xsd="http://www.w3.org/2000/10/XMLSchema">
    
    <!-- definition of simple type elements -->
    <xsd:element name="titel" type="xsd:string"/>
    <xsd:element name="untertitel" type="xsd:string"/>
    <xsd:element name="autor" type="xsd:string"/>
    <xsd:element name="ersteSendung" type="xsd:date"/>
    ...
    
    <!-- definition of attributes -->
    <xsd:attribute name="nr" type="xsd:ID" use="required"/>
    <xsd:attribute name="cd" type="xsd:positiveInteger"/>
    
    <xsd:element name="folge">
     <xsd:complexType>
      <xsd:sequence>
       <xsd:element ref="title"/>
       <xsd:element ref="untertitle" minOccurs="0"/>
       <xsd:element ref="autor" maxOccurs="3"/>
       <xsd:element ref="ersteSendung" minOccurs="0"/>
       ...
      </xsd:sequence>
     </xsd:complexType>
     <xsd:attribute ref="nr"/>
     <xsd:attribute ref="cd"/>
    </xsd:element>
    </xsd:schema>
    
    Mögliche XML-Instanz-Dokumente:
    vom "titel"-Element
    <?xml version="1.0" encoding="utf-8"?>
    
    <titel>Episode V - Das Imperium schlägt zurück</titel>
    
    Vom top-level "charakter"-Element:
    <?xml version="1.0" encoding="utf-8"?>
    
    <charakter>
     <name>Harald Schmidt</name>
     <freund-von>Helmut Zerlet</freund-von>
     <qualifikation>late-show-host</qualifikation>
     <hauptbeschaeftigung>Witzemachen Geldverdienen Leutereinlegen</hauptbeschaeftigung>
     <mensch/>
    </charakter>
    

    Typendefinitionen

    simpleType:
    Typdefinitionen besthen aus einem Basistyp und einer oder mehrerer Facetten.
    Datentyp "nameType": Ein string der aus maximal 32 Buchstaben(characters) besteht:
    <xsd:simpleType name="nameType">
     <xsd:restriction base="xsd:string">
      <xsd:maxLength value="32"/>
     </xsd:restriction>
    </xsd:simpleType>
    
    Enumeration:
    Datentyp "hauptbeschäftigung": Alle vorhandenen Hauptbeschäftigungen:
    <xsd:simpleType name="hauptbeschäftigung">
     <xsd:restriction base="xsd:string">
      <xsd:enumeration value="Trinken"/>
      <xsd:enumeration value="Stehlen"/>
      <xsd:enumeration value="Leutereinlegen"/>
      <xsd:enumeration value="in-Unterhosen-Rumhängen"/>
      <xsd:enumeration value="Slurm-Trinken"/>
      <xsd:enumeration value="Geldverdienen"/>
     </xsd:restriction>
    </xsd:simpleType>
    
    List Types:
    Datentyp "listeHauptbeschäftigung": Ein list-type vom Typ "hauptbeschäftigung":
    <xsd:simpleType name="listeHauptbeschäftigung">
     <xsd:list itemType="hauptbeschäftigung"/>
    </xsd:simpleType>
    
    Pattern:
    Wird mittels regulärer Ausdrücke gebildet:
    <xsd:simpleType name="episode">
     <xsd:restriction base="xsd:string">
      <xsd:pattern value="S\d{2}E\d{2}"/>
     </xsd:restriction>
    </xsd:simpleType>
    
    Union Types:
    Typ der aus mehreren anderen Typen "zusammengesetzt" ist (nur Auswahl):
    <xsd:simpleType name="cd">
     <xsd:union memberTypes="xsd:positiveInteger roemischeZahlen">
    </xsd:simpleType>
    
    Empty Content:
    In XML Schema existiert kein Empty-Typ, deshalb muss er per Restriktion aus dem anyType gewonnen werden:
    <xsd:complexType name="empty">
     <xsd:complexContent>
      <xsd:restriction base="xsd:anyType">
     </xsd:complexContent>
    </xsd:complexType>
    
    Mixed Content:
    Wird eingesetzt, um freien Text mit Elementen zu mischen.
    <xsd:element name="charakter">
     <xsd:complexType mixed="true">
      <xsd:sequence>
       <xsd:choice>
        <xsd:element name="name" type="xsd:string"/>
        <xsd:group ref="nameGruppe"/>
       </xsd:choice>
       <xsd:element name="freund-von" type="xsd:string"/>
       <xsd:element name="qualifikation" type"xsd:string"/>
       <xsd:element name="hauptbeschaeftigung" type="xsd:string"/>
      </xsd:sequence>
      <!-- etc. -->
     </xsd:complexType> 
    </xsd:element>
    
    Mögliches Instanzdokument(Ausszug):
    <charakter>
     <name>Bender</name>ist ein gutter Freund von
     <freund-von>Philip J. Fry</freund-von> er ist ein ausgebildeter
     <qualifikation>Bending robot</qualifikation>und seine Vorlieben sind
     <hauptbeschaeftigung>Trinken Stehlen Leutereinlegen</hauptbeschaeftigung>.
    </charakter>
    
    SimpleType-Element mit Attribut:
     <xsd:element name="ersteSendung"/>
      <xsd:complexType>
       <xsd:simpleContent>
        <xsd:extension base="xsd:date">
    	 <xsd:attribute name="wiederholung" type="xsd:positiveInteger">
    	</xsd:extension>
       </xsd:simpleContent>
      </xsd:complexContent>
     </xsd:element>
    
    In einem Instanzdokument:
    <ersteSendung wiederholung="2">2001-02-18</ersteSendung>
    
    Nil Values:
    (Zur expliziten Angabe z.B. als Rückgabewert einer DB)
    <xsd:element name="qualifikation" type="xsd:string" nillable="true"/>
    
    Im Instanzdokument muss zur deutlich Machung das nil Attribut gesetzt werden:
    <qualifikation xsi:nil="true"><qualifikation>
    Das nil Attribut ist als Teil des XML Schema namespace for instances (http://www.w3.ord/2001/XMLSchema-instance) definiert.
    Achtung: Trifft nicht auf Attributwerte zu.

    ANNOTATIONS

    XML Schema bietet 3 Elemente, um Schemas für den menschlichen Benutzer als auch für Applikationen zu kommentieren. Das annotation-Element dient hier als Marker für eine Annotation, die dann aus den Kindelementen "documentation" (Mensch) und/oder "appInfo" (Application) besteht.
    <xsd:element name="folge">
      <xsd:annotation>
        <xsd:documentation xml:lang="en">
          Top level element.
        </xsd:documentation>
        <xsd:documentation xml:lang="fr"<
          Element racine.
        </xsd:documentation>
        <xsd:appinfo source="http://example.com/foo/">
          <bind xmlns="http://example.com/bar/">
            <class name="folge"/>
          </bind>
        </xsd:appinfo>
      </xsd:annotation>
    

    NAMESPACES

    Jedes Schema Dokument ist an einen namespace durch die Angabe von targetNamespace gebunden. (bzw. durch die nicht Angabe an den undeclared target namespace)
    <xsd:schema xmlns:xsd="http://www.w3.org/2000/10/XMLSchema"
    			xmlns="http://www.futuramaworld.de/schema/folge"
    			targetNamespace="http://www.futuramaworld.de/schema/folge"
    			elementFormDefault="qualified"
    			attributeFormDefault="unqualified">
    
    Im XML-Dokument:
    <folge xmlns="http://www.futuramaworld.de/schema/folge" nr="S03E07" cd="XIII">
     <titel>The Day the Earth stood stupid</titel>
      ...
    
    Verwendung eines anderen Prefixes:
    <schema xmlns="http://www.w3.org/2000/10/XMLSchema"
    			xmlns:ff="http://www.futuramaworld.de/schema/folge"
    			targetNamespace="http://www.futuramaworld.de/schema/folge"
    			elementFormDefault="qualified"
    			attributeFormDefault="unqualified">
    
    Hier ist im Schema kein Prefix für XML Schema Instruktionen und vordefinierte Datentypen notwendig:
     <element name="folge">
      <complexType>
       <sequence>
        <element name="titel" type="string"/>
        <element name="untertitel" type="string" minOccurs="0"/>
        <element name="autor" type="string" maxOccurs="3"/>
        <element name="ersteSendung" type="date" minOccurs="0"/>
        <element name="charaktere">
         <comlexType>
    	  <sequence>
    	   <element name="charakter" type="ff:charakter" minOccurs="0" maxOccurs="unbounded"/>
    	  </sequence> 
    	 </complexType>
        </element>
       </sequence>
       <attribute name="nr" type="ID" use="required"/>
       <attribute name="cd" type="ff:cd"/>
      </complexType>
     </element>
     <!-- etc. -->
    
    Im XML-Dokument:
    <aff:folge xmlns:aff="http://www.futuramaworld.de/schema/folge" nr="S03E07" cd="XIII">
     <aff:titel>The Day the Earth stood stupid</aff:titel>
     <!-- etc. -->
    </aff:folge>  
    

    Schemas auf mehrere Dokumente aufteilen

    Einfügen mittels include-Element (wichtig:gleicher namespace):
    <xsd:schema xmlns="http://www.w3.org/2000/10/XMLSchema"
    		xmlns:ff="http://www.futuramaworld.de/schema/folge"
    		targetNamespace="http://www.futuramaworld.de/schema/folge">
    
    <include schemaLocation="http://www.futuramaworld.de/schemas/charakter.xsd"/>
    <element name="folge">
    ...
    
    Bis auf die charakter-Typdefinition vollständig. Diese befindet sich in charakter.xsd:
    <xsd:schema xmlns="http://www.w3.org/2000/10/XMLSchema"
    				xmlns:ff="http://www.futuramaworld.de/schema/folge"
    				targetNamespace="http://www.futuramaworld.de/schema/folge">
    			   
     <complexType name="charakter">
      <sequence>
       <choice>
        <element name="name" type="string"/>
        <group ref="ff:nameGruppe"/>
       </choice>
       <element name="freund-von" type="string"/>
       <element name="qualifikation" type"string"/>
       <element name="hauptbeschaeftigung" type="string"/>
       <choice>
        <element name="roboter" type="string"/>
        <element name="mensch" type="string"/>
        <element name="alien" type="string"/>
       </choice>
      </sequence>
      <attributeGroup ref="ff:charakterAttributes"/>
     </complexType> 
     
     <!-- complexType-Extension -->
     
     <complexType name="deutscherCharakter">
      <complexContent>
       <extension base="ff:charakter">
        <sequence>
    	 <element name="sprecher" type="ff:nameType">
    	</sequence>
       </extension>
      </complexContent> 
     <xsd:complexType> 
     
     <!-- group&attributeGroup-Definitionen -->
    
    Um genau identifizieren zu können, welcher Typ im Instanzdokument eingesetzt werden soll, muss dieser über das "type"-Attribut, welches Teil des XML Schema instance namespace ist, angegeben werden.
    <?xml version="1.0" encoding="utf-8"?>
    
    <folge xmlns="http://www.futuramaworld.de/schema/folge"
    			xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    			nr="S03E07" cd="13">
     <titel>...</titel>
     ...
     <characktere>
      <charakter ersteFolge="S01E01" hauptCharakter="true" xsi:type="deutscherCharakter">
       <name>Leela</name>		 
       <!-- Standard charakter Angaben-->
       <sprecher>Marion Sawatzki</sprecher>
      </charakter>
     </charaktere>
    </folge>
    
    Bei unterschiedlichen namespaces in den Schemas benutzt man im einfügenden Schema das import-Element, um den neuen namespace zu importieren:
    <xsd:schema xmlns="http://www.w3.org/2000/10/XMLSchema"
    			xmlns:ff="http://www.futuramaworld.de/schema/folge"
    			targetNamespace="http://www.futuramaworld.de/schema/folge"
    			xmlns:ex="http://www.example.com/schema/"
    			elementFormDefault="qualified">
    	
    <import namespace="http://www.example.com/schema/" 
               schemaLocation="http://www.example.com/schema/charakter.xsd">
    ...
      <element name="charakter" type="ex:charakter" minOccurs="0" maxOccurs="unbounded">
      ...
    

    Bedingungen und Schlüssel

    Auf Basis von XPath(Untergruppe) bietet XML Schema einige Features, um Einzigartigkeits- und Referenzbedingungen zu defienieren.

    Einzigartigkeit(Uniqueness):
    Mit dem unique-Element kann bestimmt werden, daß ein Attribut oder Element in einem bestimmten Bereich einzigartig ist. Hier wird festgelegt, daß der Charaktername innerhalb einer Folge einzigartig sein soll:
    <xsd:element name="folge">
     <xsd:complexType>
     <!-- Standard Definitionen -->
     <xsd:/complexType>
     
     <xsd:unique name="charNameMustBeUnique">
      <xsd:selector xpath="charakter"/>
       <xsd:field xpath="name"/>
     </xsd:unique>
    </xsd:element>
    

    Referenzbedingungen(Keys):
    Dem unique sehr ähnlich ist das zweite Konstrukt key, welches einen Schlüssel definiert, d.h. es darf nicht null sein und kann referenziert werden.
    <xsd:key name="charNameIsKey">
     <xsd:selector xpath="charakter"/>
     <xsd:field xpath="name"/>
    </xsd:key>
    
    Zum Referenzieren wird nun das keyref-Element benutzt. Bedeutend ist, daß die Ordnung und Typen in den field-Elementreferenzen übereinstimmen.
    <xsd:keyref name="friendOfIsCharRef" refer="charNameIsKey">
     <xsd:selector xpath="charakter"/>
     <xsd:field xpath="freund-von"/>
    >/xsd:keyref>
    
    Nun muss jeder freund-von Eintrag mit einem Charakter in derselben Folge übereinstimmen.
    Diese Konstrukte können auf jedes Element und Attribut angewandt werden (unabhängig von ihrem Typ), dadurch ist XML Schema viel mächtiger als XML DTD, da ID nur ein Attributtyp ist. Schema ermöglicht auch den Bereich der Bedingungen anzugeben, wobei ID auf das ganze Dokument festgelegt ist.

    Wo bitte geht's zum Schema?

    schemaLocation
    Im Instanzdokument kann mit schemaLocation der Ort, an dem das zum XML-Dokument gehörende Schema zu finden ist, angegeben werden.
    <?xml version="1.0" encoding="utf-8"?>
    
    <folge xmlns="http://www.futuramaworld.de/schema/folge"
    		xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    		xsi:schemaLocation="http://www.futuramaworld.de/schema/folge
    		http://www.futuramaworld.de/schema/folge.xsd"
    		nr="S03E07" cd="13">
    	     
     <!-- etc. -->
     
    </folge>
    
    Der erste Wert gibt den namespace der zweite den Ort des Schemas an.
    Zwei weitere Gelegeheiten für schemaLocation sind die bereits vorgestellten include und import Definitionen.
    Wichtig ist, daß der Prozessor nicht verpflichtet ist, die Angabe zu befolgen. Sie dient nur als Hinweis und vom W3C vorgeschlagenen Vereinbarung.

    Das komplette Beispiel-Schema:

    <?xml version="1.0" encoding="utf-8"?>
    
    <xsd:schema xmlns:xsd="http://www.w3.org/2000/10/XMLSchema"
    			xmlns="http://www.futuramaworld.de/schema/folge"
    			targetNamespace="http://www.futuramaworld.de/schema/folge"
    			elementFormDefault="qualified"
    			attributeFormDefault="unqualified">
    			
    <include schemaLocation="http://www.futuramaworld.de/schemas/roemischeZahlen.xsd"/>			
    			
     <xsd:element name="folge">
      <xsd:complexType>
       <xsd:sequence>
        <xsd:element name="titel" type="xsd:string"/>
        <xsd:element name="untertitel" type="xsd:string" minOccurs="0"/>
        <xsd:element name="autor" type="xsd:string" maxOccurs="3"/>
        <xsd:element name="ersteSendung" type="xsd:date" minOccurs="0"/>
        <xsd:element name="charaktere">
         <xsd:comlexType>
    	  <xsd:sequence>
    	   <xsd:element name="charakter" type="charakter" minOccurs="0" maxOccurs="unbounded"/>
    	  </xsd:sequence> 
    	 </xsd:complexType>
        </xsd:element>
       </xsd:sequence>
       <xsd:attribute name="nr" type="episode" use="required"/>
       <xsd:attribute name="cd" type="cd"/>
      </xsd:complexType>
      
      <xsd:key name="charNameIsKey">
       <xsd:selector xpath="charakter"/>
       <xsd:field xpath="name"/>
      </xsd:key>
    
      <xsd:keyref name="friendOfIsCharRef" refer="charNameIsKey">
       <xsd:selector xpath="charakter"/>
       <xsd:field xpath="freund-von"/>
      >/xsd:keyref>
      
     </xsd:element>
    
     <!-- Typdefinitionen: -->
     
     <xsd:complexType name="charakter">
      <xsd:sequence>
       <xsd:choice>
        <xsd:element name="name" type="nameType"/>
        <xsd:group ref="nameGruppe"/>
       </xsd:choice>
       <xsd:element name="freund-von" type="xsd:string"/>
       <xsd:element name="qualifikation" type"xsd:string"/>
       <xsd:element name="hauptbeschaeftigung" type="listeHauptbeschäftigung"/>
       <xsd:choice>
        <xsd:element name="roboter" type="empty"/>
        <xsd:element name="mensch" type="empty"/>
        <xsd:element name="alien" type="empty"/>
       </xsd:choice>
      </xsd:sequence>
      <xsd:attributeGroup ref="charakterAttributes"/>
     </xsd:complexType> 
     
     <xsd:simpleType name="nameType">
      <xsd:restriction base="xsd:string">
       <xsd:maxLength value="32"/>
      </xsd:restriction>
     </xsd:simpleType>
    
     <xsd:simpleType name="episode">
      <xsd:restriction base="xsd:string">
       <xsd:pattern value="S\d{2}E\d{2}"/>
      </xsd:restriction>
     </xsd:simpleType>
    
     <xsd:simpleType name="cd">
      <xsd:union memberTypes="xsd:positiveInteger roemischeZahlen">
     </xsd:simpleType>
    
     <xsd:complexType name="empty">
      <xsd:complexContent>
       <xsd:restriction base="xsd:anyType">
      </xsd:complexContent>
     </xsd:complexType>
    
     <xsd:simpleType name="hauptbeschäftigung">
      <xsd:restriction base="xsd:string">
       <xsd:enumeration value="Trinken"/>
       <xsd:enumeration value="Stehlen"/>
       <xsd:enumeration value="Leutereinlegen"/>
       <xsd:enumeration value="in-Unterhosen-Rumhängen"/>
       <xsd:enumeration value="Slurm-Trinken"/>
       <xsd:enumeration value="Geldverdienen"/>
      </xsd:restriction>
     </xsd:simpleType>
    
     <xsd:simpleType name="listeHauptbeschäftigung">
      <xsd:list itemType="hauptbeschäftigung"/>
     </xsd:simpleType>
    
     
     <!-- Gruppendefinitionen: -->
     
     <xsd:group name="nameGruppe">
      <xsd:sequence>
       <xsd:element name="vorName" type="nameType"/>
       <xsd:element name="zuName" type="nameType" minOccurs="0"/>
       <xsd:element name="nachName" type="nameType"/>
      </xsd:sequence>
     </xsd:group>
     
     <xsd:attributeGroup name="charakterAttributes">
      <xsd:attribute name="ersteFolge" type="episode" use="required"/>
      <xsd:attribute name="hauptCharakter" type="xsd:boolean" default="false"/>
     </xsd:attributeGroup>
    
    </xsd:schema>
    

    4.3. XML Schema Teil 2: Datatypes

    4.4. Reguläre Ausdrücke

    Beispiele für Reguläre Ausdrücke
    Expression Match(s)
    Chapter \d Chapter 0, Chapter 1, Chapter 2 ....
    Chapter\s\d Chapter followed by a single whitespace character (space, tab, newline, etc.), followed by a single digit
    Chapter\s\w Chapter followed by a single whitespace character (space, tab, newline, etc.), followed by a word character (XML 1.0 Letter or Digit)
    Espan&#xF1;ola Española
    \p{Lu} any uppercase character, the value of \p{} (e.g. "Lu") is defined by Unicode
    \p{IsGreek} any Greek character, the 'Is' construction may be applied to any block name (e.g. "Greek") as defined by Unicode
    \P{IsGreek} any non-Greek character, the 'Is' construction may be applied to any block name (e.g. "Greek") as defined by Unicode
    a*x x, ax, aax, aaax ....
    a?x ax, x
    a+x ax, aax, aaax ....
    (a|b)+x ax, bx, aax, abx, bax, bbx, aaax, aabx, abax, abbx, baax, babx, bbax, bbbx, aaaax ....
    [abcde]x ax, bx, cx, dx, ex
    [a-e]x ax, bx, cx, dx, ex
    [-ae]x -x, ax, ex
    [ae-]x ax, ex, -x
    [^0-9]x any non-digit character followed by the character x
    \Dx any non-digit character followed by the character x
    .x any character followed by the character x
    .*abc.* 1x2abc, abc1x2, z3456abchooray ....
    ab{2}x abbx
    ab{2,4}x abbx, abbbx, abbbbx
    ab{2,}x abbx, abbbx, abbbbx ....
    (ab){2}x ababx

    4.5. Dos and Don'ts

    Kohsuke KAWAGUCHI hat eine Reihe von Hinweisen für die gute und einfache Benutzung von XML Schema aufgestellt. Sein Rat: Betrachte W3C XML Schema als DTD + datatype + namespace
    • DO use element declarations, attribute groups, model groups and simple types.
    • DO use XML namespaces as much as possible. Learn the correct way to use them.

    Here are some DON'Ts.

    4.6. Tools &Validators

    Es gibt bereits einige Tools, um XML Dokumente gemäß ihrem Schema zu validieren. Das bisher vollständigste Tool ist SQC.
  • SQC Schema Quality Checker von IBM vom 21. Mai 2001
  • XSV XML Schema Validator von der University of Edinburgh und dem W3C vom 7.5.2001
  • 5. TREX & RELAX

    5.1 RELAX

    5.1.1 Einleitung

  • Entwickelt von Murata Makoto
  • Aktuelle Version vom 26.08.2000 mit Erweiterungen vom 01.11.2000
  • Bei der ISO eingereicht
  • Eine Beschreibung in RELAX wird RELAX grammar genannt
  • Ein RELAX grammar kann als XML-Dokument geschrieben werden
  • RELAX ist aufgeteilt in RELAX Core und RELAX Namespace
  • RELAX Core benutzt die Datentypen aus XML Schema Part 2
  • RELAX Namespace ist noch nicht vollständig definiert
  • RELAX kann Namespaces benutzen wie XML Schema
  • RELAX unterstützt keine default-Werte
  • RELAX unterstüzt keine Regel-Bedingungen (XPath-rules)
  • RELAX spezifiziert keine Möglichkeit ein XML Dokument mit einem RELAX pattern zu assoziieren
  • RELAX hat keinen Einfluß auf das post-validation infoset (PVSI)
  • RELAX ist im Vergleich mit XML Schema light weight
  • 5.1.2. RELAX Sprachdefiniton

    Ein RELAX Grammar beginnt mit dem tag module im Unterschied zu schema in XML Schema.
    Mit der Angabe der Datei/Grammar Version, der RELAX-Version und den Namespaceangaben:
    <module
          moduleVersion="1.2"
          relaxCoreVersion="1.0"
          targetNamespace=""
          xmlns="http://www.xml.gr.jp/xmlns/relaxCore">
    
    Gefolgt wird es vom interface Element, welches das root-Element angibt.
     <interface>
          <export label="folge"/>
     </interface>
    
    Elemente:
    Elementendeklarationen (<!ELEMENT ...>) werden durch elementRule Elemente repräsentiert. Sie definieren den Inhalt. Die Attribute werden in einem zugehörigen tag Element verwaltet. elementRule hat die Attribute role und label.
    Das leere Element <br/> aus XHTML würde so spezifiziert werden:
    <elementRule role="br" label="br">
        <empty/>
    </elementRule>
    <tag name="br"/>
    
    <elementRule role="tr">
     <choice occurs="*">
      <ref label="td"/>
      <ref label="th"/>
     </choice>
    </elementRule>
    
    <elementRule role="td" type="string"/>
    <tag name="td"/>
    
    <elementRule role="th" type="string"/>
    <tag name="th"/>
    
    Das occurs Attribut kann mit dem <choice>, <sequence>, oder <ref> tag benutzt werden.
    Das Groupelement in RELAX nennt sich hedgeRule (referenziert mittels hedgeRef):
     <hedgeRule label="nameGruppe">
      <sequence>
       <ref label="vorName"/>
       <ref label="zuName" occurs="?"/>
       <ref label="nachName"/>
      </sequence>
     </hedgeRule>
     
     <elementRule role="vorName" type="string"/>
     <elementRule role="zuName" type="string" />
     <elementRule role="nachName" type="string"/>
    
    Attribute:
    Attribute werden über das <tag> Element genauer definiert:
    <tag name="img">
    <attribute name="src" required="true" type="string"/>
    <attribute name="width" type="positiveInteger"/>
    <attribute name="height" type="positiveInteger"/>
    </tag>
    
    Wie im XML Schema gibt es auch in RELAX ein Pendant zum hedgeRule den attPool.
    <attPool role="alignment">
    <attribute name="align" type="string">
    <enumeration value="left"/>
    <enumeration value="center"/>
    <enumeration value="right"/>
    <enumeration value="justify"/>
    </attribute>
    <attribute name="valign" type="string">
    <enumeration value="top"/>
    <enumeration value="middle"/>
    <enumeration value="bottom"/>
    <enumeration value="baseline"/>
    </attribute>
    </attPool>
    
    <tag name="th">
    <ref role="alignment"/>
    <attribute name="rowspan" type="integer">
    <minInclusive value="1"/>
    </attribute>
    </tag>
    
    Annotation:
    Annotation funktioniert auf die gleiche Weise wie unter XML Schema.

    Aufteilung auf mehrere Module:
    Ein Modul kann ein anderes Modul mittels <include> Element referenzieren:
    <include moduleLocation="charakter.rlx" />
    
    Das Definieren eines Elementes mit einfachem Typ und Attributen ist im Unterschied zu XML Schema sehr einfach (hier mit embedded tag Element):
    <elementRule label="ersteSendung" type="date">
     <tag>
      <attribute name="wiederholung" type="positiveInteger"/>
     </tag>
    </elementRule>
    

    5.1.3 RELAX now

    Ein RELAX Grammar für unser Folge-Schema
    <module
          moduleVersion="1.2"
          relaxCoreVersion="1.0"
          targetNamespace=""
          xmlns="http://www.xml.gr.jp/xmlns/relaxCore"
    	  xmlns:xsd="http://www.w3.org/2000/10/XMLSchema">
    	  
     <interface>
          <export label="folge"/>
     </interface>
     
     <elementRule role="folge">
      <sequence>
       <ref label="titel"/>
       <ref label="untertitel" occurs="?"/>
       <ref label="autor" occurs="+"/>
       <ref label="ersteSendung" occurs="?">
       <ref label="charaktere">
      </sequence>
     </elementRule>
     
     <elementRule role="titel" type="string">
     
     <elementRule role="untertitel" type="string">
     
     <elementRule role="autor" type="string">
     
     <elementRule role="ersteSendung" type="xsd:date">
      
     <elementRule role="charaktere">
      <sequence>
       <ref label="charakter" occurs="*"/>
      </sequence>
     </elementRule>
     
     <elementRule role="charakter">
      <sequence>
       <choice>
    	<ref label="name"/>
    	<hedgeRef label="nameGruppe">
       </choice>
       <ref label="freund-von"/>
       <ref label="qualifikation"/>
       <ref label="hauptbeschaeftigung"/>
       <choice>
    	<ref label="roboter"/>
    	<ref label="mensch"/>
    	<ref label="alien"/>
       </choice>
      </sequence>
     <elementRule>
     
     <elementRule role="name" type="string">
     
     <elementRule role="freund-von" type="string">
    
     <elementRule role="qualifiaktion" type="string">
     
     <elementRule role="hauptbeschaeftigung" type="string">
     
     <elementRule role="roboter">
      <empty/>
     </elementRule>
     <elementRule role="mensch">
      <empty/>
     </elementRule>
     <elementRule role="alien">
      <empty/>
     </elementRule>
     
     <hedgeRule label="nameGruppe">
      <sequence>
       <ref label="vorName"/>
       <ref label="zuName" occurs="?"/>
       <ref label="nachName"/>
      </sequence>
     </hedgeRule>
     
     <elementRule role="vorName" type="string"/>
     <elementRule role="zuName" type="string" />
     <elementRule role="nachName" type="string"/> 	  
    
     <tag name="vorName"/>
     <tag name="zuName"/>
     <tag name="nachName"/>
     <tag name="name"/>
     <tag name="alien"/>
     <tag name="mensch"/>
     <tag name="roboter"/>
     <tag name="hauptbeschaeftigung"/>
     <tag name="qualifikation"/> 
     <tag name="freund-von"/>
     <tag name="charaktere"/>
     <tag name="ersteSendung"/>
     <tag name="untertitel"/>    
     <tag name="autor"/>
     <tag name="titel"/>  
     
     <tag name="charakter">
      <attribute name="ersteFolge" required="true" type="NMTOKEN"/>
      <attribute name="hauptcharakter" type="xsd:boolean"/>
     </tag>
      
     <tag name="folge">  
      <attribute name="nr" required="true" type="NMTOKEN"/>
      <attribute name="cd" type="xsd:positiveInteger"/>
     </tag>
     
    </module>
    

    5.2 TREX

    5.2.1 Einleitung

    TREX ist seit dem 8.6.2001 in RELAX NG aufgegangen!

  • Entwickelt von James Clark
  • Aktuelle Version vom 20.01.2001
  • Entwickelt für OASIS
  • Eine Beschreibung in TREX wird TREX pattern genannt
  • Ein TREX pattern kann als XML-Dokument geschrieben werden
  • Ein TREX pattern bildet eine Klasse von Dokumenten, die dem pattern entsprechen
  • TREX benutzt die Datentypen aus XML Schema Part 2
  • TREX kann Namespaces benutzen wie XML Schema
  • TREX unterstützt keine default-Werte
  • TREX unterstüzt keine Regel-Bedingungen (XPath-rules)
  • TREX spezifiziert nicht, ob white-space signifikant ist
  • TREX spezifiziert keine Möglichkeit ein XML Dokument mit einem TREX pattern zu assoziieren
  • TREX hat keinen Einfluß auf das post-validation infoset (PVSI)
  • TREX ist im Vergleich mit XML Schema light weight
  • 5.2.2. TREX Sprachdefiniton

    Ein TREX pattern beginnt (mit dem root-Element oder) mit dem <grammar> Element, welchem das <start> Element folgt.
    <grammar>
       <start>
          <element name="ein_root_element">
          <!-- specifications go here -->
          </element>
       </start>
    </grammar>
    
    Elemente:
    <elment name="charakter">
     <choice>
      <element name="name">
       <anyString/>
      </element>
      <group>
       <element name="vorName">
        <anyString/>
       </element>
       <optional>
        <element name="zuName">
         <anyString/>
        </element>
       </optional>
       <element name="nachName">
        <anyString/>
       </element>
      </group>
     </choice>
     <optional>
      <element name="freund-von">
       <anyString/>
      </element>
     </optional>
     <element name="qualifikation">
      <anyString/>
     </element>
     <element name=hauptbeschaeftigung">
      <anyString/>
     </element>
     <attribute name="ersteFolge">
      <anyString/>
     </attribute>
     <attribute name="hauptCharakter">
      <choice>
       <string>true</string>
       <string>false</string>
      </choice>
     </attribute>
    </element>
    
    Modularisierung eines patterns mittels <start> und <define>:
    <grammar>
    
      <start>
        <element name="addressBook">
          <zeroOrMore>
    	<element name="card">
    	  <ref name="cardContent"/>
    	</element>
          </zeroOrMore>
        </element>
      </start>
    
      <define name="cardContent">
        <element name="name">
          <anyString/>
        </element>
        <element name="email">
          <anyString/>
        </element>
      </define>
    
    </grammar>
    
    Aufteilung auf mehrere patterns:
    Ein pattern kann ein anderes pattern mittels <include> Element referenzieren:
    <include href="insert.trex"/>
    
    Falls es bei zwei gemischten grammars zu duplikaten Definitionen kommt, ist mittels combine Attribut eine Vorgehensweise zu spezifizieren. Die addressBook.trex Datei:
    <grammar>
    
     <start>
      <element name="addressBook">
       <zeroOrMore>
        <element name="card">
         <element name="name">
          <anyString/>
         </element>
         <element name="email">
          <anyString/>
         </element>
         <ref name="card.local"/>
        </element>
       </zeroOrMore>
      </element>
     </start>
    
     <define name="card.local">
      <empty/>
     </define>
    
    </grammar>
    
    Ein weiteres pattern kann addressBook.trex so benutzen:
    <grammar>
    
     <include href="addressBook.trex"/>
    
      <define name="card.local" combine="replace">
       <optional>
        <element name="note">
    	 <anyString/>
        </element>
       </optional>
      </define>
    
    </grammar>
    
    Daneben gibt es noch "group" und "choice" als mögliche Attributwerte für combine.
    Diese fügen die neue Definition mit der "alten" zusammen in ein group bzw. choice Element ein.

    Datentypen:
    TREX kann z.B. auf die in XML Schema eingebauten Datentypen über das Element <data> zugreifen:
    <element name="number" xmlns:xsd="http://www.w3.org/2000/10/XMLSchema">
     <data type="xsd:integer"/>
    </element>
    
    Weiterhin kann auch das XML Schema Konstrukt der Faceten in TREX genutzt werden:
    <trex:element name="age"
        xmlns:xsd="http://www.w3.org/2000/10/XMLSchema"
        xmlns:trex="http://www.thaiopensource.com/trex">
      <xsd:restriction base="xsd:nonNegativeInteger" trex:role="datatype">
        <xsd:maxInclusive value="150"/>
      </xsd:restriction>
    </trex:element>
    

    5.2.3 TREX it baby

    Ein TREX pattern für unser Folge-Schema
    <grammar xmlns:xsd="http://www.w3.org/2000/10/XMLSchema"
    		xmlns="http://www.thaiopensource.com/trex">
    
     <start>
      <ref name="folge"/>
     </start>
     
     <define name="folge"/>
      <element name="folge">
       <element name="titel">
        <anyString/>
       </element>
       <optional>
        <element name="untertitel">
         <anyString/>
        </element>
       </optional>
       <oneOrMore>
        <element name="autor">
         <anyString/>
        </element>
       </oneOrMore>
       <optional>
        <element name="ersteSendung">
         <data type="xsd:date"/>
        </element>
       <optional>
       <element name="charaktere">
        <zeroOrMore>
         <ref label="charakter"/>
    	</zeroOrMore>
       </element>
       <attribute name="nr">
        <anyString>
       </attribute>
       <attribute name="cd">
        <data type="xsd:positiveInteger"/>
       </attribute>
      </element>
     </define>
       
    <define name="charakter">  
     <elment name="charakter">
      <choice>
       <element name="name">
        <anyString/>
       </element>
       <group>
        <element name="vorName">
         <anyString/>
        </element>
        <optional>
         <element name="zuName">
          <anyString/>
         </element>
        </optional>
        <element name="nachName">
         <anyString/>
        </element>
       </group>
      </choice>
      <optional>
       <element name="freund-von">
        <anyString/>
       </element>
      </optional>
      <element name="qualifikation">
       <anyString/>
      </element>
      <element name=hauptbeschaeftigung">
       <anyString/>
      </element>
      <attribute name="ersteFolge">
       <anyString/>
      </attribute>
      <attribute name="hauptCharakter">
       <choice>
        <string>true</string>
        <string>false</string>
       </choice>
      </attribute>
     </element>
    </define>
    
    </grammar>
    

    6. Schematron

    6.1. Pfad-Ausdruck-/Regel-basiert Definition

    Es werden Regeln definiert die an die Knoten des Dokumentes gestellt werden.
    Wird eine Regel verletzt(assert) oder eingehalten(report), so kann dies zu einer Aktion führen.
  • Basieren auf XPath-und XSLT-Ausdrücken
  • Ähneln der SQL-Syntax: Selektor(rule) trifft Wahl, Feld(assert/report) vergleicht Bedingung
  • Sind auf alle information items (Elemente, Attribute, Entities,...) anwendbar
  • 6.2. Schematron

    6.2.1 Einleitung

    Schematron ist eine Sprache zur Spezifizierung und Deklarierung von Feststellungen(assertions) über beliebige Muster in XML-Dokumenten, basiert auf der Präsenz oder Abwesenheit von Namen und Werten in Elementen und Attributen entlang von Pfaden. Die Gebrauchsfelder liegen bei document validation, zur automatischen Erstellung von externen markup und behinderten Menschen den Zugang zu Dokumenten zu erleichtern.

  • Entwickelt von Rick Jelliffe
  • Aktuelle Version 1.5 vom 17.3.2001
  • Entwickelt beim Academia Sinica Computing Centre, Taibei
  • Eine Beschreibung in Schematron wird Schematron schema genannt
  • Ein Schematron schema kann als XML-Dokument geschrieben werden
  • Schematron ist offen
  • Schematron benutzt Namespaces (wie XML Schema)
  • Schematron ist Regel-basiert mit einer fixen 4-Schicht-Hierarchie(phases, patterns, rules, assertions)
  • Schematron benutzt Pfad-Ausdrücke: XPath und XSLT werden benutzt
  • Schematron wurde entwickelt, um enfachst in XSLT implementiert zu werden:Schematron 1.5 Reference Implementation for XSLT
  • Schematron kann auf die Datentypen aus XML Schema Part 2 zugreifen
  • 6.2.2. Schematron Sprachdefiniton

    Ein Schematron schema beginnt mit dem <schema> Element, gefolgt von <titel>, <ns>, <p>, <phase>, <pattern> und <diagnostics>.
    In patterns sind rules und assertions/reports eingebettet.
    <?xml version="1.0" encoding="US-ASCII"?>
    <sch:schema xmlns:sch="http://www.ascc.net/xml/schematron">
     <sch:title>Example Schematron Schema</sch:title>
     <sch:pattern>
       <sch:rule context="dog">
        <sch:assert test="count(ear) = 2"
        >A 'dog' element should contain two 'ear' elements.</sch:assert>
        <sch:report test="bone"
        >This dog has a bone.</sch:report>
       </sch:rule>
      </sch:pattern>
    </sch:schema>
    
    Der Einsatz von Phases:
    <phase id="basicValidation">
      <active pattern="text" />
      <active pattern="tables" />
      <active pattern="attributePresence" />
    </phase>
    <phase id="fullValidation">
      <active pattern="metadata" />
      <active pattern="text" />
      <active pattern="tables" />
      <active pattern="attributePresence" />
      <active pattern="attributeValueChecks" />
    </phase>
    
    Einsatz von Diagnostics:
    <rule context="dog" >
       <assert test="nose | @exceptional='true'" diagnostics="d1 d2"
       >A dog should have a nose.</assert>
    </rule>
    ...
    <diagnostics>
     <diagnostic id="d1"
     >Your dog <value-of select="@petname" /> has no nose. 
     How does he smell? Terrible. Give him a nose element,
     putting it after the <name path="child::*[2]"/> element.
     </diagnostic>
     <diagnostic id="d2"
     >Animals such as <name/> usually come with a full complement
     of legs, ears and noses, etc. However, exceptions are possible.
     If your dog is exceptional, provide an attribute
     <emph>exceptional='true'</emph>
    </diagnostic>
    </diagnostics>
    
    Schematron definiert:
  • Schematron 1.5 Schema for Schematron 1.5
  • XML Schema for Schematron 1.5
  • XML DTD for Schematron 1.5
  • 6.2.3. Schematron Beispiele:

    Test, if the value of an element is an integer
    <schema>
         <pattern name = 'Test integer'>
              <rule context = "AAA">
                   <report test = "floor(.) = number(.)">O.K.</report>
                   <assert test = "floor(.) = number(.)">The AAA value is not an integer.</assert>
              </rule>
        </pattern>
    </schema>
    

    The element must have the attribute, if it is inside another one, but it must not have the one otherwise
    <schema>
         <pattern name = 'Test attribute'>
              <rule context = "CCC">
    	           <report test = "parent::BBB and not(@id)">Attribute id is missing</report>
                   <assert test = "not(parent::BBB) and @id">Attribute id is used in wrong context</assert>
              </rule>
        </pattern>
    </schema>
    
    XML1:
    <AAA>
         <CCC id='Q2'/>
         <CCC/>
         <BBB>
              <CCC id='Q1'/>
         </BBB>
    </AAA>
    
    Output: Attribute id is used in wrong context

    XML2:
    <AAA>
         <CCC/>
         <CCC/>
         <BBB>
              <CCC/>
         </BBB>
    </AAA>
    
    Output: Attribute id is missing

    If the element has one attribute then it must have the second one as well.
    <schema>
         <pattern name = 'Attribute present'>
              <rule context = "BBB">
    			<assert test = "not(@aaa) or (@aaa and @bbb)">The element must not have an isolated aaa attribute</report>
    			<assert test = "not(@bbb) or (@aaa and @bbb)">The element must not have an isolated bbb attribute</assert>
              </rule>
        </pattern>
    </schema>
    
    XML1:
    <AAA>
           <BBB aaa="A"/>
    </AAA>
    
    Output: The element must not have an isolated aaa attribute

    The sum of values of all relevant elements equals 100.
    <schema>
         <pattern name = 'Sum equals 100%'>
              <rule context = "Total">
    		       <assert test = "sum(//Percent) = 100">The values do not sum to 100%</assert>
              </rule>
        </pattern>
    </schema>
    
    XML1:
    <Total>
         <Percent>20</Percent>
         <Percent>30</Percent>
         <Percent>10</Percent>
         <Percent>50</Percent>
    </Total>
    
    Output: The values do not sum to 100%

    A paragraph in XML 2 can only start with words specified in XML 1 (file source1.xml)
    <schema>
         <pattern name = 'Start of paragraph restriction'>
              <rule context = "p">
    		       <assert test = "document('source1.xml')//*[name()=substring-before(current(),' ')]">The word at the beginning of sentence is not listed in XML 1.</assert>
              </rule>
        </pattern>
    </schema>
    
    XML1:
    <list>
         <Alice/>
         <Peter/>
         <Paul/>
    </list>
    
    XML2:
    <Document>
         <p>Alice is a nice girl.</p>
         <p>Where is Peter.</p>
         <p>Paul was invited.</p>
         <p>But Paul did not come.</p>
    </Document>
    
    Output: The word at the beginning of sentence is not listed in XML 1.
    The word at the beginning of sentence is not listed in XML 1.
    Das Folge Beispiel in Schematron:
    <?xml version="1.0" encoding="US-ASCII"?>
    <sch:schema xmlns:sch="http://www.ascc.net/xml/schematron">
     <sch:title>Futurama-Folge Schematron Schema</sch:title>
     
     <sch:pattern name="Root test">
       <sch:rule context="/*">
        <sch:assert test="name()='folge'"> folge element ist nicht das root-Element.</sch:assert>
       </sch:rule>
      </sch:pattern>
    
    
     <sch:pattern name="titel check">
       <sch:rule context="folge">
        <sch:assert test="titel"> titel-Element fehlt.</sch:assert>
       </sch:rule>
      </sch:pattern>
      
      <sch:pattern name="untertitel check">
       <sch:rule context="folge">
        <sch:assert test="untertitel"> untertitel-Element fehlt.</sch:assert>
       </sch:rule>
      </sch:pattern>
      
      <sch:pattern name="autor check">
       <sch:rule context="folge">
        <sch:assert test="autor"> autor-Element fehlt.</sch:assert>
       </sch:rule>
      </sch:pattern>
      
      <sch:pattern name="ersteSendung check">
       <sch:rule context="folge">
        <sch:assert test="ersteSendung"> ersteSendung-Element fehlt.</sch:assert>
       </sch:rule>
      </sch:pattern>
      
      <sch:pattern name="charaktere check">
       <sch:rule context="folge">
        <sch:assert test="charakere"> charaktere-Element fehlt.</sch:assert>
       </sch:rule>
      </sch:pattern>
      
      <sch:pattern name="charakter check">
       <sch:rule context="charaktere">
        <sch:assert test="charakter"> charakter-Element fehlt.</sch:assert>
       </sch:rule>
      </sch:pattern>
      
      <sch:pattern name="name check">
       <sch:rule context="charakter">
        <sch:assert test="name or nachName"> name-Elemente fehlen.</sch:assert>
       </sch:rule>
      </sch:pattern>
      
      <sch:pattern name="freund-von check">
       <sch:rule context="charakter">
        <sch:assert test="freund-von"> freund-von-Element fehlt.</sch:assert>
       </sch:rule>
      </sch:pattern>
      
      <sch:pattern name="qualifikation check">
       <sch:rule context="charakter">
        <sch:assert test="qualifikation"> qualifikation-Element fehlt.</sch:assert>
       </sch:rule>
      </sch:pattern>
      
      <sch:pattern name="hauptbeschaeftigung check">
       <sch:rule context="charakter">
        <sch:assert test="hauptbeschaeftigung"> hauptbeschaeftigung-Element fehlt.</sch:assert>
       </sch:rule>
      </sch:pattern>
      
      <sch:pattern name="lebensform check">
       <sch:rule context="charakter">
        <sch:assert test="roboter or mensch or alien"> lebensform-Element fehlt.</sch:assert>
       </sch:rule>
      </sch:pattern>
     
     <sch:pattern name="nr attrib">
       <sch:rule context="folge">
        <sch:assert test="@nr"> element fogle vermisst attribut nr.</sch:assert>
       </sch:rule>
      </sch:pattern>
     
     <sch:pattern name="cd attrib">
       <sch:rule context="folge">
        <sch:assert test="@cd"> element fogle vermisst attribut cd.</sch:assert>
       </sch:rule>
       <sch:rule context="folge@cd">
        <sch:assert test="floor(.) = number(.)"> attribut cd muss integer sein.</sch:assert>
       </sch:rule>
      </sch:pattern>
      
      <!-- und noch viele viele mehr -->
      
    </sch:schema>
    
    

    7. Schemarama Teil 2

    7.1. Bewertung

    Das W3C verfolgt mit Schema die Strategie einer allround-Definitionsprache, indem Sie alle geforderten Features einbaut und dadurch das Ziel "80/20" der Reduktion von SGML-Komplexität verwirft. Die beteiligten Unternehmen werden mit XML Schema nur wenig Probleme haben, ob es aber eine breite Unterstützung im Web bekommt ist doch anhand der Komplexität zu bezweifeln.
    Sicher macht es Sinn mit Schema volle Kompatibilität zu DTD zu schaffen, doch ist die konsequente Absage von TREX/RELAX das PSVI zu verändern, eine richtige Entscheidung im Hinblick auf die Losgelöstheit von Schema und XML-Dokument. Der Weg derartiger Defaultwerte der eingebetteten DTD zu überlassen ist richtig und unglücklich zugleich.
    Der Versuch in XML Schema Regel-basierte Bedingungen aufzunehmen ist ein zögerliches Zeichen für eine Erweiterung in dieser Richtung. Für absolute Validierung führt an Schematron jedoch kein Weg vorbei.
    Ziel für die Entwickler um Schematron sollte es sein, die Vorzüge von Grammars für Schematron nützlich zu machen. Dennoch ist der Einsatz von Schematron nicht als universal zu sehen. Gerade das Web wird die Macht, die es bietet, mit der ungewohnten Anwendung in Abwegung stellen und eine einfache Grammarsprache für die alltäglichen Dokumente vorziehen.
    Während TREX/RELAX versuchen möglichst einfach, knapp und richtig(auf solidem theoretischen Fundament stehen) zu sein, versucht Schematron alle Bedingungen an information items (Elemente der Dokumente) zu bieten. XML Schema schließlich versucht einen Mix aus allem, um jedem Nutzer möglichst gerecht zu werden.
    Zu RELAX NG lässt sich noch nicht abschließend urteilen, doch die Verbesserungen gegenüber TREX und RELAX Core sind deutlich. Auch wenn es nicht die Absicht der Entwickler ist XML Schema zu ersetzen, so kommen sie mit diesem Vorschlag doch sehr in die Nähe der Funktionalität von Schema.

    7.2. Einsatzgebiete

    Grammar-basierte Sprachen:
  • Electronic commerce und business
  • Optimierte Suchanfragen
  • Verbindung zu Datenbanken
  • Die automatische Erstellung von Interfaces für Prozesse
  • Einfaches Mapping zu Prgrammiersprachen/Anwendungen
  • XHTML
  • Schematron:
  • Dokumenten-Erstellungswerkzeuge, automatische online-Kontrolle
  • Unterschieldliche Versionen, durch phases
  • Komplexe Bedingungsaufgaben

  • 7.3. Ausblick

    Seit Mai ist nun XML Schema eine W3C Recommendation und das W3C ist bemüht, zukünftige Entwicklungen (z.B. XSLT 2.0) darauf aufzubauen.
    Nachdem RELAX Core im Mai bei der ISO als ISO/IEC Technical Report genehmigt wurde, haben sich James Clark und Murata Makoto nun geeinigt ihre Spezifikationen in RELAX NG zusammen zufassen . Working Draft vom 8. Juni 2001.(Tutorial)
    Von Rick Jelliffe ist derzeit nichts bekannt, dass er seine Sprache zum Standard erheben lassen will oder doch noch versucht, mit dem Team um RELAX NG zur Einigung zu kommen.

    8. Ressourcen


    8.1. Quellen

  • W3C XML Schema Recommendation Part 0: Primer
  • W3C XML Schema Recommendation Part 1: Structures
  • W3C XML Schema Recommendation Part 2: Datatypes
  • XML Schema Requirements W3C Note 15 Feb 1999
  • W3C XML Schema: DOs and DON'Ts von Kohsuke KAWAGUCHI
  • TREX Basics von J. David Eisenberg April 11, 2001
  • TREX: a language to describe XML document structure von Eric van der Vlist 8 Jan 2001
  • HOW TO RELAX von MURATA Makoto 26 Aug 2000
  • Learning to RELAX von J. David Eisenberg October 16, 2000
  • The Schematron Assertion Language 1.5 von Rick Jelliffe 17 Mar 2001
  • Validating XML with Schematron von Chimezie Ogbuji 22 November 2000
  • XSLT Recommendation
  • XPath Recommendation
  • RELAX NG Tutorial von James Clark und Makoto MURATA 8 Juni 2001
  • Schemas by Example von Leigh Dodds 28 Mar 2001
  • Schemarama von Leigh Dodds 7 Feb 2001
  • Comparative Analysis of Six XML Schema Languages von Dongwon Lee und Wesley W. Chu Aug 2000
  • Parsing the Atom von Leigh Dodds, 25 April 2001 auf xml.com
  • XML Ain't What It Used To Be von Simon St. Laurent, 28 Feb 2001 auf xml.com
  • W3C XML Schema still has big problems von Edd Dumbill, 6 Mar 2001 auf xmlhack.com
  • The XML Schema Specification in Context von Rick Jelliffe 24 Feb 2000 auf ascc.net
  • Best Practices auf xfront.com

  • 8.2. Links

    Links, Portale und Verzeichnisse:
  • W3C
  • XML.COM XML From the Inside Out(O'Reilly)
  • XML.ORG - The XML Industry Portal
  • The official site of RELAX
  • TREX auf thaiopensource.com
  • OASIS
  • James Clark Homepage
  • XFornt.com einige Tutorials und Beispiele
  • XML Everywhere Verzeichnis
  • Schematron Beispiele auf zvon.org
  • Vielen Dank für Ihre Aufmerksamkeit.