Kapitola 3. XML schémata

Datové typy jsou samotným základem XML schémat, protože v nich je v podstatě vše datový typ. Jak jsme již řekli, datové typy mohou být jednoduché či komplexní.

Největší síla XML schémat spočívá v možnosti definovat si vlastní datové typy. Ty přitom mohou vznikat zejména restrikcí nebo rozšířením některého z již existujících typů. Jako základ pro odvozování našich uživatelských typů můžeme použít některý ze zabudovaných typů. Na obrázku 3.1 – „Hierarchie zabudovaných datových typů“ si můžete prohlédnout hierarchii zabudovaných datových typů. Obrázek byl převzat přímo ze specifikace [8].

XML schémata obsahují běžné základní datové typy jako textový řetězec, celá a desetinná čísla, binární data, logická hodnota, datum, čas, časový interval a několik typů převzatých z DTD pro jejich snazší konverzi do XML schémat. V mnoha případech si s těmito typy vystačíme. Naše první ukázka si například naprosto vystačila se zabudovanými typy pro textové řetězce (string), datum (date) a desetinné číslo (decimal).

Obrázek 3.1. Hierarchie zabudovaných datových typů

Vyžadujeme-li však v aplikacích striktnější kontrolu dat, musíme si od zabudovaných typů odvodit vlastní typy. Nejběžnějším způsobem odvození je restrikce, kdy pomocí integritních omezení zúžíme obor přípustných hodnot. Kromě toho lze odvozovat nové typy vytvořením seznamu a sjednocením typů.

w
x
s<xs:simpleType name="PSČType">
  <xs:restriction base="xs:string">
    <xs:length value="6"/>
  </xs:restriction>
</xs:simpleType>

w
x
s<xs:element name="psc" type="PSČType"/>

w
x
s<xs:simpleType name="jménoType">
  <xs:restriction base="xs:string">
    <xs:minLength value="1"/>
    <xs:maxLength value="15"/>
  </xs:restriction>
</xs:simpleType>

w
x
s<xs:simpleType name="kódMěnyType">
  <xs:restriction base="xs:string">
    <xs:enumeration value="CZK"/>
    <xs:enumeration value="EUR"/>
    <xs:enumeration value="USD"/>
  </xs:restriction>
</xs:simpleType>

w
x
s<xs:simpleType name="PSČType">
  <xs:restriction base="xs:string">
    <xs:pattern value="\d{3} \d{2}"/>
  </xs:restriction>
</xs:simpleType>

w
x
s<xs:simpleType name="částkaType">
  <xs:restriction base="xs:decimal">
    <xs:minInclusive value="0"/>
    <xs:maxExclusive value="1000000"/>
    <xs:fractionDigits value="2"/>
  </xs:restriction>
</xs:simpleType>

w
x
s<xs:element name="psc">
  <xs:simpleType>
    <xs:restriction base="xs:string">
      <xs:length value="6"/>
    </xs:restriction>
  </xs:simpleType>
</xs:element>

w
x
s<xs:simpleType name="pohlaví">
  <xs:restriction base="xs:string">
    <xs:pattern value="muž"/>
    <xs:pattern value="žena"/>
  </xs:restriction>
</xs:simpleType>

w
x
s<xs:simpleType name="sudéČíslo">
  <xs:restriction base="xs:int">
    <xs:pattern value=".*0"/>
    <xs:pattern value=".*2"/>
    <xs:pattern value=".*4"/>
    <xs:pattern value=".*6"/>
    <xs:pattern value=".*8"/>
  </xs:restriction>
</xs:simpleType>

w
x
s<xs:simpleType name="částkaVčetněMěny">
  <xs:restriction base="xs:token">
    <xs:pattern value="\d+\.?\d*\s*\p{Sc}"/>
  </xs:restriction>
</xs:simpleType>

w
x
s<xs:simpleType name="řeckéSlovoBezAlfaBetaGama">
  <xs:restriction base="xs:string">
    <xs:pattern value="[\p{IsGreek}-[αβγ]]+"></xs:pattern>
  </xs:restriction>
</xs:simpleType>

w
x
s<xs:simpleType name="pohlaví">
  <xs:restriction base="xs:string">
    <xs:pattern value="muž|žena"/>
  </xs:restriction>
</xs:simpleType>

w
x
s<xs:simpleType name="sudéČíslo">
  <xs:restriction base="xs:int">
    <xs:pattern value=".*0|.*2|.*4|.*6|.*8"/>
  </xs:restriction>
</xs:simpleType>

w
x
s<xs:simpleType>
  <xs:restriction base="xs:string">
    <xs:pattern value="\w+\s*([,;]\s*\w+)*"/>
  </xs:restriction>
</xs:simpleType>

<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">

  <xs:element name="doc">
    <xs:complexType>
      <xs:sequence>
        
        <xs:element name="řeckyBezAlfaBetaGama" maxOccurs="unbounded">
          <xs:simpleType>
            <xs:restriction base="xs:string">
              <xs:pattern value="[\p{IsGreek}-[αβγ]]+"></xs:pattern>
            </xs:restriction>
          </xs:simpleType>
        </xs:element>
        
        <xs:element name="seznamSlovOddělenýČárkamiNeboStředníky" maxOccurs="unbounded">
          <xs:simpleType>
            <xs:restriction base="xs:string">
              <xs:pattern value="\w+\s*([,;]\s+\w+)*"/>
            </xs:restriction>
          </xs:simpleType>
        </xs:element>
        
        <xs:element name="psčJakoToken" maxOccurs="unbounded">
          <xs:simpleType>
            <xs:restriction base="xs:token">
              <xs:pattern value="[0-9]{3} [0-9]{2}"/>
            </xs:restriction>
          </xs:simpleType>
        </xs:element>
        
        <xs:element name="psčJakoString" maxOccurs="unbounded">
          <xs:simpleType>
            <xs:restriction base="xs:string">
              <xs:pattern value="[0-9]{3} [0-9]{2}"/>
            </xs:restriction>
          </xs:simpleType>
        </xs:element>
        
        <xs:element name="rč" maxOccurs="unbounded">
          <xs:simpleType>
            <xs:restriction base="xs:token">
              <xs:pattern value="[0-9]{6}/[0-9]{3,4}"/>
            </xs:restriction>
          </xs:simpleType>
        </xs:element>
      
        <xs:element name="rčLépeKontrolované" maxOccurs="unbounded">
          <xs:simpleType>
            <xs:restriction base="xs:token">
              <xs:pattern value="[0-9]{2}([05][1-9]|[16][0-2])([012][0-9]|3[01])/[0-9]{3,4}"/>
            </xs:restriction>
          </xs:simpleType>
        </xs:element>
      
        <xs:element name="email" maxOccurs="unbounded">
          <xs:simpleType>
            <xs:restriction base="xs:token">
              <xs:pattern value="[&#33;-&#126;-[()&lt;>@;:\\&quot;\[\]]]+@[&#33;-&#126;-[()&lt;>@;:\\&quot;\[\]]]+"/>
            </xs:restriction>
          </xs:simpleType>
        </xs:element>

        <xs:element name="částkaVčetněMěny" maxOccurs="unbounded">
          <xs:simpleType>
            <xs:restriction base="xs:token">
              <xs:pattern value="\d+\.?\d*\s*\p{Sc}"/>
            </xs:restriction>
          </xs:simpleType>
        </xs:element>
         
        <xs:element name="sudéČíslo" maxOccurs="unbounded">
          <xs:simpleType>
            <xs:restriction base="xs:int">
              <xs:pattern value=".*[02468]"/>
            </xs:restriction>
          </xs:simpleType>
        </xs:element>
        
      </xs:sequence>
    </xs:complexType>
  </xs:element>
  
