A sémakomponensek a következő három csoportját különböztetjük meg fontosságuk alapján:

A könyvben a jelölésdeklarációk kivételével tárgyalásra kerül valamennyi sémakomponens. Minden komponenst egy elem ábrázol a sémadokumentumokban.

Bizonyos sémakomponenseknek, egészen pontosan a deklarációknak és definícióknak lehet azonosítóként szolgáló neve, amely lehetővé teszi a komponensre történő hivatkozást. Az elsődleges sémakomponensek közül a deklarációkhoz kötelezően tartozik név, a típusdefiníciókhoz viszont csak opcionálisan. A másodlagos sémakomponensek mindegyikét kötelező névvel azonosítani. A segédkomponensek egyikének sincs neve, ezek a kommentárok kivételével minden esetben más komponensek részét alkotják, felhasználásuk kizárólag az előfordulásuk helyén történik.

A sémakomponensek neve egy kettőspont karaktert nem tartalmazó érvényes XML név. (Az XML névtereket tárgyaló [XML Names] dokumentum az ilyen nevekre az NCName kifejezést használja.) Sémadokumentumokban a komponenseket ábrázoló elemek name tulajdonságának értékeként kell megadni a neveket.

Minden sémadokumentumhoz tartozhat egy cél-névtér, amelynek értéke egy, az [XML Names] szabványnak megfelelő névtér név. Cél-névtér használata esetén a sémakomponensek nevei az általa meghatározott névtérbe tartoznak, hiányában pedig nem tartoznak egyetlen névtérbe sem.

Megjegyezzük, hogy azonos fajtájú sémakomponensek esetén követelmény a nevek egyedisége a sémában. Míg például minden tulajdonságcsoport-definíció neve különböző kell, hogy legyen, egy tulajdonságcsoport-definíció neve megegyezhet például egy típusdefiníció nevével.

A sémakomponenseket ábrázoló XML elemek nevei a http://www.w3.org/2001/XMLSchema URI által azonosított névtérbe tartoznak. Az ugyancsak ebbe a névtérbe tartozó schema nevű elem szolgál a sémadokumentumok gyökérelemeként. A gyakorlatban az xs vagy az xsd előtaghoz szokás a fenti névtér nevet egy névtér deklarációban hozzákötni, mi a továbbiakban az xs előtagot használjuk.

A sémadokumentumok alakja általánosan a következő:

<?xml version="1.0"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" targetNamespace="URI">
	sémakomponens(ek)
</xs:schema>

A schema elemhez opcionális a cél-névteret meghatározó targetNamespace tulajdonság, gyermekként pedig a következő sémakomponenseket tartalmazhatja tetszőleges számban és sorrendben:

Minden típust egy típusdefiníció határoz meg, amelyet egy típusdefiníciós sémakomponens ábrázol. A típusoknak (típusdefinícióknak) lehet neve, amely lehetővé teszi a típusra (típusdefinícióra) történő hivatkozást, így a többszöri felhasználást. A név azonban nem kötelező, névtelen típusoknak (névtelen típusdefinícióknak) nevezzük azokat a típusokat (típusdefiníciókat), amelyekhez nem tartozik név. Ezek a sémában egyetlen helyen kerülnek felhasználásra.

A továbbiakban a típus és típusdefiníció fogalmakat egyenértékűnek tekintjük, mivel a típus és definíciója között kölcsönösen egyértelmű megfeleltetés van.

A típusok (típusdefiníciók) révén fogalmazhatóak meg a példányokban előforduló elemekre és tulajdonságokra vonatkozó érvényességi megszorítások. Az XML Schema kétféle típust (típusdefiníciót) különböztet meg: egyszerű és komplex típusokat (típusdefiníciókat). A kétféle típusfogalom lényegesen különbözik.

Egyszerű típusok.  Minden egyszerű típushoz egy olyan értékhalmaz tartozik, amelynek elemeit szöveges literálok ábrázolják. Az XML Schema számos beépített egyszerű típust biztosít (például boolean, date, double és int), amelyek megfelelnek a programozási nyelvek és az adatbázis-kezelő rendszerek szokásos adattípusainak. Egyszerű típusokat használhatunk tulajdonságok és elemek típusaként egyaránt, az egyszerű típusú elemeknek azonban nem lehetnek tulajdonságaik. Az egyszerű típusok értelemszerűen nem teszik lehetővé tartalomként elemek használatát sem. Az egyszerű típusok alapfogalmait és gyakorlati alkalmazását külön fejezetek tárgyalják. (Lásd az Egyszerű típusok fogalmai és az Egyszerű típusok használata és származtatása című fejezeteket.)

Komplex típusok.  Komplex típusok kizárólag az elemekhez állnak rendelkezésre, ezek teszik lehetővé tartalomként elemek, valamint tulajdonságok használatát. Az egyszerű típusoktól eltérően a szabvány nem biztosít beépített komplex típusokat. A komplex típusokat részletesen a Komplex típusok című fejezet tárgyalja.

Egy kivételtől eltekintve minden típusdefiníció egy másik típusdefiníció megszorítása vagy kiterjesztése, amelyet alap-típusdefiníciónak nevezünk, az ennek megfelelő típus pedig az alaptípus. (Hamarosan látni fogjuk, hogy az egyszerű típusok esetén valójában két további származtatási lehetőség is adott.) A típusdefiníciók közötti ezen kapcsolatok egy hierarchiát határoznak meg.

A kivételt jelentő típusdefiníció a hierarchia csúcsán lévő, amelynek ur-típus-definíció a neve.[1] Ez a típusdefiníció implicit módon része minden sémának. Az ur-típus-definíciónak az anyType nevű komplex típus felel meg. Az ur-típus-definíció (anyType típus) a hierarchia gyökerét jelenti, amelyből az összes többi típusdefiníció (típus) származik.

Létezik egy egyszerű ur-típus-definíciónak nevezett olyan egyszerű típus-definíció is, amely a komplex ur-típus-definíció egy speciális megszorítása, és amelyből az összes egyszerű típus-definíció származik. A megfelelő egyszerű típus neve anySimpleType.

