Warning: "continue" targeting switch is equivalent to "break". Did you mean to use "continue 2"? in /data/web/virtuals/280515/virtual/www/templates/vasv304/functions.php on line 202

Article Index

Úvod do XML Schema Definition

DTD lze využít bez problémů na definování struktury XML dokumentu, jeho možnosti omezit uživateli vkládat vybraná data je velmi slabý (pouze omezení typu enumeration), možnost definovat přesný počet značek je také omezený. Z tohoto důvodu bylo vytvořeno XMLSchema. Tento nástroj má velmi mocné nástroje pro přesnou definici toho, co může být v XML dokumentu obsaženo. Na druhou stranu, XMLSchema má velmi košatý zápis. V případě nevhodného zápisu může být výsledný definiční kód velmi nepřehledný.

Jednoduchá zpráva

Pokud začneme s jednoduchým zápisem, kde potřebujeme definovat prostou hierarchii, můžeme použít příklad z kapitoly DTD:

<zprava>
  <od>Michal</od>
  <komu>Jan</komu>
  <predmet>Přednáška</predmet>
  <text>Vem to dnes prosím za mne.</text>
</zprava>

Namespaces

Každý (téměř) z jazyků rodiny XML používá namespace - je to zjednodušeně řečeno odlišení jednotlivých jazyků, zejména užitečné v případě, že kombinujeme několik jazyků v jednom souboru. Taková možnost nastane napříkald u transformací, kde lze kombinovat XSL(T), XSL:FO, SV, HTML a další. Namespace označuje některé jazyky a na první pohled je tak zřejmé, s čím pracujeme. U XSD je každá značka uvozena "xs:".

Definice elementu

Základní strukturou XSD je element - definice jediné značky - další je pak úpravou možností, co v dané značce může být (datový typ, omezení, atribut) a jaké jsou možnosti (volitelnost, výběr z možností, ...).

<xs:element name="" type="" minOccurs="" maxOccurs="" />

U elementu je vždy povinné jméno "name" a datový typ "type". Další dvě volby uvedené v příkladu jsou volitelné - udávají minimální a maximální počet výskytu dané značky na daném místě v hierarchii. Pokud tyto dvě možnosti nejsou uvedené, pak je značka povinná a vyskytuje se přesně 1x. Pokud chceme umožnit neomezený výstyk značky, pak se do uvozovek vkládá hodnota "unbounded".

Úvodní deklarace

V úvodu byla jednoduchá ukázka definice posloupnosti 4 značek bez zanoření, atributů, možnosti výběru, omezení a dalších možností definičního nástroje XML Schema. Pokud vytváříme definici v XSD, musíme soubor XSD nalinkovat do XML:

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

V tomto případě bude definice v xsd vypadat následovně:

<?xml version="1.0"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <xs:element name="zprava">
    <xs:complexType>
     <xs:sequence>
      <xs:element name="od" type="xs:string"/>
      <xs:element name="komu" type="xs:string"/>
      <xs:element name="predmet" type="xs:string"/>
      <xs:element name="text" type="xs:string"/>
     </xs:sequence>
    </xs:complexType>
   </xs:element>
</xs:schema>

Jak je vidět, na rozdíl od DTD, kde je zápis hierarchie poměrně přehledný, XMLSchema potřebuje výrazně více značek pro definice. Zároveň je zde vidět další rozdíl, kdy každá značka má definovaný datový typ a je možné omezit počet výskutů značky (minimální a maximální počet).

Kořenová značka <zprava> má potomky - značky <od>, <komu>, <predmet> a <text>. Značka <zprava> je tak definována jako <xs:complexType> - komplexní typ - obsahuje další uzly. Máme tři druhy komplexních typů:

  • <xs:sequence> - posloupnost značek, musí se respektovat pořadí,
  • <xs:choice> - definujeme možnosti - značky, mezi kterými se vybírá,
  • <xs:all> - možnost libovolného obsahu potomků.

Sekvenci už jsme měli, jak vypadají zápisy zbývajících možností.