</xs:schema>

3.2.3 Normalizace hodnot a integritní omezení

Pro správné pochopení integritních omezení je potřeba si uvědomit, že hodnota, kterou kontrolují, nemusí být stejná jako hodnota zapsaná přímo do dokumentu XML.

Jak ukazuje obrázek 3.2 – „Jak se text z dokumentu XML přemění na hodnotu“ údaj uložený v dokumentu XML se nejprve normalizuje. Při této normalizaci se bílé znaky jako konce řádky a tabulátory nahradí mezerou. Poté se oříznou veškeré mezery na začátku a konci hodnoty a vícenásobný výskyt znaku mezera se nahradí mezerou jedinou. Tato normalizace se provádí vždy s výjimkou typů string, normalizedString a od nich odvozených uživatelských typů. Pro typ string se neprovádí vůbec žádná normalizace a pro normalizedString se pouze znaky konce řádků a tabulátory převedou na mezery.

Obrázek 3.2. Jak se text z dokumentu XML přemění na hodnotu

Po normalizaci údaje z dokumentu XML získáme jeho lexikální reprezentaci. Nad tímto lexikálním prostorem pracuje integritní omezení pomocí regulárního výrazu (pattern). Všechny ostatní kontroly, jako počet desetinných míst, přípustný rozsah hodnot apod., se provádějí až nad prostorem hodnot. Ten obsahuje již abstraktní reprezentaci původního údaje. Na obrázku 3.2 – „Jak se text z dokumentu XML přemění na hodnotu“ je tak vidět, jak se původně tři různé zápisy nakonec převedly na stejnou hodnotu 3½.

w
x
s<xs:simpleType name="seznamČísel">
  <xs:list itemType="xs:int"/>
</xs:simpleType>

<xs:element name="čísla" type="seznamČísel"/>

<čísla>1 2 3 4 5 6 42 999 17</čísla>

w
x
s<xs:simpleType name="seznamČísel">
  <xs:list>
    <xs:simpleType>
      <xs:restriction base="xs:int"/>
    </xs:simpleType>
  </xs:list>
</xs:simpleType>

w
x
s<xs:simpleType name="míry">
  <xs:restriction base="seznamČísel">
    <xs:length value="3"/>
  </xs:restriction>
</xs:simpleType>

<věk>30</věk>

<věk>neuvedeno</věk>

w
x
s<xs:element name="věk">
  <xs:simpleType>
    <xs:union>
      <xs:simpleType>
        <xs:restriction base="xs:positiveInteger"/>
      </xs:simpleType>
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="neuvedeno"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:union>
  </xs:simpleType>
</xs:element>

Komplexní typy slouží k modelování struktury dokumentu, protože se mohou skládat z elementů a atributů. U elementů můžeme určit v jakém pořadí se mají vyskytovat, kolikrát se mohou opakovat, zda jsou povinné či volitelné.

Komplexní typ se definuje pomocí elementu complexType. Podobně jako u jednoduchých typů můžeme definovat komplexní typ samostatně, aby pak šel používat opakovaně pro různé elementy. Následující příklad ukazuje, jak definovat elementy odberatel a dodavatel tak, že mají stejný obsah, právě pomocí společně použitého uživatelsky definovaného komplexního typu subjektType.

w
x
s<xs:element name="faktura">
  <xs:complexType>
    <xs:sequence>
      <xs:element name="odberatel" type="subjektType"/>
      <xs:element name="dodavatel" type="subjektType"/>
      ...
    </xs:sequence>
  </xs:complexType>
</xs:element>

<xs:complexType name="subjektType">
  <xs:sequence>
    <xs:element name="nazev" type="xs:string" />
    <xs:element name="adresa" type="xs:string" />
    <xs:element name="ico" type="xs:string" />
    <xs:element name="dic" type="xs:string" />
  </xs:sequence>
</xs:complexType>

Druhou možností je použít complexType přímo v definici elementu. Takto je v předchozím příkladě definován obsah elementu faktura.

Uvnitř elementu complexType pak můžeme použít další elementy sequence, choice a all (tzv. kompozitory). Elementy definované uvnitř sequence se musí v dokumentu vyskytovat v definovaném pořadí. Oproti tomu all říká, že elementy se mohou vyskytovat v libovolném pořadí. Konečně choice říká, že se v dokumentu může vyskytnout jen jeden z obsažených elementů. Tyto elementy lze do sebe podle potřeby zanořovat (s výjimkou all) a tak modelovat složitější situace.

Následující příklad definuje schéma pro článek, který má název, libovolný počet autorů a pak se v něm podle potřeby vyskytuje libovolný počet obrázků anebo odstavců.

w
x
s<xs:element name="clanek">
  <xs:complexType>
    <xs:sequence>
      <xs:element name="nazev" type="xs:string"/>
      <xs:element name="autor" type="xs:string"
                  minOccurs="0" maxOccurs="unbounded"/>
      <xs:choice minOccurs="1" maxOccurs="unbounded">
        <xs:element name="odstavec" type="xs:string"/>
        <xs:element name="obrazek" type="xs:base64Binary"/>
      </xs:choice>
    </xs:sequence>
  </xs:complexType>
</xs:element>

Příklad také demonstruje, jakým způsobem lze určovat počet výskytů elementu nebo celé jejich skupiny. Slouží k tomu atributy minOccurs a maxOccurs. Jejich standardní hodnota je jedna. Pro nekonečno se používá identifikátor unbounded.

<článek>
  <název>Ukázka</název>
  <autor>Pepa</autor>
  <odstavec>...</odstavec>
  <odstavec>...</odstavec>
</článek>

