Skeemid

Kui andmestik on lihtne ja alati samade tunnustega, siis on hea ette võtta sobiv 
näide, omad andmed asemele panna ning saabki uusi andmeid olemasoleval kohal 
kasutada. Kui aga on vaja täpsemalt teada, mis kuhu lubatud on, siis selle 
kirjapanekuks on välja mõeldud skeemid. Seal määratakse, millise nimega 
elemendid millises järjekorras on lubatud ning millist tüüpi ja millises 
vahemikus andmeid võib kusagil kasutada. Skeemi järgi saab andmefaili 
automaatselt kontrollida ning selle kaudu vähemasti märgatava osa näpuvigu 
avastada. Vigade avastamine võimalikult varakult aitab vältida nende mõju 
kasvamist. Samuti on skeemi pealt hea vaadata rakenduste loojatel, et kuidas 
andmeid esitada tuleb. Mis on lubatud ja mis mitte.

Tutvuda tasub alates kõige lihtsamast võimalusest. XML-dokument, kus on vaid ühe 
teate tekst. 

<?xml version="1.0" ?>
<teade>Uus aasta algab 1. jaanuaril.</teade>

Et seal saab olla vaid üks tekstiline teade ja ei midagi muud, see tuleb 
skeemina kirja panna järgnevalt. 


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


Kuna skeem ise vastab XML-i reeglitele, siis peab tal ülal olema 
tüübideklaratsioon.

<?xml version="1.0" ?>

Edasi teatatakse, et algab skeem.

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

Sealt siis teated, et millise nime ja millise tüübiga elemendid tulevad. Praegu 
ainult üks element nimega teade ja sisutüübiks string.

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

Ja nagu XMLi puhul ikka, siis alanud element tuleb lõpetada. 

</xs:schema>


Andmete vastavust skeemile saab kontrollida mitmetes programmeerimiskeeltes. 
Järgnevalt näide Java kohta. Kõigepealt luuakse vastavalt skeemifailile 
validaator ning edasi kontrollitakse selle järgi soovitud faili.