1.1. ábra - Típushierarchia

Alább a komplex és egyszerű típus-definíciókra is megadjuk a hierarchiába történő beépülésük lehetséges módjait.

Komplex típus-definíciók a hierarchiában.  Az ur-típus-definíciótól különböző minden komplex típus-definícióra az alábbiak egyike teljesül:

Egyszerű típus-definíciók a hierarchiában.  Az egyszerű ur-típus-definíciótól különböző minden egyszerű típus-definícióra az alábbiak egyike teljesül:

Megjegyezzük, hogy a listaképzéssel és unióképzéssel származtatott típusdefiníciók is az egyszerű ur-típus-definíció megszorításaiként tekintendők.

Egyszerű és komplex típus-definíciók esetében is korlátozhatja a felhasználó adott típusdefiníció új típusdefiníciók létrehozásához alap-típusdefinícióként (egyszerű típusdefiníciók esetén alap-, elem- vagy tag-típusdefinícióként) történő felhasználását. (Erre szolgál a típusdefiníciós elemek final tulajdonsága.)

Az értéktér az adattípus-értékek halmaza, amely többféle módon határozható meg:

Minden adattípushoz a fenti megoldások valamelyike használt. Megjegyezzük, hogy a primitív adattípusok értékterei diszjunktak.

A lexikális tér az adattípus értékeit reprezentáló karakterláncok (literálok) halmaza. Az XML Schema literáljainak felírása a programozási nyelvek és adatbázis-kezelő rendszerek hagyományait követi.

Az értéktér minden elemét a lexikális tér egy vagy több literálja is ábrázolhatja. Például a decimal adattípusnál az 1, +1, 1.0, 01 literálok ugyanazt az értéket jelölik.

A kanonikus lexikális reprezentáció a lexikális tér egy olyan részhalmaza, amely kölcsönösen egyértelműen feleltethető meg az értéktér elemeinek.

Kanonikus XML

Az alkalmazások számára fizikailag különböző XML dokumentumok ekvivalensek lehetnek információtartalmuk szempontjából. Az ekvivalencia okai lehetnek például az alábbiak: Tartalom nélküli elem megadható közvetlenül egymást követő nyitó- és zárócímkével vagy üreselem címkével is. Nem szignifikáns az elemekhez tartozó tulajdonság-specifikációk sorrendje. A tulajdonságérték-normalizálás különböző tulajdonságértékeknél eredményezheti ugyanazt a normalizált tulajdonságértéket. [XML-C14N] egy olyan algoritmust definiál, amellyel minden XML dokumentum egyértelműen alakítható át egy kanonikus alaknak nevezett ekvivalens XML dokumentummá. Ekvivalenseknek tekinthetők azok a dokumentumok, amelyek kanonikus alakja megegyezik. [XML-C14N] azonban szigorúan DTD-alapú, így a kanonikus alak létrehozásához nem kerül felhasználásra a fenti kanonikus lexikális reprezentáció.

Az adattípus-tulajdonságok az adattípusokat meghatározó tulajdonságok.[2] Az adattípusok definiálása az adattípus-tulajdonságok értékeinek rögzítésével történik, amelyek együtt meghatározzák az adattípus értékterét és jellemzőit.

Az adattípus-tulajdonságoknak a következő két fajtáját különböztetjük meg:

A logikai értékű bounded adattípus-alaptulajdonság azt jelzi, hogy az adattípus korlátos-e. Értéke true akkor, ha az adattípus korlátos, egyébként false.

Egy rendezett adattípust korlátosnak nevezünk akkor, ha létezik olyan érték, amely az értéktér minden egyes értékénél kisebb vagy egyenlő vagy szigorúan kisebb, valamint létezik olyan érték, amely az értéktér minden eleménél nagyobb vagy egyenlő vagy szigorúan nagyobb. Ez a két érték nem feltétlenül tartozik az értéktérhez származtatott adattípus esetén!

Egy atomi származtatott adattípus esetén true az adattípus-alaptulajdonság értéke akkor, ha adattípus-tulajdonságai között van a minInclusive vagy a minExclusive, valamint a maxInclusive vagy a maxExclusive, egyébként pedig false.

Egy lista adattípus esetén true az adattípus-alaptulajdonság értéke akkor, ha adattípus-tulajdonságai között van a length vagy a minLength és a maxLength, egyébként pedig false. (Azaz lista adattípusok esetén a korlátosság az elemek számának korlátosságát jelenti.)

Egy unió adattípusnál true az adattípus-alaptulajdonság értéke akkor, ha true minden tagtípus esetén is, továbbá van olyan (az anySimpleType típustól különböző) adattípus, amely őse valamennyi tagtípusnak, egyébként pedig false.

A beépített (rendezett) adattípusok közül korlátos például a double, float és long, nem korlátos a date és positiveInteger.

Az adattípus értékterének számosságát jelző adattípus-alaptulajdonság, amelynek lehetséges értékei finite (véges) és countably infinite (megszámlálhatóan végtelen). Az adattípus értékterének számosságát az adattípus számosságának is nevezzük.

Atomi származtatott típusok esetén meglehetősen bonyolult módon határozandó meg az adattípus-alaptulajdonság értéke, csupán a teljesség kedvéért adjuk meg ennek pontos menetét. Egy atomi származtatott típusnál finite az adattípus-tulajdonság értéke akkor, ha az alaptípus esetén is finite. Az adattípus-alaptulajdonság értéke finite akkor is, ha az alaptípus esetén countably infinite, de teljesül az alábbi feltételek valamelyike, egyébként pedig countably infinite:

Egy lista adattípusnál finite az adattípus-alaptulajdonság értéke akkor, ha adattípus-tulajdonságai között van a length vagy a minLength és a maxLength, egyébként pedig countably infinite.[3]

Egy unió adattípusnál finite az adattípus-alaptulajdonság értéke akkor, ha finite minden tagtípus esetén is, egyébként az értéke countably infinite.

A beépített adattípusok közül például a boolean, double és long adattípusoknál is finite az adattípus-alaptulajdonság értéke, míg például a date, duration és string adattípusoknál countably infinite.