w
x
s<xs:element name="článek">
  <xs:complexType>
    <xs:sequence>
      <xs:element name="název" type="xs:string"/>
      <xs:element name="autor" type="xs:string" minOccurs="0"/>
      <xs:element name="odstavec" type="xs:string" maxOccurs="unbounded"/>
    </xs:sequence>
  </xs:complexType>
</xs:element>

<osoby>
  <osoba>
    <jméno>Pepa Tuzemec</jméno>
    <RČ>681203/0123</RČ>
  </osoba>
  <osoba>
    <jméno>Pepa Cizinec</jméno>
    <pas>1234567</pas>
  </osoba>
  <osoba>
    <jméno>Pepa Rozvědčík</jméno>
    <SSN>987654321</SSN>
  </osoba>
</osoby>

w
x
s<xs:element name="osoby">
  <xs:complexType>
    <xs:sequence>
      <xs:element name="osoba" maxOccurs="unbounded">
        <xs:complexType>
          <xs:sequence>
            <xs:element name="jméno" type="xs:string"/>
            <xs:choice>
               <xs:element name="RČ" type="xs:string"/>
               <xs:element name="pas" type="xs:string"/>
               <xs:element name="SSN" type="xs:string"/>
            </xs:choice>
          </xs:sequence>
        </xs:complexType>
      </xs:element>
    </xs:sequence>
  </xs:complexType>
</xs:element>

<osoba>
  <jméno>Jan</jméno>
  <příjmení>Novák</příjmení>
</osoba>
<osoba>
  <příjmení>Novák</příjmení>
  <jméno>Jan</jméno>
</osoba>
<osoba>
  <titul>Ing.</titul>
  <jméno>Jan</jméno>
  <příjmení>Novák</příjmení>
</osoba>
<osoba>
  <jméno>Jan</jméno>
  <příjmení>Novák</příjmení>
  <titul>CSc.</titul>
</osoba>

w
x
s<xs:element name="osoba">
  <xs:complexType>
    <xs:all>
      <xs:element name="jméno" type="xs:string"/>
      <xs:element name="příjmení" type="xs:string"/>
      <xs:element name="titul" type="xs:string" minOccurs="0"/>
    </xs:all>
  </xs:complexType>
</xs:element>

w
x
s<xs:element name="osoba">
  <xs:complexType>
    <xs:sequence>
      <xs:element name="titul" type="xs:string" minOccurs="0"/>
      <xs:choice>
        <xs:sequence>
          <xs:element name="jméno" type="xs:string"/>
          <xs:element name="příjmení" type="xs:string"/>
        </xs:sequence>
        <xs:sequence>
          <xs:element name="příjmení" type="xs:string"/>
          <xs:element name="jméno" type="xs:string"/>
        </xs:sequence>
      </xs:choice>
      <xs:element name="titul" type="xs:string" minOccurs="0"/>
    </xs:sequence>
  </xs:complexType>
</xs:element>

<odstavec>Odstavce typicky obsahují <pojem>smíšený 
obsah</pojem>. Text se může střídat
s <odkaz url="http://www.kosek.cz">odkazy</odkaz> 
a dalšími <pojem>elementy</pojem>.</odstavec>

<odstavec>Odstavec může obsahovat i jen text.</odstavec>

<odstavec><pojem>Nebo jen element.</pojem></odstavec>

w
x
s<xs:element name="odstavec">
  <xs:complexType mixed="true">
    <xs:choice minOccurs="0" maxOccurs="unbounded">
      <xs:element name="pojem" type="xs:string"/>
      <xs:element name="odkaz">
        <xs:complexType>
          <xs:simpleContent>
            <xs:extension base="xs:string">
              <xs:attribute name="url" type="xs:anyURI"/>
            </xs:extension>
          </xs:simpleContent>
        </xs:complexType>
      </xs:element>
    </xs:choice>
  </xs:complexType>
</xs:element>

<prazdny/>
<prazdny></prazdny>

<img src="obrazek.png"/>

w
x
s<xs:element name="img">
  <xs:complexType>
    <xs:attribute name="src" type="xs:anyURI"/>
  </xs:complexType>
</xs:element>

w
x
s<xs:element name="img">
  <xs:complexType>
    <xs:complexContent>
      <xs:restriction base="xs:anyType">
        <xs:attribute name="src" type="xs:anyURI"/>
      </xs:restriction>
    </xs:complexContent>
  </xs:complexType>
</xs:element>

w
x
s<xs:attribute name="vek" type="xs:positiveInteger"/>

w
x
s<xs:attribute name="ident" type="xs:ID" use="required"/>

<xs:attribute name="měna" type="xs:string" default="USD"/>

<cena měna="USD">23.69</cena>

w
x
s<xs:element name="cena">
  <xs:complexType>
    <xs:simpleContent>
      <xs:extension base="částkaType">
        <xs:attribute name="měna" type="kódMěnyType"/>
      </xs:extension>
    </xs:simpleContent>
  </xs:complexType>
</xs:element>

w
x
s<xs:element name="cena">
  <xs:complexType>
    <xs:simpleContent>
      <xs:extension base="typ_obsahu_elementu">
	…definice atributů…
      </xs:extension>
    </xs:simpleContent>
  </xs:complexType>
</xs:element>

Pro dokonalé pochopení XML schémat, se musíme seznámit s lokálními a globálními deklaracemi a rozdílem mezi nimi.

Za globální se považují deklarace provedené na nejvyšší úrovni schématu, přímo v elementu schema. Globálně deklarované elementy a datové typy mají v některých ohledech speciální chování. Dokument vyhovující schématu může začínat libovolným globálním elementem. Ve většině schémat má proto smysl deklarovat jako globální pouze ten element, který chceme použít jako obálku okolo celého dokumentu XML. O různých možnostech, jak toho dosáhnout pojednává sekce 3.7 – „Přístupy k návrhu schématu“.

Jako ukázka nevhodného přístupu může sloužit následující schéma faktury, ve kterém jsou jako globální deklarovány elementy faktura a polozka. Validací tedy projde nejen kompletní faktura, ale i jedna jediná položka.