<xs:choice>

Zkusme dvě varianty pro jednoduchou zprávu o měření.

<mereni>
  <temp>10</temp>
</zmereni>

a

<mereni>
  <humidity>55</humidity>
</zmereni>

Pro jednoduchost zatím zanedbáme jednotky. XSD soubor by pak vypadal následovně:

<?xml version="1.0"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <xs:element name="mereni">
    <xs:complexType>
     <xs:choice>
      <xs:element name="temp" type="xs:integer"/>
      <xs:element name="humidity" type="xs:integer"/>
     </xs:choice>
    </xs:complexType>
   </xs:element>
</xs:schema>

Máme tedy v <xs:choice> dvě značky, přitom v souboru bude vždy pouze jedna z nich. Nabízí se otázka, jak realizovat výběr různých skupin značek.

První možností je vnoření - tedy každá ze značek bude obsahovat další značkym, nebo zde bude odkaz na definici těchto značek, nebo zde bude odkaz na skupinu značek - vše si projdeme dále.


Přidání atributu

Atribut v případě elementu zpráva může být například id dané zprávy. V definici se v tomto případě přidá mezi ukončení sekvence a ukončení complexType. Zápis je stále jednoduchý - pomocí atributů name, use (required - povinný, implied - nepovinný, fixed - napevno) a type.

Atribut u kořenové značky - deklarace "s ostatními značkami".

XML

<zprava id="125">
  <od>Michal</od>
  <komu>Jan</komu>
  <predmet>Přednáška</predmet>
  <text>Vem to dnes prosím za mne.</text>
</zprava>

XSD

<?xml version="1.0"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <xs:element name="zprava">
    <xs:complexType>
     <xs:sequence>
      <xs:element name="od" type="xs:string"/>
      <xs:element name="komu" type="xs:string"/>
      <xs:element name="predmet" type="xs:string"/>
      <xs:element name="text" type="xs:string"/>
     </xs:sequence>
    <xs:attribute name="id" use="required" type="xs:integer"/>
    </xs:complexType>
   </xs:element>
</xs:schema>

Atribut je tady v elementu uvnitř <xs:complexType>, ale mimo sekvenci - opět platí, že <xs:complexType> značí, že značka se skládá z dalších uzlů. Jedním z nich je tedy i atribut.

Pokud deklarujeme atribut pro "koncovou" značku, pak je to následovně:

<xs:element name="zprava">
<xs:complexType>
<xs:simpleContent>
<xs:extension base="xs:string">
<xs:attribute name="id" type="xs:integer"/>
</xs:extension>
</xs:simpleContent>
</xs:complexType>
</xs:element>

Opět je deklarace atributu součástí <xs:complexType>, ale zde už nejsou žádní potomci. Atribut je tedy deklarován v <xs:simpleContent> - tedy daný element nemá potomky, ale pouze atribut. Navíc zde značka obsahuje data. Je tam část, která deklaruje datový typ značky - <xs:extension base="xs:string" />.


Zanoření více značek - reference

Uvedneý příklad je velmi jednoduchý a v praxi zřejmě zřídka dosažitelný, jak tedy na vícenásobné vnoření v XSD? Máme dvě možnosti - první je tvořit vnořenou strukturu i v případě definičního souboru. U složitějších struktur se pak dostáváme do velmi nepřehledné situace. Druhá možnost je využít reference a značky definovat postupně - napřed v rámci struktury pouze odkaz a definice dané značky je pak až jako poslední na řadě. Upravme si soubor tak, jak aby nebyl zatím příliš složitý:

XML

<zpravy>
  <zprava>
    <od>Michal</od>
    <komu>Jan</komu>
    <predmet>Přednáška</predmet>
    <text>Vem to dnes prosím za mne.</text>
  </zprava>
</zpravy>

XSD