Azokat az adattípusokat tekintjük numerikus adattípusoknak, amelyek értékterének elemei számok. A logikai értékű numeric adattípus-alaptulajdonság azt jelzi, hogy az adattípus numerikus-e. Értéke true akkor, ha az adattípus numerikus, egyébként false.

Egy atomi származtatott adattípus pontosan akkor numerikus, ha az alaptípusa is az. (Vagyis minden atomi származtatott adattípus az alaptípusától örökli a numeric adattípus-alaptulajdonság értékét.) A lista adattípusok nem numerikus adattípusok. Egy unió adattípus akkor és csak akkor numerikus, ha minden tagtípusa numerikus.

A beépített adattípusok közül numerikus például a long, double és float, nem numerikus a date, duration és a string adattípus.

A specifikáció számos beépített adattípus esetén egy rendezést értelmez az értéktér elemei között, ezeket az adattípusokat nevezzük a továbbiakban rendezett adattípusoknak. Az ordered adattípus-alaptulajdonság jelzi, hogy az adattípus rendezett-e, rendezés esetén annak jellegét megadva. Magát a rendezést az adattípusok leírásánál határozza meg pontosan a specifikáció, így teszünk mi is.

Az alábbi két fajta rendezést használja a specifikáció:

Az adattípus-alaptulajdonság lehetséges értékei:

Minden atomi származtatott adattípus az alaptípusától örökli az ordered adattípus-alaptulajdonság értékét. Lista adattípusok esetén az adattípus-alaptulajdonság értéke false. Unió adattípusok esetén az adattípus-alaptulajdonság értéke partial az alábbi kivételekkel:

Például nem értelmezett rendezés a boolean, hexBinary és string beépített adattípusok esetén. Szigorú részbenrendezés értelmezett csak a duration beépített adattípus esetén, mivel nem összehasonlíthatóak például a P1M („1 hónap”) és P30D („30 nap”) literálokkal ábrázolt értékek. A primitív adattípusok közül kizárólag a decimal esetén értelmezett szigorú teljes rendezés.

Kizárólag modellcsoportokban előforduló element elemekhez adható meg az előfordulások számát szabályozó minOccurs és maxOccurs tulajdonság:

<xs:element name="keywords">
    <xs:complexType>
        <xs:sequence>
            <xs:element name="keyword" type="xs:string" minOccurs="1" maxOccurs="10"/>
        </xs:sequence>
    </xs:complexType>
</xs:element>

A DTD tulajdonságlista-deklarációkban megengedi tulajdonságokhoz alapértelmezett érték előírását. Az XML Schema elemekhez is biztosítja alapértelmezett érték használatának lehetőségét. Globális és lokális elemdeklarációként előforduló element elemekhez adható meg a default tulajdonság, amely az elem alapértelmezett értékét határozza meg.

Az alapértelmezett érték a példányokban az elem üreselemként való előfordulásainál lép életbe. Ha azonban az elem nem jelenik meg a példányban, akkor az alapértelmezett érték sem kerül felhasználásra.

Kizárólag egyszerű típusú vagy olyan vegyes tartalmú (elemeket és szöveget is tartalmazó) elemekhez használható alapértelmezett érték, amelyek tartalomként megengedik csak szöveg előfordulását. Ha az elem egyszerű típusú, akkor az alapértelmezett érték az adattípus értékterének eleme kell, hogy legyen. Vegyes tartalmú elem esetén az alapértelmezett érték egy tetszőleges karakterlánc.

<xs:element name="numberOfChildren" type="xs:nonNegativeInteger" default="0"/>

A DTD tulajdonságlista-deklarációkban megengedi tulajdonságokhoz rögzített érték előírását. Az XML Schema elemekhez is biztosítja rögzített érték használatának lehetőségét. Globális és lokális elemdeklarációként előforduló element elemekhez adható meg a fixed tulajdonság, amely az elem rögzített értékét határozza meg.

Rögzített értékkel rendelkező elemek tartalmaként a példányokban kizárólag a rögzített érték megengedett. Rögzített értékű elemek megjelenhetnek a példányokban üreselemként is, ezen előfordulásokhoz a rögzített érték szolgáltat alapértelmezett értéket.

Kizárólag egyszerű típusú vagy olyan vegyes tartalmú (elemeket és szöveget is tartalmazó) elemekhez használható rögzített érték, amelyek tartalomként megengedik csak szöveg előfordulását. Ha az elem egyszerű típusú, akkor a rögzített érték az adattípus értékterének eleme kell, hogy legyen. Vegyes tartalmú elem esetén a rögzített érték egy tetszőleges karakterlánc.

<xs:element name="content-type" type="xs:string" fixed="text/html"/>

Az alább bemutatásra kerülő helyettesítési csoport mechanizmus lehetővé teszi a példányokban adott globális elem más globális elemekkel történő helyettesítését.

Kizárólag globális elemdeklarációként előforduló element elemekhez megengedett a substitutionGroup tulajdonság, amelynek értékeként egy globális elemdeklaráció nevét kell megadni. A substitutionGroup tulajdonság értékeként adott nevű elemet helyettesítheti a példányokban az az elem, amelynek deklarációjában megjelenik a tulajdonság. A helyettesítési csoport azokat az elemeket jelenti, amelyek egy adott elemet helyettesíthetnek.

A helyettesítő elem típusa meg kell, hogy egyezzen a helyettesítendő elem típusával, vagy annak típusából származtatott típus kell, hogy legyen.

Megjegyezzük, hogy a helyettesíthetőség tranzitív tulajdonság: ha a B elem helyettesítheti az A elemet, a C elem pedig a B elemet, akkor a C elem egyben az A elemet is helyettesítheti.

Körkörös helyettesíthetőség nem megengedett.

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

<xs:element name="surname" type="xs:string" substitutionGroup="familyName"/>

<xs:element name="lastName" type="xs:string" substitutionGroup="familyName"/>

<xs:element name="citizenship" type="xs:string" substitutionGroup="nationality"/>