w
x
s<?xml version="1.0" encoding="utf-8" ?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
            targetNamespace="urn:x-kosek:schemas:faktura:1.0"
            xmlns="urn:x-kosek:schemas:faktura:1.0"
            elementFormDefault="qualified">
  <xs:element name="faktura">
    <xs:complexType>
      <xs:sequence>
        <xs:element name="odberatel" type="subjektInfoTyp" />
        <xs:element name="dodavatel" type="subjektInfoTyp" />
        <xs:element ref="polozka" minOccurs="1" maxOccurs="unbounded" />
      </xs:sequence>
      <xs:attribute name="cislo" type="cisloFakturyTyp" use="required" />
      <xs:attribute name="vystaveni" type="xs:date" use="required" />
      <xs:attribute name="splatnost" type="xs:date" use="required" />
      <xs:attribute name="vystavil" type="xs:string" />
    </xs:complexType>
  </xs:element>
  <xs:complexType name="subjektInfoTyp">
    <xs:sequence>
      <xs:element name="nazev" type="xs:string" />
      <xs:element name="adresa" type="xs:string" />
      <xs:element name="ico" type="icoTyp" />
      <xs:element name="dic" type="dicTyp" />
    </xs:sequence>
  </xs:complexType>
  <xs:simpleType name="icoTyp">
    <xs:restriction base="xs:string">
      <xs:pattern value="\d{10}" />
    </xs:restriction>
  </xs:simpleType>
  <xs:simpleType name="dicTyp">
    <xs:restriction base="xs:string">
      <xs:pattern value="\d{3}-\d{10}" />
    </xs:restriction>
  </xs:simpleType>
  <xs:simpleType name="cisloFakturyTyp">
    <xs:restriction base="xs:string">
      <xs:pattern value="\d{4}/\d{3}" />
    </xs:restriction>
  </xs:simpleType>
  <xs:element name="polozka">
    <xs:complexType>
      <xs:sequence>
        <xs:element name="popis" type="xs:string" minOccurs="0" maxOccurs="1" />
        <xs:element name="cena" type="částkaTyp" />
        <xs:element name="dph" type="dphTyp" />
        <xs:element name="ks" type="xs:positiveInteger" minOccurs="0" maxOccurs="1" />
      </xs:sequence>
    </xs:complexType>
  </xs:element>
  <xs:simpleType name="částkaTyp">
    <xs:restriction base="xs:decimal">
      <xs:minInclusive value="0" />
    </xs:restriction>
  </xs:simpleType>
  <xs:simpleType name="dphTyp">
    <xs:restriction base="xs:decimal">
      <xs:enumeration value="22" />
      <xs:enumeration value="5" />
    </xs:restriction>
  </xs:simpleType>
</xs:schema>

Na globálně deklarované typy a elementy se lze odvolávat z jiných schémat (viz 3.12.5 – „Schéma definující elementy v několika jmenných prostorech“). V další sekci uvidíme, že globálně a lokálně deklarované elementy mají i odlišné vlastnosti vzhledem ke jmenným prostorům.

Bývá dnes dobrým zvykem přiřadit každému nově vytvořenému značkovacímu jazyku vlastní jmenný prostor, aby jej šlo snadno identifikovat. Jmenný prostor, do něhož budou elementy patřit, se určuje pomocí atributu targetNamespace u kořenového elementu schématu. Z praktických důvodů se tento jmenný prostor obvykle deklaruje i jako implicitní, abychom před naše elementy nemuseli všude psát nějaký prefix.

XML schéma má jednu nepříjemnou vlastnost – do jmenného prostoru patří jen globální elementy. Jsou to pouze ty elementy, které jsou ve schématu definované na nejvyšší úrovni přímo pod elementem schema. Předpokládejme například následující schéma:

w
x
s<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
           targetNamespace="urn:x-kosek:schemas:pokus"
           xmlns="urn:x-kosek:schemas:pokus">
  <xs:element name="a">
    <xs:complexType>
      <xs:sequence>
        <xs:element name="b" type="xs:string"/>
        <xs:element name="c" type="xs:string"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
</xs:schema>

Instance, která schématu vyhovuje, pak odporuje ustáleným praktikám pro tvorbu dokumentů XML. Můžeme ji zapsat buď jako:

<a xmlns="urn:x-kosek:schemas:pokus">
  <b xmlns="">foo</b>
  <c xmlns="">bar</c>
</a>

nebo

<p:a xmlns:p="urn:x-kosek:schemas:pokus">
  <b>foo</b>
  <c>bar</c>
</p:a>

Nepřehledný a nekonzistentní zápis je právě důsledkem toho, že elementy b a c nepatří do žádného jmenného prostoru. Každý element by přitom měl patřit do nějakého jmenného prostoru. Toho můžeme dosáhnout tím, že pomocí atributu elementFormDefault řekneme, že celé schéma musí používat kvalifikované (rozuměj zařazené do nějakého jmenného prostoru) elementy.

w
x
s<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
           targetNamespace="urn:x-kosek:schemas:pokus"
           xmlns="urn:x-kosek:schemas:pokus"
           elementFormDefault="qualified">
  <xs:element name="a">
    <xs:complexType>
      <xs:sequence>
        <xs:element name="b" type="xs:string"/>
        <xs:element name="c" type="xs:string"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
</xs:schema>

S tímto schématem už můžeme vytvářet dokumenty, tak jak je zvykem.

<a xmlns="urn:x-kosek:schemas:pokus">
  <b>foo</b>
  <c>bar</c>
</a>

<p:a xmlns:p="urn:x-kosek:schemas:pokus">
  <p:b>foo</p:b>
  <p:c>bar</p:c>
</p:a>

Ve skutečnosti je možné u každého elementu nebo atributu určit, zda má nebo nemá patřit do cílového jmenného prostoru. Slouží k tomu atribut form, jehož použití ukazuje následující příklad, který rovněž definuje všechny tři elementy v jednom jmenném prostoru.

w
x
s<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
  targetNamespace="urn:x-kosek:schemas:pokus"
  xmlns="urn:x-kosek:schemas:pokus">
  <xs:element name="a">
    <xs:complexType>
      <xs:sequence>
        <xs:element name="b" type="xs:string" form="qualified"/>
        <xs:element name="c" type="xs:string" form="qualified"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
</xs:schema>

V praxi se však příslušenství elementů (případně atributů) do jmenného prostoru obvykle definuje globálně a využívají se proto atributy elementFormDefault a attributeFormDefault.

Použití jmenných prostorů ve schématech přináší ještě jednu záludnost. Do cílového jmenného prostoru patří nejen globálně deklarované elementy, ale i typy. Odvoláváme-li se pak při definici elementu nebo atributu na uživatelsky definovaný typ, musíme jej určit pomocí jeho kvalifikovaného jména. Dosáhnout tohoto cíle lze dvě způsoby. První spočívá v deklaraci prefixu pro cílový jmenný prostor.

w
x
s<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
           targetNamespace="http://example.org/ns"
           xmlns:tns="http://example.org/ns"
           elementFormDefault="qualified">

<xs:element name="root" type="tns:mujTyp"/>

<xs:simpleType name="mujTyp">
  <xs:restriction base="xs:string"/>
</xs:simpleType>

</xs:schema>

Druhá možnost využívá toho, že XML schémata rozšiřují dopad výchozího jmenného prostoru ze jmen elementů i na jména datových typů (samozřejmě pouze uvnitř schématu, změna se netýká instancí). Předchozí schéma tak můžeme napsat i následujícím způsobem, který je většinou i běžnější.

