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.