import javax.xml.validation.*;
import javax.xml.XMLConstants;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.*;
import javax.xml.parsers.*;
import org.w3c.dom.*;
import java.io.*;
public class SkeemiKontroll{
  public static void main(String[] argumendid) throws Exception{
        if(argumendid.length!=2){
            System.out.println("Kasuta kujul: java SkeemiKontroll skeem.xsd 
andmefail.xml");
            System.exit(0);
        }
        Validator 
validaator=SchemaFactory.newInstance("http://www.w3.org/2001/XMLSchema").
                             newSchema(new 
StreamSource(argumendid[0])).newValidator();
        validaator.validate(new StreamSource(argumendid[1]));
  }
}

Nagu ikka, tuleb enne käivitamist fail kompileerida. Ning edasi tuleb talle ette 
anda skeem ning andmefail.

c:\temp>javac SkeemiKontroll.java
c:\temp>java SkeemiKontroll teade.xsd teade.xml


Skeemifaili asukoht on võimalik ka andmefaili enese sisse kirjutada. Järgnevas 
näites märgitakse, et andmetele vastava skeemi leiab failist nimega 
teateskeem.xsd . Kui failid avada nt Microsoft Visual Studio abil ja nad asuvad 
samas kataloogis, siis kontrollitakse automaatselt, kas andmefail vastab 
skeemile. Kui kõik on korras, siis ei teatata midagi.


<?xml version="1.0" ?>
<teade xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:noNamespaceSchemaLocation="teateskeem.xsd">
  Uus aasta algab 1. jaanuaril.
</teade>

Kui aga andmefail ei peaks skeemile vastama, siis antakse vastav hoiatus. Siin 
on teate sisse lisatud skeemis kirjeldamata element nimega "selgitus". Visual 
Studio keskkond tõmbab sellele hoiatusjoone alla. Mõnes muus kohas aga näiteks 
teatatakse käsureaaknast, et millisel koodireal ja milline viga leiti.


<?xml version="1.0" ?>
<teade xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:noNamespaceSchemaLocation="teateskeem.xsd">
  Uus aasta algab 1. jaanuaril.
  <selgitus></selgitus>
</teade>
 

Mitmest elemendist koosnev skeem.

Harva piirdub XML-fail ühe elemendiga. Ning õigupoolest pole nii lihtsa faili 
tarbeks põhjust ka skeemi koostada. Kui elemente rohkem, siis aga skeem 
kindlasti omal kohal. Järgnev kirjeldus inimese andmete kohta. Väliseks 
elemendiks inimene. Et tema sisse saab teisi elemente paigutada, siis 
määratakse, et tegemist on complexType'ga. Ning siin näites paiknevad sisemised 
elemendid kindlas järjekorras jadana (sequence). Kõigepealt eesnimi stringi ehk 
tekstina, siis perenimi ning lõpuks synniaasta. Viimane peab olema täisarvuline, 
et andmestik validaatorist läbi läheks. 


<?xml version="1.0" ?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <xs:element name="inimene">
     <xs:complexType>
        <xs:sequence>
           <xs:element name="eesnimi" type="xs:string" />
           <xs:element name="perenimi" type="xs:string" />
           <xs:element name="synniaasta" type="xs:integer" />
        </xs:sequence>
     </xs:complexType>
  </xs:element>
</xs:schema>

Skeemile vastav näide siis järgmine. 


<?xml version="1.0" ?>
<inimene>
  <eesnimi>Juku</eesnimi>
  <perenimi>Juurikas</perenimi>
  <synniaasta>1989</synniaasta>
</inimene>




Kui tahta, et suudetaks ka automaatselt kontrollida andmete vastavust skeemile, 
siis tuleb skeemifaili asukoht juurelemendi atribuudi juures ära määrata.

<?xml version="1.0" ?>
<inimene xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:noNamespaceSchemaLocation="inimene1.xsd">
  <eesnimi>Juku</eesnimi>
  <perenimi>Juurikas</perenimi>
  <synniaasta>1989</synniaasta>
</inimene>


Ülesandeid

* Koosta skeem auto registrinumbri hoidmiseks.
* Loo vastav andmefail. Testi andmefaili vastavust skeemile.
* Koosta skeem, kus auto kohta on kirjas registrinumber, mark ja 
väljalaskeaasta.
* Testi andmestiku vastavust skeemile.

Elemendi esinemise kordade arv

Eelmises näites on iga element ühekordselt. Kui midagi eraldi määratud pole, 
siis käibki nõnda. Ehk siis vaikimisi on elemendi juurde kuuluvate 
arvuatribuutide maxOccurs ning minOccurs väärtusteks 1. Need aga võib üle 
kirjutada. Lubades kuni kolm eesnime, võib lisada atribuudi maxOccurs="3".


<?xml version="1.0" ?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <xs:element name="inimene">
     <xs:complexType>
        <xs:sequence>
           <xs:element name="eesnimi" type="xs:string" maxOccurs="3"/>
           <xs:element name="perenimi" type="xs:string" />
           <xs:element name="synniaasta" type="xs:integer" />
        </xs:sequence>
     </xs:complexType>
  </xs:element>
</xs:schema>

Nõnda muutub lubatavaks järgmine andmestik, kus inimesel kaks eesnime.

<?xml version="1.0" ?>
<inimene>
  <eesnimi>Juku</eesnimi>
  <eesnimi>Ferdinant</eesnimi>
  <perenimi>Juurikas</perenimi>
  <synniaasta>1989</synniaasta>
</inimene>


Kui element võib kord olla, kord puududa, siis tuleb kirjelduse juurde määrata 
minOccurs="0". Sellistes kohtades on skeemist eriti kasu, sest näitfailis ei 
pruugi vajalikku elementi olla, skeemist aga saab vaadata, mis on lubatud, mis 
mitte. 


<?xml version="1.0" ?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <xs:element name="inimene">
     <xs:complexType>
        <xs:sequence>
           <xs:element name="eesnimi" type="xs:string" />
           <xs:element name="hyydnimi" type="xs:string" minOccurs="0"/>
           <xs:element name="perenimi" type="xs:string" />
           <xs:element name="synniaasta" type="xs:integer" />
        </xs:sequence>
     </xs:complexType>
  </xs:element>
</xs:schema>

Ning siis juurde näitena hüüdnimega andmestik.

<?xml version="1.0" ?>
<inimene>
  <eesnimi>Juku</eesnimi>
  <hyydnimi>juks</hyydnimi>
  <perenimi>Juurikas</perenimi>
  <synniaasta>1989</synniaasta>
</inimene>



Atribuudi kirjeldus tuleb samuti xs:complexType elemendi sisse panna. Mitte aga 
elementide jadasse, vaid eraldi. Atribuutide puhul pole nende järjekord tähtis. 


<?xml version="1.0" ?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <xs:element name="inimene">
     <xs:complexType>
        <xs:sequence>
           <xs:element name="eesnimi" type="xs:string" />
           <xs:element name="perenimi" type="xs:string" />
           <xs:element name="synniaasta" type="xs:integer"/>
        </xs:sequence>
        <xs:attribute name="sugu" type="xs:string" />
     </xs:complexType>
  </xs:element>
</xs:schema>

Atribuudiga element näeb siis välja järgmine.


<?xml version="1.0" ?>
<inimene sugu="m">
  <eesnimi>Juku</eesnimi>
  <perenimi>Juurikas</perenimi>
  <synniaasta>1989</synniaasta>
</inimene>

Ülesandeid

* Loo skeem auto kohta, millel võib lisaks omanikule olla kuni kolm kasutajat.
* Auto kütuse liik tähistatakse atribuudina.

Tüüpide täiendamine

Harilikuks tekstitüübiks on string, täisarvuks integer, murdarvuks decimal ning 
kuupäevaks date. Kusjuures kuupäeva puhul tuleb andmed kirjutada alati kujul 
aasta-kuu-päev. Hiljem rakenduses võib neid kasutajale sobival kujul sättida, 
kuid XMLi standardis on määratud nõnda, et ei tekiks segadusi.


<?xml version="1.0" ?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <xs:element name="inimene">
     <xs:complexType>
        <xs:sequence>
           <xs:element name="eesnimi" type="xs:string" />
           <xs:element name="perenimi" type="xs:string" />
           <xs:element name="synniaeg" type="xs:date"/>
        </xs:sequence>
     </xs:complexType>
  </xs:element>
</xs:schema>


<?xml version="1.0" ?>
<inimene>
  <eesnimi>Juku</eesnimi>
  <perenimi>Juurikas</perenimi>
  <synniaeg>1989-11-05</synniaeg>
</inimene>


Lihtsad andmed saab "kohe ja kohapeal" ära kirjeldada. Kui aga andmestik läheb 
keerulisemaks, siis on võimalik üksikud osad enne gruppidena valmis teha ning 
alles seejärel gruppe omavahel kombineerima hakata. Nii nagu programmikoodi 
kirjutamisel saab enne valmis teha alamprogrammid ning neid siis sobivalt välja 
kutsuma hakata, nii ka skeemi puhul on võimalik kõigepealt defineerida omaette 
tüübid ning neid siis hiljem kasutada. Siinses lihtsas näites on kõigepealt 
defineeritud isikutüüp ning hiljem märgitud, et dokument koosneb ühest, 
isikutüüpi inimesest. 


<?xml version="1.0" ?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <xs:complexType name="isikutyyp">
      <xs:sequence>
         <xs:element name="eesnimi" type="xs:string" />
         <xs:element name="perenimi" type="xs:string" />
         <xs:element name="synniaeg" type="xs:date"/>
      </xs:sequence>
  </xs:complexType>