w
x
s<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
           targetNamespace="http://example.org/ns"
           xmlns="http://example.org/ns"
           elementFormDefault="qualified">

<xs:element name="root" type="mujTyp"/>

<xs:simpleType name="mujTyp">
  <xs:restriction base="xs:string"/>
</xs:simpleType>

</xs:schema>

Chceme-li přímo v dokumentu XML určit, kde může parser najít schéma například pro účely validace, musíme k tomu použít speciální globální atributy patřící do jmenného prostoru http://www.w3.org/2001/XMLSchema-instance.

Nepoužíváme-li jmenné prostory, stačí do atributu noNamespaceSchemaLocation uvést URL adresu, na které se nachází schéma. Můžeme použít samozřejmě i relativní URL a jednoduše se tak odkázat na soubor se schématem, který je ve stejném adresáři jako dokument.

<dokument 
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:noNamespaceSchemaLocation="dokument.xsd">
  ...
</dokument>

Používáme-li jmenné prostory, musíme použít atribut schemaLocation. Ten může obsahovat několik dvojic hodnot URI jmenného prostoru a umístění schématu. Hodnoty jsou přitom oddělené mezerami nebo jinými bílými znaky.

<dokument 
  xmlns="urn:x-kosek:schemas:dokument:1.0"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="urn:x-kosek:schemas:dokument:1.0
                      dokument.xsd">
  ...
</dokument>

Některé novější aplikace již podporují novou instrukci <?xml-model?>. Ta umožňuje připojit jakékoliv schéma bez nutnosti používat speciální atributy.

<?xml-model href="dokument.xsd"?>
<dokument>
  ...
</dokument>

Obecně však tento způsob připojování schématu nelze doporučit. Hodí se pro účely testování a různých hrátek se schématy. V praxi bychom však atributy schemaLocation a noNamespaceSchemaLocation neměli používat. Schéma vhodné pro validaci by si měla vybrat sama aplikace, která validaci provádí jako součást zpracování dokumentu. Můžeme tak vždy určit jedno pevné schéma, nebo schéma vybrat na základě nějaké mapovací tabulky^[4], kde je pro každý jmenný prostor určeno odpovídající schéma. Tím budeme mít zaručeno, že zvalidovaný dokument opravdu odpovídá schématu, se kterým naše aplikace pro další zpracování dokumentu počítá.

Když se spolehneme na atributy pro připojení schématu, může nám kdokoliv podvrhnout jakýkoliv dokument, pro který někde na webu vystavil svoje vlastní schéma. Takový dokument projde validací, ale naše aplikace bude mít v lepším případě problémy s jeho zpracování, v horším ji to zcela vyvede z míry.

Postupem času se vyvinulo několik přístupů k tomu, jak správně vystavět schéma. Problém, který je potřeba rozhodnout, spočívá ve výběru, kdy používat lokální, a kdy globální elementy, jak moc bude schéma rozšiřitelné a použitelné v dalších schématech.

Rozdíly mezi jednotlivýmu přístupy si ukážeme na následujícím jednoduchém dokumentu.

<?xml version="1.0" encoding="UTF-8"?>
<zamestnanec>
  <jmeno>Jan</jmeno>
  <prijmeni>Novák</prijmeni>
  <adresa>
    <ulice>Dlouhá 2</ulice>
    <město>Praha 1</město>
    <psč>110 00</psč>
  </adresa>
  <plat>34500</plat>
</zamestnanec>

První přístup je označován jako matrjóška, tedy ruská panenka, kdy do sebe zapadají jednotlivé menší a menší panenky. V tomto přístupu je globální jen jeden element a všechny ostatní jsou uvnitř něj definovány jako lokální.

w
x
s<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
  
  <xs:element name="zamestnanec">
    <xs:complexType>
      <xs:sequence>
        <xs:element name="jmeno" type="xs:string"/>
        <xs:element name="prijmeni" type="xs:string"/>
        <xs:element name="adresa">
          <xs:complexType>
            <xs:sequence>
              <xs:element name="ulice" type="xs:string"/>
              <xs:element name="město" type="xs:string"/>
              <xs:element name="psč" type="xs:string"/>
            </xs:sequence>
          </xs:complexType>
        </xs:element>
        <xs:element name="plat" type="xs:decimal"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
  
</xs:schema>

Instance tohoto schématu může začínat jen elementem zamestnanec, a jiný element ani nejde znovu použít v jiných schématech, které by toto schéma importovaly. Výhodou je naopak krátké a kompaktní schéma, které je rychle napsané.

Druhý častý přístup se nazývá salámová kolečka. Všechny elementy jsou definovány jako globální a pak jsou složeny dohromady pomocí odkazů.

w
x
s<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
  
  <xs:element name="jmeno" type="xs:string"/>
  <xs:element name="prijmeni" type="xs:string"/>
  <xs:element name="ulice" type="xs:string"/>
  <xs:element name="město" type="xs:string"/>
  <xs:element name="psč" type="xs:string"/>
  <xs:element name="plat" type="xs:decimal"/>
  
  <xs:element name="adresa">
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="ulice"/>
        <xs:element ref="město"/>
        <xs:element ref="psč"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
  
  <xs:element name="zamestnanec">
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="jmeno"/>
        <xs:element ref="prijmeni"/>
        <xs:element ref="adresa"/>
        <xs:element ref="plat"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
  
</xs:schema>

Dokument může začínat libovolným elementem, libovolný element můžeme znovu použít. Nevýhoda je, že v tomto přístupu nejde pro element stejného názvu definovat dva různé modely obsahu v závislosti na kontextu jeho výskytu. Tuto možnost první způsob nabízí.

Třetí metoda, označovaná jako metoda slepého Benátčana, pro všechny elementy nejprve definuje typy, které lze znovu používat. Elementy jsou pak definovány lokálně pomocí těchto typů, takže mohou mít při shodě jmen různé modely obsahu. Tento přístup nabízí nejvíce možností a komfortu, a ve většině případů je nejvhodnější. Jeho nevýhodou je větší pracnost a složitost v porovnání s předchozími metodami.