<xs:element name="nationality" type="xs:string" substitutionGroup="citizenship"/>

A helyettesítési csoportokat gyakran absztrakt elemekhez használjuk.

Globális elemdeklarációként előforduló element elemekhez adható meg a logikai értékű abstract tulajdonság, amelynek alapértelmezett értéke false. Az olyan globális elemeket nevezzük absztrakt elemeknek, amelyek deklarációjában az abstract tulajdonság értéke true.

Absztrakt elemek nem fordulhatnak elő a példányokban, az ilyen elemekhez tipikusan egy helyettesítési csoportot használunk, amelynek tagjai helyettesíthetik az adott absztrakt elemet.

<xs:element name="uri" type="xs:anyURI" abstract="true"/>

<xs:element name="http-uri" substitutionGroup="uri">
    <xs:simpleType>
        <xs:restriction base="xs:anyURI">
            <xs:pattern value="http://.*"/>
        </xs:restriction>
    </xs:simpleType>
</xs:element>

<xs:element name="ftp-uri" substitutionGroup="uri">
    <xs:simpleType>
        <xs:restriction base="xs:anyURI">
            <xs:pattern value="ftp://.*"/>
        </xs:restriction>
    </xs:simpleType>
</xs:element>

Lokális tulajdonság-deklarációként és globális tulajdonság-deklarációra való hivatkozásként megjelenő attribute elemekhez adható meg a use tulajdonság, amelynek lehetséges értékei és jelentésük:

Az XML Schema a DTD-hez hasonlóan lehetővé teszi tulajdonságokhoz alapértelmezett érték előírását. Olyan attribute elemekhez adható meg az alapértelmezett értéket szolgáltató default tulajdonság, amelyeknél a use tulajdonság értéke optional. Az értékeként megjelenő alapértelmezett érték a deklarációhoz tartozó adattípus értékterének eleme kell, hogy legyen.

<xs:attribute name="enabled" type="xs:boolean" default="false"/>

Az XML Schema a DTD-hez hasonlóan lehetővé teszi tulajdonságokhoz rögzített érték előírását. Az attribute elem minden előfordulásánál megjelenhet a fixed tulajdonság, amely a tulajdonság rögzített értékét határozza meg. A tulajdonság értéke a deklarációhoz tartozó adattípus értékterének eleme kell, hogy legyen.

Rögzített értékkel rendelkező tulajdonságok értékeként a példányokban kizárólag a rögzített érték megengedett. Ha egy rögzített értékű opcionális tulajdonság nem kerül megadásra a példányban, akkor a rögzített érték szolgáltat alapértelmezett értéket.

<xs:attribute name="units" type="xs:token" fixed="cm"/>

Az [XML 1.0] specifikáció kötelezővé teszi az XML feldolgozók számára tulajdonságértékek normalizálását. A feldolgozók az érvényesség ellenőrzését a normalizált tulajdonságértékeken végzik el, az alkalmazásoknak ugyancsak a normalizált értékeket adják tovább. Ezt a tulajdonságérték-normalizálást végrehajtják a sémafeldolgozók is a tulajdonságértékek érvényességének ellenőrzése előtt.

Az XML Schema elemekhez is lehetővé teszi adattípusok használatát, amely a tulajdonságokkal egységesen történő kezelés biztosításához szükségessé teszi a whitespace normalizálás megfelelő értelmezését és kiterjesztését az elemekre is.

Egyszerű típusú elemek és tulajdonságok normalizált értéke normalizálással nyerhető:

A sémafeldolgozók érvényesítést az elemek és tulajdonságok normalizált értékén végeznek.

Az alábbi normalizálások definiáltak:

A whiteSpace korlátozó adattípus-tulajdonság alkalmazásával szabályozható a normalizálás, amelynek értékeként a fentieknek megfelelő preserve, replace és collapse adható meg.

A string adattípus kivételével minden beépített atomi adattípus esetén collapse a whiteSpace adattípus-tulajdonság értéke, amely nem változtatható meg. A string adattípus esetén preserve a whiteSpace adattípus-tulajdonság értéke, az adattípusból történő származtatás során azonban mindhárom lehetséges érték megadható ezen adattípus-tulajdonság értékeként.

Vegyük észre, hogy a tulajdonságértékeket ilyen módon kétszer normalizálja a sémafeldolgozó. A replace vagy collapse normalizálás végrehajtása az XML 1.0 tulajdonságérték-normalizálás után azonban nem felesleges, további változást nem eredményező művelet. Karakterhivatkozások használata révén maradhatnak ugyanis TAB, CR és LF karakterek az XML 1.0 tulajdonságérték-normalizált tulajdonságértékben, amelyeket replace és collapse szóköz karakterekre cserél.

<number>
    12<!-- This is a comment -->43
</number>

<title xml:lang="hu">
    Az ember, aki <!-- This is a comment --> csütörtök
    volt</title>

    Az ember, aki  csütörtök
    volt

Az XML 1.0 tartalommodellnek nevezi azokat a kifejezéseket, amelyeket az olyan elemek deklarációiban használunk a megengedett tartalom meghatározására, amelyekben gyermekként csak elemek fordulhatnak elő. Egy tartalommodell például az

<!ELEMENT d (a?,(b|c)+)*>

DTD elemtípus-deklarációban az (a?,(b|c)+)* kifejezés. Egy tartalommodell meghatározza a gyermekként megengedett elemek nevét és sorrendjét.

Az XML Schema a DTD-hez hasonlóan teszi lehetővé komplex típusok definícióihoz a tartalommodellek leírását. Az alább bemutatásra kerülő konstrukciók segítségével kifejezhető a DTD összes lehetséges tartalommodellje.

Míg a tartalommodelleket a DTD-ben a reguláris kifejezésekéhez hasonló szintaxis ábrázolja, addig az XML Schema elemeket használ a tartalmodellek leírására. A DTD tartalommodell szintaxisa tömörebbnek és jobban olvashatónak tűnhet, használata mégis nagyon kényelmetlen lehet olyan esetekben, amelyekben ugyanakkor az XML Schema egyszerű megoldást kínál.