<?xml version="1.0"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <xs:element name="zpravy">
    <xs:complexType>
     <xs:sequence>
      <xs:element ref="zprava"/> <!-- odkaz na definici elementu zprava -->
     </xs:sequence>
    <xs:attribute name="id" use="required" type="xs:integer"/>
    </xs:complexType>
   </xs:element>


  <xs:element name="zprava"> <!-- definice elementu zprava -->
    <xs:complexType>
     <xs:sequence>
      <xs:element name="od" type="xs:string"/>
      <xs:element name="komu" type="xs:string"/>
      <xs:element name="predmet" type="xs:string"/>
      <xs:element name="text" type="xs:string"/>
     </xs:sequence>
    </xs:complexType>
   </xs:element>
</xs:schema>

Vnoření a definice přes referenci je vidět u elementu zpravy - kde v sekvenci je definici elementu zpravy přes odkaz - ref="zprava". Značka <zprava> je pak definována dále. Takto je možné použít XSD i na složité struktury a udržet soubor přehledný.

Tímto zápisem se vyhýbáme "uhýbání" kódu do pravé strany - zůstáváme v rozumných počte odsazení řádku. Zároveň máme kód přehlednější.


Výskyty značek

Při našem zápisu prozatím neupravujeme počet výskytů daného elementu. V tom případě se předpokládá, že bude na daném místě pouze 1x. Když potřebujeme povolit jeho volitelnost (počet výskytů 0) nebo vícenásobné vložení (můžeme nechat neomezený počet nebo omezit horní počet výskytů elementu), použijeme následujíc úpravu.

XML

<zpravy>
  <zprava>
    <od>Michal</od>
    <komu>Jan</komu>
    <predmet>Přednáška</predmet>
    <text>Vem to dnes prosím za mne.</text>
  </zprava>
</zpravy>

XSD

<?xml version="1.0"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <xs:element name="zpravy">
    <xs:complexType>
     <xs:sequence>
       <!-- zpráv může být 0 až nekonečno -->
       <xs:element ref="zprava" minOccurs="0" maxOccurs="unbounded"/>

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


  <xs:element name="zprava">
    <xs:complexType>
     <xs:sequence>
      <xs:element name="od" type="xs:string"/>
           <!-- adresát musí být alespoň jeden, maximum je omezeno na 10 -->
      <xs:element name="komu" type="xs:string" minOccurs="1" maxOccurs="10"/>
      <xs:element name="predmet" type="xs:string"/>
      <xs:element name="text" type="xs:string"/>
     </xs:sequence>
    <xs:attribute name="id" use="required" type="xs:integer"/>
    </xs:complexType>
   </xs:element>
</xs:schema>

Pokud tento zápos chybí, pak se vyžaduje výskyt dané značky přesně jednou - <od>, <predmet>, <text>.

Volitelnost vybraných značek

Náš příklad se týká zprávy, pojďme si upravit příjemce tak, aby odpovídali emailové zprávě. Přidáme příjemce CC (kopie) a BCC (slepé kopie) s tím, že vždy musí být alespoň jedenkrát značka <komu></komu>.

XML

<zpravy>
  <zprava>
    <od>Michal</od>
    <komu>Jan</komu>
    <predmet>Přednáška</predmet>
    <text>Vem to dnes prosím za mne.</text>
  </zprava>
</zpravy>

XSD

<?xml version="1.0"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <xs:element name="zpravy">
    <xs:complexType>
     <xs:sequence>
      <!-- zpráv může být 0 až nekonečno -->  

      <xs:element ref="zprava" minOccurs="0" maxOccurs="unbounded"/>
     </xs:sequence>
    <xs:attribute name="id" use="required" type="xs:integer"/>
    </xs:complexType>
   </xs:element>


  <xs:element name="zprava">
    <xs:complexType>
     <xs:sequence>
      <xs:element name="od" type="xs:string"/>
      <xs:element name="komu" type="xs:string" minOccurs="1" maxOccurs="10"/>
            <xs:element name="cc" type="xs:string" minOccurs="0" maxOccurs="unbounded"/>
            <xs:element name="bcc" type="xs:string" minOccurs="0" maxOccurs="unbounded"/> 
      <xs:element name="predmet" type="xs:string"/>
      <xs:element name="text" type="xs:string"/>
     </xs:sequence>
    </xs:complexType>
   </xs:element>