  <xs:element name="inimene" type="isikutyyp"/>  
</xs:schema>




<?xml version="1.0" ?>
<inimene>
  <eesnimi>Juku</eesnimi>
  <perenimi>Juurikas</perenimi>
  <synniaeg>1989-11-05</synniaeg>
</inimene>


Kui xs:sequence määras, et elemendid peavad olema kindlas järjekorras, siis 
xs:all järjekorda ei määra, küll ütleb aga ikka, et kõik määratud elemendid 
peavad olemas olema. 



<?xml version="1.0" ?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <xs:element name="inimene">
     <xs:complexType>
        <xs:all>
           <xs:element name="eesnimi" type="xs:string" />
           <xs:element name="perenimi" type="xs:string" />
           <xs:element name="synniaasta" type="xs:integer"/>
        </xs:all>
     </xs:complexType>
  </xs:element>
</xs:schema>

Nõnda on lubatud ja järgnev


<?xml version="1.0" ?>
<inimene>
  <perenimi>Juurikas</perenimi>
  <synniaasta>1989</synniaasta>
  <eesnimi>Juku</eesnimi>
</inimene>


Käsklus xs:choice teatab, et määratutest peab olema ainult üks. Ehk siis 
järgnevas näites saab inimese alla panna kooli või asutuse, aga mitte mõlemat. 

<?xml version="1.0" ?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <xs:element name="inimene">
     <xs:complexType>
        <xs:choice>
           <xs:element name="kool" type="xs:string" />
           <xs:element name="asutus" type="xs:string" />
        </xs:choice>
     </xs:complexType>
  </xs:element>
</xs:schema>


<?xml version="1.0" ?>
<inimene>
  <kool>Nurgametsa kool</kool>
</inimene>


Ülesandeid

* Koosta skeem auto andmete hoidmiseks. Märgi auto registreerimise aeg 
kuupäevana. Kontrolli skeemi ja andmete sobivust.
* Luba auto andmed esitada vabas järjestuses.
* Defineeri isikuandmed (eesnimi, perekonnanimi, isikukood) eraldi tüübina. 
Määra nii auto omanik kui kasutajad vastavat tüüpi.
* Valikuna on auto kütuseks kas bensiin, diisel või gaas. Bensiini puhul on 
alamelementideks lubatud vähim ja suurim oktaanarv. 



Tüüpide piirangud