<!ELEMENT d ((a,b,c)|(a,c,b)|(b,a,c)|(b,c,a)|(c,a,b)|(c,b,a))>

<xs:element name="d">
    <xs:complexType>
        <xs:all>
            <xs:element ref="a"/>
            <xs:element ref="b"/>
            <xs:element ref="c"/>
        </xs:all>
    </xs:complexType>
</xs:element>

Modellcsoportoknak nevezzük az XML Schema alábbi, tartalommodellek kifejezésére szolgáló konstrukcióit:

Minden modellcsoportot egy azonos nevű elem ábrázol az XML Schema névtérben. Mindhárom esetben megadható

A két tulajdonság alapértelmezett értéke mind a három modellcsoport esetén 1, azonban lehetséges értékeik eltérőek.

Tartalommodellek leírásához minden egyes modellcsoportban az alábbiak közül bizonyosak adhatóak meg tetszőleges számban és sorrendben:

A tartalommodellek fenti alkotóelemeit részecskéknek nevezzük. Megjegyezzük, hogy a modellcsoportoknál részben eltérő korlátozások vonatkoznak a részecskék használatára (az all modellcsoport sokkal korlátozottabb módon használható, mint a sequence és a choice).

Egy-egy szakasz mutatja be az egyes modellcsoportokat. Látni fogjuk, hogy a modellcsoportok egymásba ágyazhatósága révén tetszőlegesen összetett tartalommodelleket ki lehet fejezni.

<xs:element name="file">
    <xs:complexType>
        <xs:sequence>
            <xs:element name="uri" type="xs:anyURI"/>
            <xs:element name="description" type="xs:string" minOccurs="0"/>
            <xs:element name="size" type="xs:nonNegativeInteger"/>
            <xs:element name="contentType" type="xs:string"/>
            <xs:element name="lastModified" type="xs:dateTime" minOccurs="0"/>
        </xs:sequence>
    </xs:complexType>
</xs:element>

<file>
    <uri>http://www.apache.org/dist/ant/binaries/apache-ant-1.8.2-bin.zip</uri>
    <size>10920710</size>
    <contentType>application/zip</contentType>
    <lastModified>2010-12-20T18:47:00Z</lastModified>
</file>

<file>
    <uri>http://spaceflight.nasa.gov/gallery/images/apollo/apollo11/hires/as11_40_5903.jpg</uri>
    <description>Astronaut Edwin Aldrin, Jr.</description>
    <size>3101893</size>
    <contentType>image/jpeg</contentType>
</file>

<xs:element name="data">
    <xs:complexType>
        <xs:sequence minOccurs="0" maxOccurs="unbounded">
            <xs:element ref="block"/>
            <xs:element ref="checksum"/>
        </xs:sequence>
    </xs:complexType>
</xs:element>

<xs:element name="value">
    <xs:complexType>
        <xs:choice>
            <xs:element name="float" type="xs:float"/>
            <xs:element name="int" type="xs:int"/>
            <xs:element name="string" type="xs:string"/>
        </xs:choice>
    </xs:complexType>
</xs:element>

<value><float>1E-5</float></value>
<value><int>1024</int></value>
<value><string>C-3PO</string></value>

<xs:element name="array">
    <xs:complexType>
        <xs:choice>
            <xs:element name="float" type="xs:float" maxOccurs="unbounded"/>
            <xs:element name="int" type="xs:int" maxOccurs="unbounded"/>
            <xs:element name="string" type="xs:string" maxOccurs="unbounded"/>
        </xs:choice>
    </xs:complexType>
</xs:element>

<array>
    <string>George</string>
    <string>John</string>
    <string>Paul</string>
    <string>Ringo</string>
</array>

<xs:element name="array">
    <xs:complexType>
        <xs:choice maxOccurs="unbounded">
            <xs:element name="float" type="xs:float"/>
            <xs:element name="int" type="xs:int"/>
            <xs:element name="string" type="xs:string"/>
        </xs:choice>
    </xs:complexType>
</xs:element>

<array>
    <string>Mace Windu</string>
    <int>42</int>
    <string>Obi-Wan Kenobi</string>
    <float>123.0</float>
    <string>Qui-Gon Jinn</string>
</array>

<xs:element name="address">
    <xs:complexType>
        <xs:all>
            <xs:element name="street" type="xs:string"/>
            <xs:element name="city" type="xs:string"/>
            <xs:element name="state" type="xs:string" minOccurs="0" maxOccurs="1"/>
            <xs:element name="postalCode" type="xs:string"/>
            <xs:element name="country" type="xs:string"/>
        </xs:all>
	</xs:complexType>
</xs:element>

<address>
    <city>Debrecen</city>
    <street>Egyetem tér 1.</street>
    <postalCode>4032</postalCode>
    <country>Hungary</country>
</address>

<address>	
    <street>456 Kent Street</street>
    <city>Sydney</city>
    <state>NSW</state>
    <postalCode>2000</postalCode>
    <country>Australia</country>
</address>

Ha egy modellcsoport azonos nevű elemdeklarációkat tartalmaz részecskeként közvetlenül vagy közvetett módon, akkor az azonos nevű deklarációkhoz ugyanaz a felső szintű (névvel rendelkező) típusdefiníció kell, hogy tartozzon. A közvetlen tartalmazás az elemgyermekként való tartalmazást jelenti. A közvetett tartalmazás pedig azt, hogy a deklarációt egy, a modellcsoportban elemgyermekként előforduló vagy hivatkozott sequence vagy choice modellcsoport tartalmazza közvetlenül vagy közvetett módon.

5.10. példa - Nem megengedett modellcsoport

Nem megengedett például az alábbi három modellcsoport, mert a részecskeként felhasznált azonos nevű elemek különböző típusúak:

<xs:choice>
    <xs:element name="value" type="xs:int"/>
    <xs:element name="value" type="xs:string"/>
</xs:choice>

<xs:sequence>
    <xs:element name="value" type="xs:int"/> 
    <xs:element name="value" type="xs:string"/>
</xs:sequence>