</xs:schema>


Datové typy

Datové typy v XMLSchema V definici každé značky můžeme vybrat datový typ, který nejlépe vystihuje zapsané hodnoty, text, logické hodnoty a další.

Textový řetězec

Datový typ String umožňuje zapsat textové řetězce, včetně whitespace znaků.

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

Datový typ NormalizedString umožňuje zapsat textové řetězce, dojde k nahrazení tabulátorů, znaků pro nový řádek a konců odstavců - mezerou.

<xs:element name="komu" type="xs:normalizedString"/>

Datový typ Token umožňuje zapsat textové řetězce, dojde k nahrazení tabulátorů, znaků pro nový řádek, konců odstavců, mezer na začátku a konci řetězce, vícenásobných mezer - mezerou.

<xs:element name="komu" type="xs:token"/>

Datový typ Name umožňuje zapsat textové řetězce odpovídající XML konvencím.

<xs:element name="komu" type="xs:name"/>

Datum a čas

Datový typ Date umožňuje zapsat datum ve formátu YYYY-MM-DD.

<xs:element name="prijato" type="xs:date"/>

Zápis ukázkových dat

<prijato>2017-09-26</prijato>

Pro definování časové zóny UTC lze přidat Z na konec dat.

<prijato>2017-09-26Z</prijato>

Pokud je potřeba upravit časovou zónu na konkrétní, pak je možnost následující.

<prijato>2017-09-26+02:00</prijato> <prijato>2017-09-26-02:00</prijato>

Datový typ Time umožňuje zapsat datum ve formátu HH:MM:SS.

<xs:element name="zacatek" type="xs:time"/>

Zápis ukázkových dat

<zacatek>13:25:51</zacatek>

Pokud potřebujeme přesnější časový zápis, pak je to následující:

<zacatek>13:25:51.28</zacatek>

Časové zóny jsou ošetřeny stejně, jako v případě datumu.

<zacatek>13:25:51Z</zacatek>

<zacatek>13:25:51+02:00</zacatek>

<zacatek>13:25:51-02:00</zacatek>

Datový typ Time umožňuje zkombinovat oba dva údaje do jediného zápisu.

<xs:element name="zacatek" type="xs:dateTime"/>

Zápis ukázkových dat

<zacatek>2017-09-26T13:25:51+02:00</zacatek>

Datový typ Duration umožňuje zaznamenání trvání nějakého procesu lze využít datový typ duration. Jeho mírnou nevýhodou je členěný zápis. Formát je dán následujícím zápisem PnYnMnDTnHnMnS.

<xs:element name="narocnost" type="xs:duration"/>

Zápis ukázkových dat (plné využití všech polí).

<zacatek>P2Y3M19DT10H6M10S</zacatek>

Jedná se o periodu s dobou trvání 2 roky, 3 měsíce, 19 dní, 10 hodin, 6 minut a 10 sekund.

Dílčí časové datové typy

Kromě těchto datových typů lze využít i dílčích datových typů pro zápis pouze části datumových nebo časových údajů:

  • gDay
  • gMonth
  • gMonthDay
  • gYear
  • gYearMonth

Číselné datové typy

Datový typ Decimal umožňuje zapsat desetinné číslo, oddělovačem je znak ".".

XSD
<xs:element name="teplota" type="xs:decimal"/>

XML
<teplota>6.4</teplota>
<teplota>+6.4</teplota>
<teplota>-6.4</teplota>

Datový typ Integer umožňuje zapsat celé číslo.

XSD
<xs:element name="teplota" type="xs:integer"/>

XML
<platba>254</platba>
<platba>+254</platba>
<platba>-254</platba>

Další číselné datové typya