w
x
s<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">

  <xs:simpleType name="jmenoType">
    <xs:restriction base="xs:string">
      <xs:minLength value="1"/>
      <xs:maxLength value="15"/>
    </xs:restriction>
  </xs:simpleType>
  
  <xs:simpleType name="prijmeniType">
    <xs:restriction base="xs:string">
      <xs:minLength value="1"/>
      <xs:maxLength value="20"/>
    </xs:restriction>
  </xs:simpleType>
  
  <xs:simpleType name="uliceType">
    <xs:restriction base="xs:string"/>
  </xs:simpleType>
  
  <xs:simpleType name="městoType">
    <xs:restriction base="xs:string"/>
  </xs:simpleType>
  
  <xs:simpleType name="psčType">
    <xs:restriction base="xs:token">
      <xs:pattern value="[0-9]{3} [0-9]{2}"/>
    </xs:restriction>
  </xs:simpleType>
  
  <xs:simpleType name="platType">
    <xs:restriction base="xs:decimal">
      <xs:minInclusive value="0"/>
    </xs:restriction>
  </xs:simpleType>
  
  <xs:complexType name="adresaType">
    <xs:sequence>
      <xs:element name="ulice" type="uliceType"/>
      <xs:element name="město" type="městoType"/>
      <xs:element name="psč" type="psčType"/>
    </xs:sequence>
  </xs:complexType>
  
  <xs:complexType name="zamestnanecType">
    <xs:sequence>
      <xs:element name="jmeno" type="jmenoType"/>
      <xs:element name="prijmeni" type="prijmeniType"/>
      <xs:element name="adresa" type="adresaType"/>
      <xs:element name="plat" type="platType"/>
    </xs:sequence>
  </xs:complexType>
  
  <xs:element name="zamestnanec" type="zamestnanecType"/>
  
</xs:schema>

Velkou nevýhodou XML z pohledu databázistů byla neexistence standardního mechanismu pro zaznamenání toho, že nějaký element obsahuje nedefinovanou hodnotu (NULL). Oba XML zápisy

<autor></autor>
<autor/>

můžeme chápat jako element autor, který obsahuje hodnotu prázdný řetězec. Pro zachycení hodnoty NULL můžeme použít další globální atribut (používají se i pro připojení schématu):

<autor xsi:nil="true"></autor>
<autor xsi:nil="true"/>

To, že element může nabývat prázdnou hodnotu, musíme předtím definovat ve schématu:

w
x
s<xs:element name="autor" nillable="true" type="xs:string"/>

Konstrukci xsi:nil využívají zejména různé nástroje pro databinding. Obvyklý přístup ve světě XML je ten, že pokud může být nějaká hodnota nedefinovaná, tak se odpovídající element/atribut do výstupu vůbec nevloží – ve schématu pak musí být definován jako volitelný.

Chceme-li zabránit výskytu duplicitních hodnot v nějaké množině elementů nebo atributů, můžeme si definovat unikátní klíč. Klíčů může být v jednom schématu definováno několik a pro jejich definici se používá dotazovací jazyk XPath.

Použití klíče si ukážeme na příkladě. Předpokládejme, že v následujícím seznamu zaměstnanců chceme zajistit unikátnost jejich osobních čísel (atribut oc).

<?xml version="1.0" encoding="UTF-8"?>
<zamestnanci>
  <zamestnanec oc="1164">
    <jmeno>Procházka Karel</jmeno>
    <sef>2021</sef>
  </zamestnanec>
  <zamestnanec oc="1168">
    <jmeno>Novotná Alena</jmeno>
    <sef>2021</sef>
  </zamestnanec>
  <zamestnanec oc="1230">
    <jmeno>Klíma Josef</jmeno>
    <sef>1168</sef>
  </zamestnanec>
  <zamestnanec oc="1564">
    <jmeno>Pinkas Josef</jmeno>
    <sef>2021</sef>
  </zamestnanec>
  <zamestnanec oc="2021">
    <jmeno>Kládová Adéla</jmeno>
  </zamestnanec>
</zamestnanci>

Klíč proto definujeme u elementu zamestnanci, který obsahuje jednotlivé zaměstnance, pro které se má dodržovat unikátnost osobního čísla.

w
x
s<xs:element name="zamestnanci">
  <xs:complexType>
    <xs:sequence>
      <xs:element ref="zamestnanec" maxOccurs="unbounded"/>
    </xs:sequence>
  </xs:complexType>
  <xs:unique name="oc_je_unikatni">
    <xs:selector xpath="zamestnanec"/>
    <xs:field xpath="@oc" />
  </xs:unique>
</xs:element>

Důležité je, aby definice klíče byla umístěna v definici elementu, který pod sebou jako potomky obsahuje elementy, pro které se referenční integrita hlídá. V opačném případě nebude klíč fungovat správně.

Klíč definovaný pomocí unique kontroluje pouze unikátnost hodnot, ale neohlásí chybu, pokud u některého elementu klíč chybí. Chceme-li mít zaručeno, že hodnoty jsou unikátní a jsou uvedeny všude, můžeme použít element key (viz příklad wxs/zamestnanci-key.xsd).

Podobně jako v relační databázi, můžeme i na půdě jednoho dokumentu XML definovat referenční integritu. Postup je obdobný jako u databází – definujeme si klíče a pak cizí klíče, které na ně ukazují. Následující ukázka ilustruje omezení, které zajistí, že pro každého zaměstnance bude existovat jeho šéf.

w
x
s<xs:element name="zamestnanci">
  <xs:complexType>
    <xs:sequence>
      <xs:element ref="zamestnanec" maxOccurs="unbounded"/>
    </xs:sequence>
  </xs:complexType>

  <xs:key name="osobni_cislo">
    <xs:selector xpath="zamestnanec"/>
    <xs:field xpath="@oc"/>
  </xs:key>

  <xs:keyref name="sef_je_existujici_oc" 
             refer="osobni_cislo">
    <xs:selector xpath="zamestnanec"/>
    <xs:field xpath="sef"/>
  </xs:keyref>

</xs:element>

Při návrhu schémat máme k dispozici několik vlastností, které jsou hodně podobné vlastnostem známým z objektově orientovaných jazyků. Možnost odvozování nových typů na základě již existujících není nic jiného než dědičnost. Odvozování jde přitom použít i pro komplexní typy, ne jen pro jednoduché, jak jsme si ukázali.

Komplexní typy lze odvozovat rozšířením a restrikcí. Při rozšíření jde však nové elementy přidávat pouze na konec modelu obsahu, což je velmi omezující. Při odvození nového komplexního typu restrikcí je potřeba celý nový model obsahu vypsat. Díky těmto omezením jsou tyto rysy WXS většinou nepoužívané, protože je lze nahradit jednodušeji pomocí ostatních konstrukcí. Jediné kdy se jejich použití hodí, je v případech, kdy čteme dokument pomocí PSVI a chceme mít k dispozici informaci o tom, jak jsou od sebe jednotlivé typy navzájem odvozené.

Zajímavým rysem jsou substituční skupiny. Ty umožňují definovat element, který může být v instanci nahrazen jakýmkoliv jiným elementem patřícím do stejné substituční skupiny. Výhodou tohoto přístupu je pak zejména možnost přidávat nové varianty pro nahrazení elementu v modularizovaných schématech.