<xs:sequence>
    <xs:choice>
        <xs:element name="value1" type="xs:int"/>
        <xs:element name="value2" type="xs:string"/>
    </xs:choice> 
    <xs:element name="value1" type="xs:string"/>
</xs:sequence>

	Megjegyzés
	Az első modellcsoport kiváltható az alábbi elemdeklarációval, amely a value elemben tartalomként megengedi az int és string adattípus literáljait is: <xs:element name="value"> <xs:simpleType> <xs:union memberTypes="xs:int xs:string"/> </xs:simpleType> </xs:element>

Egy további korlátozás, hogy minden modellcsoport egyértelmű kell, hogy legyen a következő értelemben. Ha egy modellcsoportot érvényesítéshez kell felhasználni, akkor minden egyes elem egyértelműen megfeleltethető kell, hogy legyen a modellcsoportban közvetlenül vagy közvetett módon tartalmazott valamely részecskének úgy, hogy ehhez nem használhatóak fel az elem tartalma és tulajdonságai, sem a dokumentumban ezt követő elemek.

<xs:sequence>
    <xs:choice>
        <xs:element ref="A"/>
        <xs:element ref="B" minOccurs="0"/>
    </xs:choice>
    <xs:choice>
        <xs:element ref="A"/>
        <xs:element ref="C"/>
    </xs:choice>
</xs:sequence>

<xs:sequence>
    <xs:choice>
        <xs:element ref="A"/>
        <xs:element ref="B"/>
    </xs:choice>
    <xs:choice>
        <xs:element ref="A"/>
        <xs:element ref="C"/>
    </xs:choice>
</xs:sequence>

<xs:sequence>
    <xs:choice>
        <xs:element ref="A"/>
        <xs:element ref="B"/>
    </xs:choice>
    <xs:choice>
        <xs:element ref="A" minOccurs="0"/>
        <xs:element ref="C"/>
    </xs:choice>
</xs:sequence>

A modellcsoport-definíciók olyan másodlagos sémakomponensek, amelyek egy modellcsoport elnevezését teszik lehetővé többszöri felhasználás céljából. Az alábbi módon adható meg a schema elem gyermekeként egy modellcsoport-definíció:

<xs:group name="név"> modellcsoport </xs:group>

Az elemben tartalomként pontosan egy sequence, choice vagy all modellcsoport kötelező, amelyekhez nem adható meg sem a minOccurs, sem a maxOccurs tulajdonság.

Egy modellcsoport-definícióra a sequence és choice modellcsoportokban lehet hivatkozni az alábbi módon:

<xs:group ref="név"/>

A hivatkozás a modellcsoport-definícióban tartalmazott modellcsoport felhasználást eredményezi a hivatkozás helyén. A hivatkozásban adható meg a modellcsoporthoz a minOccurs és maxOccurs tulajdonság.

<xs:group name="startAndEndDate">
    <xs:sequence>
        <xs:element name="startDate" type="xs:date"/>
        <xs:element name="endDate" type="xs:date"/>
    </xs:sequence>
</xs:group>

<xs:element name="event">
    <xs:complexType>
        <xs:sequence>
            <xs:element name="title" type="xs:string"/>
            <xs:group ref="startAndEndDate"/>
            <xs:element name="location" type="xs:string"/>
        </xs:sequence>
    </xs:complexType>
</xs:element>

<event>
    <title>XIX. Budapesti Nemzetközi Könyvfesztivál</title>
    <startDate>2012-04-19</startDate>
    <endDate>2012-04-22</endDate>
    <location>Budapest</location>
</event>

<xs:group name="floatOrIntOrString">
    <xs:choice>
        <xs:element name="float" type="xs:float"/>
        <xs:element name="int" type="xs:int"/>
        <xs:element name="string" type="xs:string"/>
    </xs:choice>
</xs:group>

<xs:element name="array">
    <xs:complexType>
        <xs:group ref="floatOrIntOrString" minOccurs="1" maxOccurs="unbounded"/>
    </xs:complexType>
</xs:element>

Komplex típusú minden olyan elem, amelyhez megengedett tulajdonságok használata. Egy egyszerű típus definíciójának kiterjesztésével alkotható olyan típusdefiníció, amely tartalomként csak az alaptípus literáljait engedi meg. A kiterjesztés formája a következő (a felső szintű típusdefiníciót adjuk meg, névtelen típusdefinícióban el kell hagyni a name tulajdonságot):

<xs:complexType name="név">
    <xs:simpleContent>
        <xs:extension base="alaptípus">
            tulajdonságok használatára vonatkozó elemek
        </xs:extension>
    </xs:simpleContent>
</xs:complexType>

<xs:element name="image">
    <xs:complexType>
        <xs:simpleContent>
            <xs:extension base="xs:anyURI">
                <xs:attribute name="width" type="xs:nonNegativeInteger" use="optional"/>
                <xs:attribute name="height" type="xs:nonNegativeInteger" use="optional"/>
            </xs:extension>
        </xs:simpleContent>
    </xs:complexType>
</xs:element>

<image width="72" height="48">http://www.w3.org/Icons/w3c_home.png</image>

<xs:simpleType name="myDecimal">
    <xs:restriction base="xs:decimal">
        <xs:minInclusive value="0"/>
        <xs:fractionDigits value="2"/>
    </xs:restriction>
</xs:simpleType>

<xs:element name="price">
    <xs:complexType>
        <xs:simpleContent>
            <xs:extension base="myDecimal">
                <xs:attribute name="currency" use="optional" default="EUR">
                    <xs:simpleType>
                        <xs:restriction base="xs:token">
                            <xs:enumeration value="CHF"/>
                            <xs:enumeration value="EUR"/>
                            <xs:enumeration value="USD"/>
                        </xs:restriction>
                    </xs:simpleType>    
                </xs:attribute>
            </xs:extension>
        </xs:simpleContent>
    </xs:complexType>
</xs:element>

Egy komplex típus definíciója lehet egy másik komplex típus definíciójának kiterjesztése. A kiterjesztés révén származtatott új típus örökli az alaptípus tartalommodelljét és tulajdonságait, amelyeket bővíthet. A kiterjesztés módja az alábbi (a felső szintű típusdefiníciót adjuk meg, névtelen típusdefinícióban el kell hagyni a name tulajdonságot):