Výše uvedené datové typy patří k nejpoužívanějším, v případě nutnosti lze využít další datové typy pro číselná data:

  • byte – rozsah -128 až 127
  • int – 32 bitové číslo
  • long – 64 bitové číslo – rozsah -9223372036854775808 až 9223372036854775807
  • negativeInteger
  • nonNegativeInteger
  • nonPositiveInteger
  • short – 16 bitové číslo – rozsah -32768 až 32767
  • unsignedLong  – rozsah 0 až 18446744073709551615
  • unsignedShort – rozsah 0 až 65535
  • unsignedByte – rozsah 0 až 255
  • double – 64 bitové číslo v plovoucí desetinné čárce
  • float – 32 bitové číslo v plovoucí desetinné čárce

Datový typ boolean umožňuje zapsat logickou hodnotu – tedy výsledek pravda nebo nepravda.

<xs:element name="studuje" type="xs:boolean"/>

Datový typ URI umožňuje zapsat odkaz.

<xs:element name="logo" type="xs:uri"/>

<logo>http://mojeadresa.tld/logo/logo.png</logo>

Vlastní datový typ

Lze definovat vlastní datový typ. Omezení zadávaných dat Pokud návrh datového souboru předpokládá omezení zadávaných hodnot, XSD je schopno jasně definovat rozpětí hodnot nebo řetězců, které může daná položka nabývat.

Příkladem může být následující jednoduchý příklad:

<xs:element name="vek">
  <xs:simpleType>
    <xs:restriction base="xs:integer">
      <xs:minInclusive value="0"/>
      <xs:maxInclusive value="150"/>
    </xs:restriction>
  </xs:simpleType>
</xs:element>

Zde je připraveno omezení pro datovou položku věk, kde se předpokládá integritní omezení – hodnoty mohou být mezi 0 a 150. 

Další možností je výčet hodnot:

<xs:element name="bonus">
  <xs:simpleType>
    <xs:restriction base="xs:string">
      <xs:enumeration value="1200 bodů"/>
      <xs:enumeration value="sleva 10%"/>
      <xs:enumeration value="doprava zdarma"/>
    </xs:restriction>
  </xs:simpleType>
</xs:element>

Zde je několik možností, které je možno zvolit jako bonus za nákup ve fiktivním e-shopu. Nic jiného nemůže být nabízeno.

Ještě lépe to je dle následujícího příkladu. Zatímco v tom výše uvedeném je definováno omezení přímo pro daný element. Následující příklad je lepší z hlediska přístupu k návrhu. Je definován nový datový typ s omezením a následně použit pro vybraný element – umožňuje připravit stejné omezení pro různé elementy. 

<xs:element name="bonus" type="typ_bonusu"/>
  <xs:simpleType name="typ_bonusu">
    <xs:restriction base="xs:string">
      <xs:enumeration value="1200 bodů"/>
      <xs:enumeration value="sleva 10%"/>
      <xs:enumeration value="doprava zdarma"/>
    </xs:restriction>
</xs:simpleType>

Omezení maskou

Pokud je potřeba hlídat přesné zadání vybraného řetězce, pak lze využít masku. 

<xs:element name="pismeno">
  <xs:simpleType>
    <xs:restriction base="xs:string">
      <xs:pattern value="[a-z]"/>
    </xs:restriction>
  </xs:simpleType>
</xs:element>

Maska omezuje zadání na pouze jedno písmeno.

Následující maska umožní zadat tři písmena.

<xs:element name="inicialy">
  <xs:simpleType>
    <xs:restriction base="xs:string">
      <xs:pattern value="[A-Z][A-Z][A-Z]"/>
    </xs:restriction>
  </xs:simpleType>
</xs:element>

Jsou povoleny přesně tři znaky a pouze velkými písmeny.

<xs:element name="inicialy">
  <xs:simpleType>
    <xs:restriction base="xs:string">
      <xs:pattern value="[a-zA-Z][a-zA-Z][a-zA-Z]"/>
    </xs:restriction>
  </xs:simpleType>
</xs:element>