Následující dokument ukazuje adresář, kde osoba může být identifikována buď přezdívkou, nebo plným jménem.

<adresář>
  <osoba>
    <plnéJméno>
      <křestní>Jan</křestní>
      <příjmení>Novák</příjmení>
    </plnéJméno>
    <email>jan.novak@example.org</email>
  </osoba>
  <osoba>
    <přezdívka>Drsňák</přezdívka>
    <email>jiri.prochazka@example.org</email>
  </osoba>
</adresář>

Tohoto efektu můžeme samozřejmě dosáhnout pomocí choice, ale substituční skupina umožní v budoucnu snadno přidávat další varianty identifikace osoba.

w
x
s<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">

  <xs:element name="jméno" abstract="true"/>
  
  <xs:element name="přezdívka" substitutionGroup="jméno" type="xs:string"/>
  
  <xs:element name="plnéJméno" substitutionGroup="jméno">
    <xs:complexType>
      <xs:all>
        <xs:element name="křestní" type="xs:string"/>
        <xs:element name="příjmení" type="xs:string"/>
      </xs:all>
    </xs:complexType>
  </xs:element>
  
  <xs:element name="osoba">
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="jméno"/>
        <xs:element name="email" type="xs:string"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
  
  <xs:element name="adresář">
    <xs:complexType>
      <xs:sequence maxOccurs="unbounded">
        <xs:element ref="osoba"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
  
</xs:schema>

Vidíme, že element jméno, který slouží jako začátek substituční skupiny je definován jako abstraktní, aby jej nešlo použít přímo v instanci dokumentu.

Substituční skupiny lze využít pro psaní schémat, které umožňují následné snadné přizpůsobení. Pomocí elementu include je možné schéma skládat dohromady z několika souborů. V novém schématu tak můžeme načíst již existující a přidávat nové elementy do substituční skupiny.

w
x
s<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">

  <xs:include schemaLocation="substituce.xsd"/>
  
  <xs:element name="krycíJméno" substitutionGroup="jméno" type="xs:string"/>

</xs:schema>

Mezi další objektově inspirované rysy patří možnost zablokovat další dědění nebo substituce od nějakého datového typu. Slouží k tomu atributy final a block. První blokuje další úpravy ve schématu, druhý v jeho instancích.

W3C XML schémata nabízejí několik prostředků, které usnadňují modularizaci schémat.

w
x
s<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">

  <xs:group name="adresa">
    <xs:sequence>
      <xs:element name="ulice" type="xs:string"/>
      <xs:element name="město" type="xs:string"/>
      <xs:element name="psč" type="xs:string"/>
    </xs:sequence>
  </xs:group>

  <xs:element name="osoba">
    <xs:complexType>
      <xs:sequence>
        <xs:element name="jméno" type="xs:string"/>
        <xs:group ref="adresa"/>
        <xs:element name="zaměstnání">
          <xs:complexType>
            <xs:sequence>
              <xs:element name="firma" type="xs:string"/>
              <xs:group ref="adresa"/>
            </xs:sequence>
          </xs:complexType>
        </xs:element>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
  
</xs:schema>

w
x
s<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">

  <xs:attributeGroup name="společnéAtributy">
    <xs:attribute name="id" type="xs:ID"/>
    <xs:attribute name="lang" type="xs:language"/>
  </xs:attributeGroup>
  
  <xs:element name="doc">
    <xs:complexType>
      <xs:sequence>
        <xs:element name="title">
          <xs:complexType>
            <xs:simpleContent>
              <xs:extension base="xs:string">
                <xs:attributeGroup ref="společnéAtributy"/>    
              </xs:extension>
            </xs:simpleContent>
          </xs:complexType>
        </xs:element>
        <xs:element name="p">
          <xs:complexType>
            <xs:simpleContent>
              <xs:extension base="xs:string">
                <xs:attributeGroup ref="společnéAtributy"/>
              </xs:extension>
            </xs:simpleContent>
          </xs:complexType>
        </xs:element>
      </xs:sequence>
      <xs:attributeGroup ref="společnéAtributy"/>
    </xs:complexType>
  </xs:element>
  
</xs:schema>

<xs:include schemaLocation="cast-schematu.xsd"/>

w
x
s<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">

  <xs:redefine schemaLocation="zamestnanec-benatcan.xsd">
  
    <xs:complexType name="adresaType">
      <xs:complexContent>
        <xs:extension base="adresaType">
          <xs:sequence>
            <xs:element name="stát" type="xs:string"/>
          </xs:sequence>          
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
    
  </xs:redefine>

</xs:schema>

w
x
s<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">

  <xs:redefine schemaLocation="zamestnanec-benatcan-group.xsd">
  
    <xs:group name="adresaGroup">
      <xs:sequence>
        <xs:element name="stát" type="xs:string"/>
        <xs:group ref="adresaGroup"/>
      </xs:sequence>
    </xs:group>
    
  </xs:redefine>

</xs:schema>

w
x
s<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
           targetNamespace="http://www.w3.org/1999/xhtml"
           xmlns="http://www.w3.org/1999/xhtml">

  <xs:redefine schemaLocation="xhtml11/xhtml11.xsd">
  
    <xs:group name="tr.content">
      <xs:sequence>
        <xs:choice maxOccurs="unbounded">
          <!-- Odstraníme element th: <xs:element ref="th"/> -->
          <xs:element ref="td"/>
        </xs:choice>
      </xs:sequence>
    </xs:group>
    
  </xs:redefine>

</xs:schema>

w
x
s<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs='http://www.w3.org/2001/XMLSchema'
           xmlns:html="http://www.w3.org/1999/xhtml">
  
  <xs:import namespace="http://www.w3.org/1999/xhtml"
             schemaLocation="xhtml11/xhtml11.xsd"/>
  
  <xs:element name="message">
    <xs:complexType>
      <xs:sequence>
        <xs:element name="from" type="xs:string"/>
        <xs:element name="to" type="xs:string"/>
        <xs:element name="subject" type="xs:string"/>
        <xs:choice>
          <xs:element name="body" type="xs:string"/>
          <xs:element ref="html:body"/>
        </xs:choice>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
  
</xs:schema>

<?xml version="1.0" encoding="UTF-8"?>
<message xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:noNamespaceSchemaLocation="message.xsd">
  <from>adam@example.org</from>
  <to>eva@example.org</to>
  <subject>Pokusný email v textu</subject>
  <body>Tělo e-mailu.</body>
</message>