<xs:complexType name="név">
    <xs:complexContent>
        <xs:extension base="alaptípus">
            tartalommodellt megadó elem
            tulajdonságok használatára vonatkozó elemek
        </xs:extension>
    </xs:complexContent>
</xs:complexType>

A származtatott típus tartalommodellje egy olyan sequence modellcsoportként tekinthető, amelyben az alaptípus tartalommodelljét az extension elemben megadott tartalommodell követi. Természetesen az eredményül kapott tartalommodellre is kell, hogy teljesüljenek a modellcsoportokra vonatkozó korlátozások. A származtatott típushoz csak olyan tulajdonságok adhatóak meg, amelyek nevei különböznek az alaptípus tulajdonságainak neveitől.

<xs:complexType name="eventType">
    <xs:sequence>
            <xs:element name="date" type="xs:date"/>
            <xs:element name="place" type="xs:string"/>
    </xs:sequence>
</xs:complexType>

<xs:element name="birth" type="eventType"/>

<xs:element name="death">
    <xs:complexType>
        <xs:complexContent>
            <xs:extension base="eventType">
                <xs:sequence>
                    <xs:element name="cause" type="xs:string" minOccurs="0"/>
                </xs:sequence>
            </xs:extension>
        </xs:complexContent>
    </xs:complexType>
</xs:element>

<xs:element name="person">
    <xs:complexType>
        <xs:sequence>
            <xs:element name="name" type="xs:string"/>
            <xs:element ref="birth"/>
            <xs:element ref="death" minOccurs="0"/>
        </xs:sequence>
    </xs:complexType>
</xs:element>

<person>
    <name>John F. Kennedy</name>
    <birth>
        <date>1917-05-29</date>
        <place>Brookline, Massachusetts, U.S.</place>
    </birth>
    <death>
        <date>1963-11-22</date>
        <place>Dallas, Texas, U.S.</place>
        <cause>assassination</cause>
    </death>
</person>

<xs:sequence>
    <xs:sequence>
        <xs:element name="date" type="xs:date"/>
        <xs:element name="place" type="xs:string"/>
    </xs:sequence>
    <xs:sequence>
        <xs:element name="cause" type="xs:string" minOccurs="0"/>
    </xs:sequence>
</xs:sequence>

<xs:complexType name="CelestialObjectType">
    <xs:sequence>
        <xs:element name="mass" type="xs:double"/>
    </xs:sequence>
    <xs:attribute name="id" type="xs:ID" use="required"/>
</xs:complexType>

<xs:complexType name="PlanetType">
    <xs:complexContent>
        <xs:extension base="CelestialObjectType">
            <xs:sequence>
                <xs:element name="hasMoon" minOccurs="0" maxOccurs="unbounded">
                    <xs:complexType>
                        <xs:attribute name="ref" type="xs:IDREF" use="required"/>
                   </xs:complexType>
                </xs:element>
            </xs:sequence>
        </xs:extension>
    </xs:complexContent>
</xs:complexType>

<xs:element name="SolarSystem">
    <xs:complexType>
        <xs:sequence>
            <xs:element ref="CelestialObject" minOccurs="0" maxOccurs="unbounded"/>
        </xs:sequence>
    </xs:complexType>
</xs:element>

<xs:element name="CelestialObject" type="CelestialObjectType"/>

<xs:element name="Planet" type="PlanetType" substitutionGroup="CelestialObject"/>

<SolarSystem>

    <Planet id="MARS">
        <mass>6.421e+23</mass>
        <hasMoon ref="PHOBOS"/>
        <hasMoon ref="DEIMOS"/>
    </Planet>

    <CelestialObject id="PHOBOS">
        <mass>1.08e+16</mass>
    </CelestialObject>

    <CelestialObject id="DEIMOS">
        <mass>1.80e+15</mass>
    </CelestialObject>

</SolarSystem>

Egy komplex típus definíciója lehet egy másik komplex típus definíciójának megszorítása. A megszorítás révén az alaptípus tartalommodellje és tulajdonságainak használata korlátozható. A megszorítást az alábbi formában kell megadni (a felső szintű típusdefiníciót adjuk meg, névtelen típusdefinícióban el kell hagyni a name tulajdonságot):

<xs:complexType name="név">
    <xs:complexContent>
        <xs:restriction base="alaptípus">
            tartalommodellt megadó elem
            tulajdonságok használatára vonatkozó elemek
        </xs:restriction>
    </xs:complexContent>
</xs:complexType>

Megjegyzés

Megjegyezzük, hogy valójában az anyType típus definíciójának megszorítása minden olyan típusdefiníció, ahol a complexType elemben nem jelenik meg sem az extension, sem a restriction elem. Például a <xs:complexType> <xs:sequence minOccurs="0" maxOccurs="unbounded"> <xs:element ref="item"/> </xs:sequence> </xs:complexType> típusdefiníció a következő típusdefinícióval ekvivalens: <xs:complexType> <xs:complexContent> <xs:restriction base="xs:anyType"> <xs:sequence minOccurs="0" maxOccurs="unbounded"> <xs:element ref="item"/> </xs:sequence> </xs:restriction> </xs:complexContent> </xs:complexType>

A kiterjesztéstől eltérően a származtatott típus nem örökli az alaptípus tartalommodelljét. A restriction elemben az alaptípus tartalommodelljének egy módosított változata adható meg. Csak olyan módosítások történhetnek az eredeti tartalommodellen, amelyek szűkítik az alaptípus által megengedett tartalmak halmazát, valamint az új típus által megengedett tartalmak meg kell, hogy feleljenek az alaptípus tartalommodelljének is. Például az alábbi módosítások jöhetnek szóba:

A kiterjesztéshez hasonlóan a származtatott típus örökli az alaptípus tulajdonságait. A restriction elemben a tartalommodellt követően elhelyezhetők az alaptípus tulajdonság-deklarációinak módosított változatai, így megváltoztathatók az alaptípus tulajdonságok használatára vonatkozó előírásai. Csak olyan módosítás végezhető, amely a tulajdonságok használatát szűkíti. Például az alábbi változtatások történhetnek:

<xs:complexType name="PersonType">
    <xs:sequence>
        <xs:choice>
            <xs:sequence>
                <xs:element name="givenName" type="xs:string"/>
                <xs:element name="surname" type="xs:string"/>
            </xs:sequence>
            <xs:element name="name" type="xs:string"/>
        </xs:choice>
        <xs:element name="email" type="xs:string" minOccurs="0" maxOccurs="unbounded"/>
        <xs:element name="homePage" type="xs:anyURI" minOccurs="0" maxOccurs="unbounded"/>
    </xs:sequence>
    <xs:attribute name="nick" type="xs:string" use="optional"/>
</xs:complexType>

<xs:element name="Person" type="PersonType"/>

<Person nick="TimBL">
    <givenName>Timothy John</givenName>
    <surname>Berners-Lee</surname>
    <email>timbl@w3.org</email>
    <homePage>http://www.w3.org/People/Berners-Lee/</homePage>
</Person>

<Person>
    <givenName>Mark</givenName>
    <surname>Zuckerberg</surname>
</Person>

<Person nick="DOS">
    <name>Daniel O’Sullivan</name>
    <email>mothlite@gmail.com</email>
    <homePage>http://www.myspace.com/danielohsullivan</homePage>
    <homePage>http://www.mothlite.org/</homePage>
    <homePage>http://mothlite.blogspot.com/</homePage>
</Person>

<xs:complexType name="SimplePersonType">
    <xs:complexContent>
        <xs:restriction base="PersonType">
            <xs:sequence>
                <xs:element name="name" type="xs:string"/>
                <xs:element name="email" type="xs:string" minOccurs="1"/>
                <xs:element name="homePage" type="xs:anyURI" minOccurs="0" maxOccurs="1"/>
            </xs:sequence>
            <xs:attribute name="nick" use="required">
                <xs:simpleType>
                    <xs:restriction base="xs:string">
                        <xs:maxLength value="10"/>
                    </xs:restriction>
                </xs:simpleType>
            </xs:attribute>
        </xs:restriction>
    </xs:complexContent>
</xs:complexType>

5.25. példa - Komplex típus megszorítása

Egy irányított gráf csúcsokból és azokat összekötő irányított élekből áll. Egy irányított gráf látható az alábbi ábrán:

5.1. ábra - Irányított gráf

A fenti gráfot ábrázolhatjuk például az alábbi módon:

<graph>
    <node id="N1">
        <hasEdgeTo ref="N2"/>
    </node>
    <node id="N2">
        <hasEdgeTo ref="N3"/>
        <hasEdgeTo ref="N4"/>
    </node>
    <leafNode id="N3"/>
    <leafNode id="N4"/>
</graph>

A graph elemben kétféle elemet használunk a gráf csúcsainak ábrázolásához:

• A leafNode elemek azoknak a csúcsoknak felelnek meg, amelyekből nem indul egyetlen él sem (ezeket levélcsúcsoknak nevezzük).

• A node elemek azoknak a csúcsoknak felelnek meg, amelyekből legalább egy él indul (ezeket belső csúcsoknak nevezzük).

Minden csúcshoz egy egyedi azonosítót rendelünk hozzá, amelyet az id tulajdonság hordoz. A node elemekben legalább egy hasEdgeTo elem kötelező, amely a ref tulajdonság értékével egy él végpontját adja meg. Értelemszerű, hogy a leafNode elemeknek nincs tartalma.

Az alábbi sémát alkothatjuk a gráfok fenti formájú leírásához:

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

    <xs:complexType name="NodeType">
        <xs:sequence>
            <xs:element name="hasEdgeTo" minOccurs="0" maxOccurs="unbounded">
                <xs:complexType>
                    <xs:attribute name="ref" type="xs:IDREF" use="required"/>
                </xs:complexType>
            </xs:element>
        </xs:sequence>
        <xs:attribute name="id" type="xs:ID" use="required"/>
    </xs:complexType>

    <xs:complexType name="LeafNodeType">
        <xs:complexContent>
            <xs:restriction base="NodeType"/>
        </xs:complexContent>
    </xs:complexType>

    <xs:element name="graph">
        <xs:complexType>
            <xs:sequence>
                <xs:element ref="node" minOccurs="0" maxOccurs="unbounded"/>
            </xs:sequence>
        </xs:complexType>
    </xs:element>

    <xs:element name="node" type="NodeType"/>

    <xs:element name="leafNode" type="LeafNodeType" substitutionGroup="node"/>

</xs:schema>

A NodeType komplex típus szolgál a node elem, a LeafNodeType komplex típus pedig a leafNode elem típusául. Figyeljük meg, hogy a LeafNodeType típust megszorítással származtatjuk a NodeType típusból. A restriction elemben nem adunk meg tartalommodellt, megtiltva így a származtatott típus esetén tartalomként elemek és szöveg előfordulását, amely az alaptípus tartalommodelljének szűkítése. A származtatott típus azonban örökli az alaptípus tulajdonság-deklarációit, így a LeafNodeType típusú elemekhez is kötelező az id tulajdonság.

Figyeljük meg, hogy a leafNode elem deklarációjában a substitutionGroup tulajdonság értékeként a node elem jelenik meg, amely azt jelenti, hogy a leafNode elem helyettesítheti a node elemet. Ez megengedett, mivel a LeafNodeType típust a NodeType típusból származtattuk megszorítással.

A helyettesítési csoport használata miatt a graph elemben tartalomként elég megengedni a node elem előfordulását, mivel helyette bárhol megengedett egy leafNode elem.

A típusdefinícióhoz megadható final tulajdonság révén korlátozható a származtatás, amelynek lehetséges értékei és ezek jelentése:

Megjegyezzük, hogy a schema elemhez megadható finalDefault tulajdonsággal határozható meg a típusok final tulajdonságának alapértelmezett értéke.