	Terviktüüpe ette võttes on kasutada string, date, integer ja decimal. 
Tüübi juures lubatud terve väärtuste vahemik ei pruugi aga konkreetses kohas 
sugugi mõistlik olla. Mida vähem on lubatud väärtusi, seda rohkem on lootust, et 
näpuveana sisestatud valed andmed läbi ei lähe. Arvu puhul saab näiteks seada 
alam- ja ülempiiri. Kui tüübi ulatust piiratakse, siis tuleb elemendi sisse 
eraldi elemendiks xs:simpleType. Selle sisse xs:restriction, mille base-
atribuudiga määratakse ära, milline tüüp aluseks võetakse. Ja xs:restrictioni 
sisse siis omakorda loetelu täiendavatest piirangutest. 


<?xml version="1.0" ?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <xs:element name="inimene">
     <xs:complexType>
        <xs:sequence>
           <xs:element name="eesnimi" type="xs:string" />
           <xs:element name="perenimi" type="xs:string" />
           <xs:element name="synniaasta">
             <xs:simpleType>
              <xs:restriction base="xs:integer">
                <xs:minInclusive value="1900"/>
                <xs:maxInclusive value="2100"/>
              </xs:restriction>
             </xs:simpleType>
           </xs:element> 
        </xs:sequence>
     </xs:complexType>
  </xs:element>
</xs:schema>



<?xml version="1.0" ?>
<inimene>
  <eesnimi>Juku</eesnimi>
  <perenimi>Juurikas</perenimi>
  <synniaasta>1989</synniaasta>
</inimene>


Sobivad tüübid saab ka eraldi välja kirjutada. Siis ei lähe hilisem andmestiku 
määratlemine liialt pikaks. Järgnevalt siis näide täisarvu kohta, kus seatakse 
alumine ja ülemine piir. Nimetüübis olev regulaaravaldis näitab, et praegusel 
juhul peab nimi algama suurtähega (üks täht vahemikus A-st Z-ni ning edasi tuleb 
üks või rohkem (mida määrab +) väikest tähte. Täpitähed tuleks loetellu eraldi 
lisada, kui neid ka lubada. Joogitüübile on jäetud võimalus olemasolevate 
väärtuste hulgast valida. Lisaks on levinumate piirangute seas veel pikkuse 
jaoks minLength, length ja maxLength.


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

    <xs:simpleType name="aastatyyp">
        <xs:restriction base="xs:integer">
            <xs:minInclusive value="1900"/>
            <xs:maxInclusive value="2100"/>
        </xs:restriction>
    </xs:simpleType>

    <xs:simpleType name="nimetyyp">
        <xs:restriction base="xs:string">
            <xs:pattern value="[A-Z][a-z]+"/>
        </xs:restriction>
    </xs:simpleType>

    <xs:simpleType name="joogityyp">
        <xs:restriction base="xs:string">
            <xs:enumeration value="Coca-Cola"/>
            <xs:enumeration value="Fanta"/>
            <xs:enumeration value="Sprite"/>
        </xs:restriction>
    </xs:simpleType>

    <xs:element name="inimene">
        <xs:complexType>
            <xs:sequence>
                <xs:element name="eesnimi" type="nimetyyp" />
                <xs:element name="perenimi" type="nimetyyp" />
                <xs:element name="synniaasta" type="aastatyyp"/>
                <xs:element name="jook" type="joogityyp"/>
            </xs:sequence>
        </xs:complexType>
    </xs:element>
</xs:schema>


<?xml version="1.0" ?>
<inimene xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:noNamespaceSchemaLocation="tyybid.xsd">
    <eesnimi>Juku</eesnimi>
    <perenimi>Juurikas</perenimi>
    <synniaasta>1989</synniaasta>
    <jook>Coca-Cola</jook>
</inimene>

Ülesandeid

* Koosta piirang Eesti Vabariigi valitsuse määruse aastanumbri kohta. 
Aastanumbri väärtus peab olema vähemalt 1918.
* Koosta piirang parooli jaoks. Pikkus peab olema vähemalt kuus tähte.
* Koosta skeem auto andmete jaoks. Registrimärk peab olema kujul kolm numbrit ja 
kolm tähte, omaniku perekonnanimi peab algama suure tähega ja ülejäänud tähed 
peavad olema väikesed.



Pikemad andmestikud

Elemente võib olla ka hulgem üksteise sees ning seal igaühes omakorda 
alamelemendid. Kui elementide arv pole piiratud, siis selle tähistamiseks sobib 
atribuudi maxOccurs väärtus unbounded.


<?xml version="1.0" ?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
 <xs:element name="inimesed">
  <xs:complexType>
    <xs:sequence>
     <xs:element name="inimene" maxOccurs="unbounded">
        <xs:complexType>
           <xs:sequence>
              <xs:element name="eesnimi" type="xs:string" />
              <xs:element name="perenimi" type="xs:string" />

              <xs:element name="synniaasta" type="xs:integer" />
           </xs:sequence>
        </xs:complexType>
     </xs:element>
    </xs:sequence>
  </xs:complexType>
 </xs:element>
</xs:schema>



<?xml version="1.0"?>
<inimesed>
 <inimene>
   <eesnimi>Juku</eesnimi>
   <perenimi>Juurikas</perenimi>
   <synniaasta>1963</synniaasta>
 </inimene>
 <inimene>

   <eesnimi>Juku</eesnimi>
   <perenimi>Kaalikas</perenimi>
   <synniaasta>1961</synniaasta>
 </inimene>
 <inimene>
   <eesnimi>Kalle</eesnimi>
   <perenimi>Kaalikas</perenimi>

   <synniaasta>1975</synniaasta>
 </inimene>
 <inimene>
   <eesnimi>Mari</eesnimi>
   <perenimi>Maasikas</perenimi>
   <synniaasta>1981</synniaasta>
 </inimene>

 <inimene>
   <eesnimi>Oskar</eesnimi>
   <perenimi>Ohakas</perenimi>
   <synniaasta>1971</synniaasta>
 </inimene>
</inimesed>


Kui sama ülesehitusega elementi soovitakse kasutada mitmel pool, siis on otse 
loomulik, et ta tuleb eraldi ära kirjeldada. Järgnevas näites on nii õpetaja kui 
õpilased isikutüüpi ning pääseb eesnime ja muude isikuandmete mitmekordsest 
kirjeldamisest. 

<?xml version="1.0" ?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
 <xs:complexType name="isikutyyp">
      <xs:sequence>
         <xs:element name="eesnimi" type="xs:string" />
         <xs:element name="perenimi" type="xs:string" />
         <xs:element name="synniaasta" type="xs:integer"/>
      </xs:sequence>
 </xs:complexType>
 <xs:element name="inimesed">

  <xs:complexType>
    <xs:sequence>
     <xs:element name="kirjeldus" type="xs:string" />
     <xs:element name="opetaja" type="isikutyyp" />
     <xs:element name="opilane" type="isikutyyp" maxOccurs="50" />
    </xs:sequence>
  </xs:complexType>
 </xs:element>
</xs:schema>



<?xml version="1.0"?>
<inimesed>
 <kirjeldus>Nurgametsa kooli 7. klass</kirjeldus>
 <opetaja>
   <eesnimi>Juku</eesnimi>
   <perenimi>Juurikas</perenimi>
   <synniaasta>1963</synniaasta>
 </opetaja>

 <opilane>
   <eesnimi>Juku</eesnimi>
   <perenimi>Kaalikas</perenimi>
   <synniaasta>1991</synniaasta>
 </opilane>
 <opilane>
   <eesnimi>Kalle</eesnimi>

   <perenimi>Kaalikas</perenimi>
   <synniaasta>1991</synniaasta>
 </opilane>
 <opilane>
   <eesnimi>Mari</eesnimi>
   <perenimi>Maasikas</perenimi>
   <synniaasta>1992</synniaasta>

 </opilane>
 <opilane>
   <eesnimi>Taavi</eesnimi>
   <perenimi>Ohakas</perenimi>
   <synniaasta>1992</synniaasta>
 </opilane>
</inimesed>


Kui andmestik paisub veel suuremaks ja keerukamaks, siis saab skeemid jagada 
laiali mitmesse faili. Nõnda võib üksikutes failides defineerida kogu dokumendi 
jaoks vajalikud tüübid ning hiljem alles neid vajalikes kohtades pruukida. Siin 
ühes failis kõigepealt defineeritakse tänavatüüp (mis praegusel juhul võib 
koosneda kuni kolmest sõnast) ja indeksitüüp. Nende põhjal ehitatakse kokku 
aadressitüüp. Katseks on defineeritud ka üks aadress, kuid see ei ole 
kohustuslik.



<?xml version="1.0" encoding="utf-8" ?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
    <xs:simpleType name="tänavatüüp">
        <xs:restriction base="xs:string">
            <xs:pattern value="[A-Z][a-z]+( [a-z]+)?( [a-z]+)?"/>
        </xs:restriction>
    </xs:simpleType>
    <xs:simpleType name="indeksitüüp">
        <xs:restriction base="xs:integer">
            <xs:minInclusive value="10000" />
            <xs:maxInclusive value="99999" />
        </xs:restriction>
    </xs:simpleType>
    <xs:complexType name="aadressitüüp">
        <xs:all>
            <xs:element name="indeks" type="indeksitüüp" />
            <xs:element name="aadressivalik">
                <xs:complexType>
                    <xs:choice>
                        <xs:element name="maaaadress">
                            <xs:complexType>
                                <xs:all>
                                    <xs:element name="talu" type="xs:string" />
                                </xs:all>
                            </xs:complexType>
                        </xs:element>
                        <xs:element name="linnaaadress">
                            <xs:complexType>
                                <xs:sequence>
                                    <xs:element name="tänav" type="tänavatüüp" /
>
                                </xs:sequence>
                            </xs:complexType>
                        </xs:element>
                    </xs:choice>
                </xs:complexType>
            </xs:element>
        </xs:all>
    </xs:complexType>
    <xs:element type="aadressitüüp" name="aadress" />
</xs:schema>


Edasi saab teises failis sisse lugeda aadressikontrollifailist tüübikirjeldused 
ning neid oma kirjelduse juures kasutada. Nagu näha, siinse osakonnatüübi juures 
märgitakse, et aadress on aadressitüüpi. See pikk ja keeruline tüüp on aga juba 
eelnevalt defineeritud failis nimega aadressikontroll.xsd, mis xs:include käsuga 
sisse loetakse.


<?xml version="1.0" encoding="utf-8" ?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
    <xs:include schemaLocation="aadressikontroll.xsd"></xs:include>
    <xs:complexType name="osakonnatüüp">
        <xs:sequence>
            <xs:element name="nimetus" type="xs:string" />
            <xs:element name="aadress" type="aadressitüüp" />
        </xs:sequence>
    </xs:complexType>
    <xs:element name="osakond" type="osakonnatüüp"  />
</xs:schema>


Nii ongi kogu süsteem jaotatud kolme faili. XML-andmefail loeb osakonna tüübi 
välja failist osakonnakontroll.xsd. See aga omakorda kasutab veel faili 
aadressikontroll.xsd.


<?xml version="1.0" encoding="utf-8" ?>
<osakond xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:noNamespaceSchemaLocation="osakonnakontroll.xsd">
    <nimetus>Kultuuriosakond</nimetus>
    <aadress>
        <indeks>17655</indeks>
        <aadressivalik>
            <linnaaadress>
                <tänav>Lai</tänav>
            </linnaaadress>
        </aadressivalik>
    </aadress>
</osakond>


Ülesandeid

* Koosta skeem ülevaatuse läbinud autode loetelu kuvamiseks. Iga auto kohta 
registrinumber, mark, valmimisaasta, omanik. Sea tüüpidele mõistlikud piirangud.
* Koosta skeem arvuti võimalike omaduste ja osade kirjeldamiseks. Samuti sea 
elementide väärtustele piirangud, mis võimalust mööda vähendaksid näpuvigu.


Rekursiivsed andmed, sugupuu

Skeemi üheks heaks omaduseks on võimalus defineerida üksteisesse sisenevaid 
samatüübilisi andmeid. Sellist andmestruktuuri nimetatakse rekursiivseks. Tuleb 
ta ette näiteks failisüsteeme, kus kataloogid võivad sisaldada faile ja 
katalooge, viimased taas omakorda faile ja katalooge ning nõnda edasi. Või 
siinses näites, kus inimese elemendi sees on tema lapsed. Ning laste sees on 
jällegi loetelu inimestest, kellel igaühel taas võivad lapsed olla. Sellise 
struktuuri saab kirja panna nõnda, kus sisenevalt korduv tüüp on eraldi 
defineeritud ning ta enese sees sisaldab ka sama tüüpi elemente. Et ehkki laste 
loetelu juures ei ole isikutüübi defineerimine veel lõppenud, võib juba määrata, 
et laste sees on loetelu määramata arvust isikutüüpi inimestest. Siinne skeem 
sobib kirjelduseks sugupuule, mis omaette andmestikuna juba eelpool näidati.


<?xml version="1.0" encoding="utf-8" ?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
    <xs:complexType name="isikutyyp">
        <xs:sequence>
            <xs:element name="eesnimi" type="xs:string" />
            <xs:element name="hyydnimi" type="xs:string" minOccurs="0" />
            <xs:element name="perekonnanimi" type="xs:string" />
            <xs:element name="synniaasta" type="xs:int" />
            <xs:element name="lapsed" minOccurs="0">
                <xs:complexType>
                    <xs:sequence>
                        <xs:element name="inimene" 
                           type="isikutyyp" maxOccurs="unbounded" />
                    </xs:sequence>
                </xs:complexType>
            </xs:element>
        </xs:sequence>
        <xs:attribute name="sugu" type="xs:string"  />
    </xs:complexType>
    <xs:element name="inimene" type="isikutyyp" />
</xs:schema>


Ülesandeid

* Koosta rekursiivse andmestruktuuri skeem kirjeldamaks kataloogides asuvaid 
faile ja alamkatalooge. Testi skeemi sobivust tegelike andmetega.
* Koosta skeem suurfirma organisatsiooni kirjeldamiseks. Kus firma jaguneb 
osakondadeks, igal neist võivad olla aga omakorda alamosakonnad. Osakonnas on 
töötajad, neil igaühel ametinimetus ja palk.