Pokud chceme zadat neomezeně znaků, ale pouze písmenka lowercase, pak je platný následujíc zápis.

<xs:element name="zprava">
  <xs:simpleType>
    <xs:restriction base="xs:string">
      <xs:pattern value="([a-z])*"/>
    </xs:restriction>
  </xs:simpleType>
</xs:element>

Hvězdička znamená alespoň jeden znak, horní počet znaků je neomezený.

Pokud chceme přesně například 8 znaků, můžeme použít toto.

<xs:element name="heslo">
  <xs:simpleType>
    <xs:restriction base="xs:string">
      <xs:pattern value="[a-zA-Z0-9]{8}"/>
    </xs:restriction>
  </xs:simpleType>
</xs:element>

Bílé znaky

Práce s whitespace znaky je závislá na požadavku na jejich ponechání. Můžeme použít tři postupy pro zpracování bílých znaků.

Preserve – ponechání – všechny bílé znaky budou zachovány dle zadání.

<xs:element name="zprava">
  <xs:simpleType>
    <xs:restriction base="xs:string">
      <xs:whiteSpace value="preserve"/>
    </xs:restriction>
  </xs:simpleType>
</xs:element>

Další možnost je replace – dojde k nahrazení bílých znaků mezerou.

<xs:element name="zprava">
  <xs:simpleType>
    <xs:restriction base="xs:string">
      <xs:whiteSpace value="replace"/>
    </xs:restriction>
  </xs:simpleType>
</xs:element>

Poslední možností je collapse – pak jsou všechny znaky nahrazeny mezerou a pokud je někde více mezer za sebou, dojde k jejich redukci na jedinou.


<xs:element name="zprava">
  <xs:simpleType>
    <xs:restriction base="xs:string">
      <xs:whiteSpace value="collapse"/>
    </xs:restriction>
  </xs:simpleType>
</xs:element>

Omezení délky řetězce

Můžeme zadat přesnou délku řetězce, pokud nechceme omezovat znaky, které uživatel má povoleno zadávat, pak lze nastavit přesnou délku následovně.

<xs:element name="heslo">
  <xs:simpleType>
    <xs:restriction base="xs:string">
      <xs:length value="8"/>
    </xs:restriction>
  </xs:simpleType>
</xs:element>

Jinou možností je omezit nejmenší akceptovatelné množství znaků, největší možné množství znaků, případně obojí najednou.

<xs:element name="password">
  <xs:simpleType>
    <xs:restriction base="xs:string">
      <xs:minLength value="5"/>
      <xs:maxLength value="8"/>
    </xs:restriction>
  </xs:simpleType>
</xs:element>


Komplexní datový typ

Jiná možnost k omezení rozvětveného XSD kódu je použití komplexních datových typů. Ty umožňují definovat datový typ obsahující elementy, které se mohou vyskytovat v několika pozicích. Typicky to může být jméno a příjmení.

<xs:complexType name="osobni-info">
  <xs:sequence>
    <xs:element name="jmeno" type="xs:string"/>
    <xs:element name="prijmeni" type="xs:string"/>
  </xs:sequence>
</xs:complexType>

Použití je potom následující:

<xs:complexType name="kontakt">
  <xs:complexContent>
    <xs:extension base="osobni-udaje">
      <xs:sequence>
        <xs:element name="ulice" type="xs:string"/>
        <xs:element name="mesto" type="xs:string"/>
        <xs:element name="psc" type="xs:string"/>
      </xs:sequence>
  </xs:complexContent>
</xs:complexType>

Finální sestavení je pak toto:

<xs:element name="student" type="kontakt" />

Jak je vidět, tak z celého rozsáhlého kódu máme tři části - dílčí komplexní typ obsahující jméno a příjmení, sestavený s dalšími značkami dává komplexní typ adresa a je je přiřazen studentovi - jediné značce.


Skupina značek

Jinou cestou k zjednodušení návrhu je využití skupin - ať značek nebo elementů. Skupinu pak můžeme odazovat na vybraném místě.