<?xml version="1.0" encoding="UTF-8"?>
<message xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:noNamespaceSchemaLocation="message.xsd">
  <from>adam@example.org</from>
  <to>eva@example.org</to>
  <subject>Pokusný email v textu</subject>
  <body xmlns="http://www.w3.org/1999/xhtml">
    <h1>E-mail zapsaný v HTML</h1>
    <p>První odstavec.</p>
    <p>Druhý odstavec</p>
    <table>
      <tr><th>A</th><th>B</th></tr>
      <tr><td>2</td><td>7</td></tr>
    </table>
  </body>
</message>

<?xml version="1.0" encoding="UTF-8"?>
<Envelope xmlns="http://www.w3.org/2003/05/soap-envelope"
          xmlns:p="urn:x-pokus:ws-payload">
  <Header>
    <p:UserId>Pepa</p:UserId>
  </Header>
  <Body>
    <p:GetFoo>
      <p:foo>abc</p:foo>
      <p:bar>def</p:bar>
    </p:GetFoo>
  </Body>
</Envelope>

<xs:any namespace="##any" processContents="lax" 
        minOccurs="0" maxOccurs="unbounded"/>

<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
           targetNamespace="urn:x-pokus:ws-payload"
           elementFormDefault="qualified">
  
  <xs:element name="GetFoo">
    <xs:complexType>
      <xs:sequence>
        <xs:element name="foo" type="xs:string"/>
        <xs:element name="bar" type="xs:string"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>

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

</xs:schema>

<?xml version="1.0" encoding="UTF-8"?>
<Envelope xmlns="http://www.w3.org/2003/05/soap-envelope"
          xmlns:p="urn:x-pokus:ws-payload"
	  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instamce"
	  xsi:schemaLocation="http://www.w3.org/2003/05/soap-envelope soap.xsd
	                      urn:x-pokus:ws-payload payload.xsd">
  …
</Envelope>

<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
 
  <xs:import namespace="http://www.w3.org/2003/05/soap-envelope" schemaLocation="soap.xsd"/>
  <xs:import namespace="urn:x-pokus:ws-payload" schemaLocation="payload.xsd"/>

</xs:schema>

Při psaní schémat můžeme poměrně snadno narazit na několik omezení. Některé konstrukce jsou ve schématech zakázané. Někdy to má dobrý důvod, někdy lze jen o umělý relikt, protože v době práce na specifikaci nebyl široce znám efektivní algoritmus pro validaci určitých konstrukcí.

w
x
s<xs:complexType name="typ1">
  <xs:choice>
    <xs:sequence>
      <xs:element name="a"/>
      <xs:element name="b"/>      
    </xs:sequence>
    <xs:sequence>
      <xs:element name="a"/>
      <xs:element name="c"/>      
    </xs:sequence>
  </xs:choice>
</xs:complexType>

w
x
s<xs:complexType name="typ2">
  <xs:sequence>
    <xs:element name="a"/>
    <xs:choice>
      <xs:element name="b"/>      
      <xs:element name="c"/>      
    </xs:choice>
  </xs:sequence>
</xs:complexType>

w
x
s<xs:complexType name="typ3">
  <xs:sequence>
    <xs:element name="a" type="xs:string"/>
    <xs:element name="a" type="xs:integer"/>
  </xs:sequence>
</xs:complexType>

XML schéma umožňuje k libovolné jeho části připojit dokumentaci. Ta může obsahovat buď prostý text, nebo můžeme použít v odpovídajícím jmenném prostoru nějaký speciální značkovací jazyk jako XHTML nebo DocBook.

w
x
s<xs:element name="zamestnanec">
  <xs:annotation>
    <xs:documentation>Element slouží pro uchování důležitých 
      údajů o zaměstnanci.</xs:documentation>
  </xs:annotation>
  <xs:complexType>
    <xs:sequence>
      <xs:element name="jmeno" type="xs:string"/>
      <xs:element name="prijmeni" type="xs:string"/>
      <xs:element name="plat" type="xs:decimal"/>
      <xs:element name="narozen" type="xs:date"/>
    </xs:sequence>
  </xs:complexType>
</xs:element>

w
x
s<xs:simpleType name="DruhDokumentuType">
  <xs:annotation>
    <xs:documentation xmlns="http://www.w3.org/1999/xhtml">
      <p>Druh účetního dokumentu.</p>
      <p>Podporovány jsou následující hodnoty:</p>
      <table>
        <tr>
          <td>1</td>
          <td>faktura</td>
        </tr>
        <tr>
          <td>2</td>
          <td>dobropis</td>
        </tr>
        <tr>
          <td>3</td>
          <td>vrubopis</td>
        </tr>
      </table>
      <p>Více podrobností <a href="http://example.com/ciselnik">v číselníku MF</a>.</p>
    </xs:documentation>
  </xs:annotation>
  <xs:restriction base="xs:integer">
    <xs:enumeration value="1"/>
    <xs:enumeration value="2"/>
    <xs:enumeration value="3"/>
  </xs:restriction>      
</xs:simpleType>

Existují nástroje, které jsou pak schopné na základě schématu a v něm obsažených komentářů vygenerovat přehlednou dokumentaci. Jedním z těchto nástrojů je xs3p dostupné na adrese http://sourceforge.net/projects/xs3p/. Jedná se o XSLT styl, který umí schéma převést do webové stránky.

Vygenerování dokumentace tak spočívá v prostém aplikování XSLT stylu na schéma:

saxon -o faktura.html faktura.xsd ../tools/xs3p.xsl

Analogickou a většinou ještě komfortnější funcionalitu mívají přímo do sebe zabudované i editory XML a schémat.

Podobným způsobem lze do elementu appInfo přidat i různé aplikačně závislé informace. Třeba doplňkovou validaci pomocí Schematronu.

Na jaře 2012 byla vydána nová verze XML Schema 1.1, která se snaží odstranit některá omezení a nedostatky předchozích verzí. Bohužel praktické nasazení bude pomalé. V současné době novou verzi podporují pouze dva validátory Saxon-EE a Xerces-J. Kromě uzavřených scénářů tak není vhodné schémata ve verzi 1.1 vytvářet, protože většina nástrojů je nebude schopna použít. I přesto se však alespoň stručně podíváme na některé nejdůležitější novinky.

w
x
s<xs:element name="adresa" type="adresaType">
  <xs:alternative test="@stat='usa'" type="americkaAdresaType"/>
  <xs:alternative test="@stat='eu'" type="evropskaAdresaType"/>
  <xs:alternative type="xs:error"/>
</xs:element>

w
x
s<xs:element name="faktura">
  <xs:complexType>
    <xs:sequence>
      …
    </xs:sequence>
    <xs:attribute name="vystaveni" type="xs:date" use="required"/>
    <xs:attribute name="splatnost" type="xs:date" use="required"/>
    <xs:assert test="@splatnost ge @vystaveni"/>
  </xs:complexType>
</xs:element>