<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:complexType name="osobni-info">
  <xs:sequence>
    <xs:element name="jmeno" type="xs:string"/>
    <xs:element name="prijmeni" type="xs:string"/>
  </xs:sequence>
</xs:complexType>

Skupinu máme připravenou, její vložení do struktury XSD je pak následující:

<xs:complexType name="kontakt">
  <xs:complexContent>
    <xs:extension base="osobni-udaje">
      <xs:sequence>
        <xs:group ref="adresa"/>
      </xs:sequence>
  </xs:complexContent>
</xs:complexType>

Skupina atributů

U zprávy můžeme kromě id evidovat ještě jazyk zprávy. Pak si můžeme pomoci skupinou atributů:

<xs:attributeGroup name="zprava-info">
  <xs:attribute name="id" type="xs:integer"/>
  <xs:attribute name="lang" type="xs:language"/>
</xs:attributeGroup>

Použití v XSD je následující:

<?xml version="1.0"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <xs:element name="zprava">
    <xs:complexType>
     <xs:sequence>
      <xs:element name="od" type="xs:string"/>
      <xs:element name="komu" type="xs:string"/>
      <xs:element name="predmet" type="xs:string"/>
      <xs:element name="text" type="xs:string"/>
     </xs:sequence>
    <xs:attributeGroup ref="zprava-info" /><!-- odkaz na skupinu atributů -->
    </xs:complexType>
   </xs:element>
</xs:schema>


Dokumentace

Kromě komentářů lze do XSD přidávat i dokumentaci - tedy delší text k vysvětlení určité části kódu. A to buď jednoduchou formou nebo za použití HTML značek.

<xs:complexType name="kontakt">
  <xs:annotation>

    <xs:documentation>
      Tady můžeme vložit nějaké dokumentační věty.
    </xs:documentation>
  </xs:annotation>
  <xs:complexContent>
    <xs:extension base="osobni-udaje">
      <xs:sequence>
              <xs:group ref="adresa" />
      </xs:sequence>
  </xs:complexContent>
</xs:complexType>

A nebo složitěji:

<xs:complexType name="kontakt">
  <xs:annotation>

    <xs:documentation xmlns="http://www.w3.org/1999/xhtml">
      <p>Nebo můžeme vložit HTML kód</p>
    </xs:documentation>
  </xs:annotation>
  <xs:complexContent>
    <xs:extension base="osobni-udaje">
      <xs:sequence>
              <xs:group ref="adresa" />
      </xs:sequence>
  </xs:complexContent>
</xs:complexType>


Validace hodnot

V XSD 1.1 je nově možné validovat hodnoty oproti nastavenému kriteriu. Je to inspirované Schematronem. Nicméně nejde definovat vlastní chybová hláška.

Příklad 1 potřebujeme kontrolovat definované hodnoty - zde zda není hodnota menší než 0:

<xs:simpleType name="spotreba">
  <xs:restriction base="xs:integer">
    <xs:assertion test="$value gt 0"/>
 
</xs:restriction>
</xs:simpleType>

V případě, že by hodnota měla být menší než - pak použijeme zápis le

<xs:simpleType name="spotreba">
  <xs:restriction base="xs:integer">
    <xs:assertion test="$value le 0"/>
 
</xs:restriction>
</xs:simpleType>

Pokud potřebujeme například ohodnotit klienta podle počtu zakázek (zde uloženy v atributu - ano, nemělo by to tak být :-)).

XSD

<xs:complexType name="Customer">
  <xs:sequence>
    <xs:element name="VIP" type="xs:string"/>
    <xs:element name="name" type="xs:string"/>
  </xs:sequence>
  <xs:attribute name="orders" type="xs:integer"/>
  <xs:assert test="if (@orders > 100)
                   then VIP = 'Silver' 
else if (@orders > 250)
then VIP = 'Gold'
else if (@orders > 500)
then VIP = 'Platinum'

else false()"
/>

</xs:complexType>