XMLSchema

XMLSchema Hvorfor ikke bare bruke DTD? Uviklernes egne forklaringer… Fordi XMLSchema er enklere Spesifiserer element data typer Forenkler design Bedre støtte for navnerom Tillater gjenbruk av elementer via arv. De er utvidbare. DTD syntaks forholder seg til SGML syntaks XMLSchema er skrevet i XML Uviklernes egne forklaringer…

XMLSchema Hva er så et XMLSchema: definerer elementer som kan forekomme i et dokument definerer attributter som kan forekomme i et dokument definerer hvilke elementer som er barn definerer rekkefølgen på elementene som er barn definerer antall barn definerer hvorvidt et element er tomt eller kan inneholde tekst. definerer data typer for elementer og attributter definerer standard og faste verdier for elementer and attributter.

XMLSchema Med støtte for datatyper: Er det enklere å beskrive tillatt dokument innhold. Er det enklere å validere riktigheten av data Er det enklere å jobbe med data fra en database. Blir det enklere å definere restriksjoner på data. Blir det enklere å definere data formater. Blir det enklere å konvertere data mellom forskjellige datatyper.

XMLSchema XMLSchema er en W3C anbefaling og foreligger nå som en stabil spesifikasjon. XMLSchema var først et Microsoft forslag.

XMLSchema Innledende eksempler: Vi har sett DTD’en til dette xml dok. 1.<?xml version="1.0" encoding="ISO-8859-1"?> 2.<notat> 3.<til>Tove</til> 4.<fra>Janni</fra> 5.<tittel>Huskelapp</tittel> 6.<melding>Ikke glem avtalen til helgen</melding> 7.</notat> Vi har sett DTD’en til dette xml dok. Her kommer XMLSchema til samme dokument:

XMLSchema <?xml version="1.0"?> <xs:schema xmlns:xs=http://www.w3.org/2001/XMLSchema xmlns="http://www.osir.hihm.no/sfi/kurs/3ip80" targetNamespace="http://www.osir.hihm.no/sfi/kurs/3ip80"> <xs:element name="notat"> <xs:complexType> <xs:sequence> <xs:element name="til" type="xs:string"/> <xs:element name=”fra" type="xs:string"/> <xs:element name=”tittel" type="xs:string"/> <xs:element name=”melding" type="xs:string"/> </xs:sequence> </xs:complexType> </xs:element> </xs:schema>

XMLSchema I eksempelet ovenfor kan en se at notat inneholder komplekse typer, fordi den inneholder flere elementer. De andre elementene inneholder simple typer fordi de ikke inneholder andre elementer, men kun tekst eller tall Referanse til et XMLSchema: <?xml version="1.0" encoding="ISO-8859-1"?> <notat xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="notat.xsd"> <til>Tove</til> <fra>Janni</fra> <tittel>Huskelapp</tittel> <melding>Ikke glem avtalen til helgen</melding> </notat>

XMLSchema navnerom Et schema kan bli sett på som en samling (vokabular) av type definisjoner og element deklarasjoner hvis navn tilhører et bestemt navnerom også kalt ”Target Namespace”. ”Target namespace” vil hjelpe til å skille mellom ulike vokabularer, som for eksempel deklarasjonen av et element innen schema vokabularet eller et matte vokabular (mathML).

XMLSchema navnerom For å validere et instans dokument (xml) må vi identifisere hvilke element og attributt deklarasjoner og type definisjoner som skal sjekkes mot hvilke elementer og attributter i instans dokumentet. Target Namespace spiller en viktig rolle også i denne identifiserings prosessen.

XMLSchema <xs:schema> elementet er rot elementet i et XMLSchema. En schema deklarasjon ser ofte slik ut: <xs:schema xmlns:xs=http://www.w3.org/2001/XMLSchema targetNamespace =http://www.osir.hihm.no/sfi/kurs/3ip80 xmlns="http://www.osir.hihm.no/sfi/kurs/3ip80"> Følgende linje: xs:schema xmlns:xs=http://www.w3.org/2001/XMLSchema Indikerer at elementer og datatyper (schema, element, complexType, sequence, string, boolean, etc.) kommer fra http://www.w3.org/2001/XMLSchema navnerom, og at elementene og datatypene som kommer fra http://www.w3.org/2001/XMLSchema navnerommet skal ha :xs som prefiks og valideres mot dette navnerommet. (denne url har til hensikt å beskrive navnerommet.) Det blir et schema for et schema…

XMLSchema xmlns=http://www.osir.hihm.no/sfi/kurs/3ip80 Standard navnerom targetNamespace=http://www.osir.hihm.no/sfi/kurs/3ip80 Indikerer at et xml dokument, hvor elementene er deklarert til å tilhøre navnerommet til schemaet, skal valideres mot XMLScema.

XMLSchema Referanse til et XMLSchema: <notat xmlns=” http://www.osir.hihm.no/sfi/kurs/3ip80” xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.osir.hihm.no/sfi/kurs/3ip80 notat.xsd"> Når XMLSchema instans navnerommet er tilgjengelig kan man bruke schemaLocation for å spesifisere schema fila. Schemalocation tar to paramentre; standard navnerom + schema fil.

XMLSchema Det er to hovedtyper av elementer Elementer med simpelt innhold Derav simple typer Elementer med komplekst innhold Derav komplekse typer Det er en grunnleggende forskjell mellom komplekse typer, som tillater element innhold og attributter og simple typer som ikke kan ha element innhold og ha attributter.

Enkle Typer Enkle typer kan være innebygde Datatyper som finnes i XMLSchema eller utledede typer fra de innebygde datatypene. Elementer og attributter kan ha enkle typer.

Innebygde Datatyper Primitive Datatyper string boolean decimal float double duration dateTime time date gYearMonth gYear gMonthDay "Hello World" {true, false, 1, 0} 7.08 12.56E3, 12, 12560, 0, -0, INF, -INF, NAN P1Y2M3DT10H30M12.3S format: CCYY-MM-DDThh:mm:ss format: hh:mm:ss.sss format: CCYY-MM-DD format: CCYY-MM format: CCYY format: --MM-DD INF = infinity NAN = not-a-number

Innebygde Datatyper forts. Primitive Datatyper gDay gMonth hexBinary base64Binary anyURI QName format: ---DD format: --MM-- Hexadecimal streng base64 streng http://www.xfront.com Navnerom kvalifisert navn

XMLSchema – Element deklarasjon (Enkle typer) Dette er en deklarasjon av et element med enkelt innhold. <xs:element name="til" type="xs:string"/> Enkle elementer inneholder kun ”tekst” Enkle elementer inneholder ikke andre elementer eller attributter. Deklarasjonen består av element navn og en datatype: <xs:element name=”etternavn" type="xs:string"/> <etternavn>Olsen</etternavn> <xs:element name=”alder" type="xs:integer"/> <alder>35</alder> <xs:element name=”fodt" type="xs:date"/> <fodt>1968</fodt>

XMLSchema – deklarasjon av attributter (enkle typer) Deklarering av attributter: <xs:attribute name="xxx" type="yyy"/> Angir navn på attributtet og datatypen F.eks: <etternavn spraak=”NO">Olsen</etternavn> <xs:attribute name=”spraak" type="xs:string"/> Standard verdier: <xs:attribute name=”spraak" type="xs:string” default=”NO” /> Faste verdier: <xs:attribute name=”spraak" type="xs:string” fixed=”NO” /> Påkrevet: <xs:attribute name=”spraak" type="xs:string” use=”required” /> Valgfritt: <xs:attribute name=”spraak" type="xs:string” use=”optional” />

XMLSchema – deklarasjon av attributter (enkle typer) Attributter kan altså også inneholde enkle typer som for eksempel string, decimal osv.. Men kan også inneholde typer som er utledet.

Dette eksempelet viser En Purchase Order, po.xml <?xml version="1.0"?> <purchaseOrder orderDate="1999-10-20"> <shipTo country="US"> <name>Alice Smith</name> <street>123 Maple Street</street> <city>Mill Valley</city> <state>CA</state> <zip>90952</zip> </shipTo> <billTo country="US"> <name>Robert Smith</name> <street>8 Oak Avenue</street> <city>Old Town</city> <state>PA</state> <zip>95819</zip> </billTo> <comment>Hurry, my lawn is going wild!</comment> <items> <item partNum="872-AA"> <productName>Lawnmower</productName> <quantity>1</quantity> <USPrice>148.95</USPrice> <comment>Confirm this is electric</comment> </item> <item partNum="926-AA"> <productName>Baby Monitor</productName> <USPrice>39.98</USPrice> <shipDate>1999-05-21</shipDate> </items> </purchaseOrder> Dette eksempelet viser En Purchase Order, po.xml

Her er XMLSchema for xml instans dokumentet po.xml <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"> <xsd:element name="purchaseOrder" type="PurchaseOrderType"/> <xsd:element name="comment" type="xsd:string"/> <xsd:complexType name="PurchaseOrderType"> <xsd:sequence> <xsd:element name="shipTo" type="USAddress"/> <xsd:element name="billTo" type="USAddress"/> <xsd:element ref="comment" minOccurs="0"/> <xsd:element name="items" type="Items"/> </xsd:sequence> <xsd:attribute name="orderDate" type="xsd:date"/> </xsd:complexType> <xsd:complexType name="USAddress"> <xsd:element name="name" type="xsd:string"/> <xsd:element name="street" type="xsd:string"/> <xsd:element name="city" type="xsd:string"/> <xsd:element name="state" type="xsd:string"/> <xsd:element name="zip" type="xsd:decimal"/> <xsd:attribute name="country" type="xsd:NMTOKEN" fixed="US"/> <xsd:complexType name="Items"> <xsd:sequence> <xsd:element name="item" minOccurs="0" maxOccurs="unbounded"> <xsd:complexType> <xsd:element name="productName" type="xsd:string"/> <xsd:element name="quantity"> <xsd:simpleType> <xsd:restriction base="xsd:positiveInteger"> <xsd:maxExclusive value="100"/> </xsd:restriction> </xsd:simpleType> </xsd:element> <xsd:element name="USPrice" type="xsd:decimal"/> <xsd:element ref="comment" minOccurs="0"/> <xsd:element name="shipDate" type="xsd:date" minOccurs="0"/> </xsd:sequence> <xsd:attribute name="partNum" type="SKU" use="required"/> </xsd:complexType> <!-- Stock Keeping Unit, a code for identifying products --> <xsd:simpleType name="SKU"> <xsd:restriction base="xsd:string"> <xsd:pattern value="\d{3}-[A-Z]{2}"/> </xsd:schema> Her er XMLSchema for xml instans dokumentet po.xml

Nye enkle typer Nye enkle typer blir definert ved å utlede dem fra eksisterende innebygde typer. Vi kan for eksempel lage en ny type ved å begrense en allerede eksisterende enkel type: Lager en ny type MinInteger som har en rekkevidde på 1000 – 9999. Den nye typen baseres på den innebygde enkle typen integer som jo har en mye større rekkevidde men som vi nå skal utlede en ny type av for å begrense rekkevidden.

Nye enkle typer Definerer den nye typen med simpleType <xsd:simpleType name=”MinInteger"> <xsd:restriction base="xsd:integer"> <xsd:minInclusive value="10000"/> <xsd:maxInclusive value="99999"/> </xsd:restriction> </xsd:simpleType>

Nye enkle typer forts. Et annet eksempel fra po.xsd Utleder en ny type fra den innebygde enkle typen string. Begrenser verdien med et regulært uttrykk innenfor en <pattern> som alltid inneholder regulære uttrykk. Uttrykket ser slik ut: "\d{3}-[A-Z]{2}" Og leses tre tall (digits) etterfulgt av bindestrek etterfulgt av 2 store bokstaver.

Nye enkle typer forts. Definerer den nye typen SKU <xsd:simpleType name="SKU"> <xsd:restriction base="xsd:string"> <xsd:pattern value="\d{3}-[A-Z]{2}"/> </xsd:restriction> </xsd:simpleType Typen SKU brukes her: <xsd:attribute name="partNum" type="SKU" use="required"/>

XMLSchema – simpleTypes (enkle typer) <xs:simpleType> definisjoner brukes altså for å lage nye typer når det skal settes begrensninger på verdier. Noen flere eksempler: Alder kan ikke være under 0 og høyere enn 100. <xs:element name=”alder"> <xs:simpleType> <xs:restriction base="xs:integer"> <xs:minInclusive value="0"/> <xs:maxInclusive value="100"/> </xs:restriction> </xs:simpleType> </xs:element> base attributtet er obligatorisk og spesifiserer den innebygde datatypen xs:minInclusive – mindre eller lik xs:maxInclusive – større eller lik

XMLSchema – simpleTypes (enkle typer) Eks: Begrense tillatte verdier: <xs:element name=”bil"> <xs:simpleType> <xs:restriction base="xs:string"> <xs:enumeration value="Audi"/> <xs:enumeration value="Golf"/> <xs:enumeration value="BMW"/> </xs:restriction> </xs:simpleType> </xs:element>

XMLSchema – simpleTypes (enkle typer) Eks: Begrense tillatte verdier ved å definere en serie: <xs:element name="initialer"> <xs:simpleType> <xs:restriction base="xs:string"> <xs:pattern value="[A-Z][A-Z][A-Z]"/> </xs:restriction> </xs:simpleType> </xs:element>

XMLSchema – simpleTypes (enkle typer) Eks: Begrensning på lengde: <xs:element name="passord"> <xs:simpleType> <xs:restriction base="xs:string"> <xs:minLength value="5"/> <xs:maxLength value="8"/> </xs:restriction> </xs:simpleType> </xs:element>

XMLSchema – simpleTypes (enkle typer) En annen variant… <xs:element name=”bil“ type=“biltype” /> <xs:simpleType name=“biltype”> <xs:restriction base="xs:string"> <xs:enumeration value="Audi"/> <xs:enumeration value="Golf"/> <xs:enumeration value="BMW"/> </xs:restriction> </xs:simpleType> Her kan biltype brukes på andre elementer fordi den ikke er en del av bil elementet.

Restriksjoner Constraint Description enumeration Defines a list of acceptable values fractionDigits Specifies the maximum number of decimal places allowed. Must be equal to or greater than zero length Specifies the exact number of characters or list items allowed. Must be equal to or greater than zero maxExclusive Specifies the upper bounds for numeric values (the value must be less than this value) maxInclusive Specifies the upper bounds for numeric values (the value must be less than or equal to this value) maxLength Specifies the maximum number of characters or list items allowed. Must be equal to or greater than zero minExclusive Specifies the lower bounds for numeric values (the value must be greater than this value) minInclusive Specifies the lower bounds for numeric values (the value must be greater than or equal to this value) minLength Specifies the minimum number of characters or list items allowed. Must be equal to or greater than zero pattern Defines the exact sequence of characters that are acceptable totalDigits Specifies the exact number of digits allowed. Must be greater than zero whiteSpace Specifies how white space (line feeds, tabs, spaces, and carriage returns) are handled

<xs:complexType> eller <xs:simpleType>? Når bruker du complexType elementet og når bruker du simpleType elementet? complexType når du ønsker å definere barn elementer og /eller attributter til et element. simpleType når du ønsker å lage en ny type som er en begrensning av en innebygget type (string, date, gYear, etc)

XMLSchema – komplekse typer Det er fire typer komplekse elementer Tomme elementer Elementer som bare inneholder andre elementer Elementer som bare inneholder tekst Elementer som både inneholder andre elementer og tekst

XMLSchema - komplekse typer Komplekse elementer kan inneholde både tekst flere elementer og attributter. Dette er f.eks et komplekst element som er tomt! <produkt pid="1345"/> Eller dette: som består av andre elementer <ansatt> <fornavn>John</fornavn > <etternavn>Smith</etternavn> </ansatt> <element name=”ansatt”> <complexType > <sequence> <element name=”fornavn” type=”string”> <element name=”etternavn” type=”string”> </sequence> </complexType> </element>

XMLSchema – komplekse typer Dette er en deklarasjon av et komplekst element <xs:element name="notat"> Vi vet at elementet er komplekst fordi det har element innhold. Den komplekse typen er definert som anonym Dvs. at den ikke inneholder et ”type” attributt <xs:complexType> <xs:element name="notat"> <xs:complexType> <xs:sequence> <xs:element name="til" type="xs:string"/> <xs:element name=”fra" type="xs:string"/> <xs:element name=”tittel" type="xs:string"/> <xs:element name=”melding" type="xs:string"/> </xs:sequence> </xs:complexType> </xs:element>

XMLSchema – complexTypes (komplekse typer) Definisjon av complekse typer gjøres ved bruk av <complexType> elementet. Vanligvis vil <complexType> inneholde element deklarasjoner, attributt deklarasjoner og element referanser. <xs:element name="notat"> <xs:complexType> <xs:sequence> <xs:element name="til" type="xs:string"/> <xs:element name=”fra" type="xs:string"/> <xs:element name=”tittel" type="xs:string"/> <xs:element name=”melding" type="xs:string"/> </xs:sequence> </xs:complexType> </xs:element>

Nye komplekse typer For å definere nye komplekse typer bruker vi ”type” attributtet og gir den komplekse typen et navn som vi senere kan referere til når vi ønsker å bruke den nye typen. <xs:complexType type=” USAddress”>

Nye komplekse typer forts. Definerer den nye komplekse typen ”USAddress” og inneholder deklarasjoner som involverer kun enkle typer. (string og decimal) <xsd:complexType name="USAddress" > <xsd:sequence> <xsd:element name="name" type="xsd:string"/> <xsd:element name="street" type="xsd:string"/> <xsd:element name="city" type="xsd:string"/> <xsd:element name="state" type="xsd:string"/> <xsd:element name="zip" type="xsd:decimal"/> </xsd:sequence> <xsd:attribute name="country" type="xsd:NMTOKEN" fixed="US"/> </xsd:complexType>

Nye komplekse typer forts. Definisjonen av typen "PurchaseOrderType" inneholder element deklarasjoner som involverer komplekse typer, som for eksempel ”USAddress”. <xsd:complexType name="PurchaseOrderType"> <xsd:sequence> <xsd:element name="shipTo" type="USAddress"/> <xsd:element name="billTo" type="USAddress"/> <xsd:element ref="comment" minOccurs="0"/> <xsd:element name="items" type="Items"/> </xsd:sequence> <xsd:attribute name="orderDate" type="xsd:date"/> </xsd:complexType> -- Kompleks type -- Kompleks type -- Referanse til et globalt element -- Kompleks type -- Enkel type

Nye komplekse typer forts. "PurchaseOrderType" inneholder element deklarasjonene: <xsd:element name="shipTo" type="USAddress"/> <xsd:element name="billTo" type="USAddress"/> <xsd:element ref="comment" minOccurs="0"/> <xsd:element name="items" type="Items"/> Og attributt deklarasjonen <xsd:attribute name="orderDate" type="xsd:date"/> Alle elementene må forekomme i denne rekkefølgen som er spesifisert. Vi kan bl.a. lese ut av denne definisjonen at elementet ”shipto” består av (name, street, city, state og zip) subelementer som er deklarert i ”USAddress”.

Element innhold Komplekse typer for elementer med tomt innhold: <produkt prodid="1345" /> <xs:element name=”produkt"> <xs:complexType> <xs:complexContent> <xs:restriction base="xs:anyType"> <xs:attribute name="prodid" type="xs:positiveInteger"/> </xs:restriction> </xs:complexContent> </xs:complexType> </xs:element> complexContent modellen signaliserer at vi ønsker å begrense eller utvide innholdsmodellen av en kompleks type. Indikerer at innholdsmodellen til et element av kompleks type bare inneholder fra 0 til mange elementer. Her introduseres ingen elementer. anyType brukes nettopp for å si at typen kan være en kompleks eller enkel type.

Element innhold forts. Komplekse typer for elementer med enkelt innhold (husk begrep fra xml terminologi: simplelt innhold). Her blir spørsmålet: hvordan definere en kompleks type som er basert på en enkel type. <shoesize country="france">35</shoesize> Deklarerer elementet shoesize som en start… <xs:element name="shoesize” type=”xs:integer”> Hvordan legger vi til et attributt her…? Enkle typer kan jo ikke inneholde attributter. integer er en enkel type… Vi må derfor definere en kompleks type for å kunne deklarere attributtet. Innholdet til elementet shoesize er jo en enkel type (integer) Spørsmålet er igjen; hvordan definere en kompleks type som er basert på den enkle typen integer. Svaret blir å utlede en ny kompleks type fra den enkle typen integer.

Element innhold forts. <xs:element name="shoesize"> <xs:complexType> <xs:simpleContent> <xs:extension base="xs:integer"> <xs:attribute name="country" type="xs:string" /> </xs:extension> </xs:simpleContent> </xs:complexType> </xs:element> Vi bruker complexType for å definere en ny anonym type For å indikere at innholdsmodellen til den nye typen kun inneholder tegn og ikke har element innhold bruker vi simpleContent. Så utledes den nye typen ved å utvide den enkle typen integer Utvidelsen består av å legge til et attributt ved å bruke vanlig attributt deklarasjon

XMLSchema – complexTypes (komplekse typer) Komplekse typer med mixed innhold <letter> Dear Mr.<name>John Smith</name> Your order <orderid>1032</orderid> will be shipped on <shipdate>2001-07-13</shipdate> </letter> <xs:element name="letter"> <xs:complexType mixed="true"> <xs:sequence> <xs:element name="name" type="xs:string"/> <xs:element name="orderid" type="xs:positiveInteger"/> <xs:element name="shipdate" type="xs:date"/> </xs:sequence> </xs:complexType> </xs:element>

XMLSchema – complexTypes (komplekse typer) For at tekst kan forekomme mellom barn elementene må mixed være satt til true. Vi kan også gi complexType et navn og la ”letter” elementet få et attributt som ref. til den komplekse typen. Slik kan flere elementer referere til samme complexType. <xs:element name="letter" type="lettertype"/> <xs:complexType name="lettertype" mixed="true"> <xs:sequence> <xs:element name="name" type="xs:string"/> <xs:element name="orderid" type="xs:positiveInteger"/> <xs:element name="shipdate" type="xs:date"/> </xs:sequence> </xs:complexType>

Et annet eksempel med complexContent Element som inneholder en kompleks type som er en utvidelse av en annen kompleks type <xsd:complexType name="Publication"> <xsd:sequence> <xsd:element name="Title" type="xsd:string" maxOccurs="unbounded"/> <xsd:element name="Author" type="xsd:string" maxOccurs="unbounded"/> <xsd:element name="Date" type="xsd:gYear"/> </xsd:sequence> </xsd:complexType> <xsd:complexType name="BookPublication"> <xsd:complexContent> <xsd:extension base="Publication" > <xsd:element name="ISBN" type="xsd:string"/> <xsd:element name="Publisher" type="xsd:string"/> </xsd:extension> </xsd:complexContent> <xsd:element name="Book" type="BookPublication"/> Element deklarasjonen

complexContent versus simpleContent Med complexContent utvider du eller begrenser en kompleks type -- <complexType> Med simpleContent utvider du eller begrenser en enkel type -- <simpleType> <xsd:complexType name="…"> <xsd:complexContent> <extension base="X"> … </extension> </xsd:complexContent> </xsd:complexType> <xsd:complexType name="…"> <xsd:simpleContent> <extension base="Y"> … </extension> </xsd:simpleContent> </xsd:complexType> versus X må være en complexType Y må være en simpleType

XMLSchema – complexTypes. Indikatorer Vi kan kontrollere hvordan elementer brukes i dokumenter, med indikatorer. Det er sju typer indikatorer: Som gir orden: All Choice Sequence Som angir ant. Forekomster: minOccurs maxOccurs Som grupperer: Group name Attribute name

XMLSchema – complexTypes Indikatorer All: Barn nodene kan opptre i vilkårlig rekkefølge. Hvert barn element kan kun forekomme 1 gang. Choice: kun et av elementene innenfor en choice deklarasjon kan forekomme innenfor den ytre elementkontaineren. Sequence: spesifiserer at elementene må være i en bestemt rekkefølge <xs:element name="person"> <xs:complexType> <xs:sequence> <xs:element name="firstname" type="xs:string"/> <xs:element name="lastname" type="xs:string"/> </xs:sequence> </xs:complexType> </xs:element>

XMLSchema – complexTypes Indikatorer All <xsd:complexType name="PurchaseOrderType"> <xsd:all> <xsd:element name="shipTo" type="USAddress"/> <xsd:element name="billTo" type="USAddress"/> <xsd:element ref="comment" minOccurs="0"/> <xsd:element name="items" type="Items"/> </xsd:all> <xsd:attribute name="orderDate" type="xsd:date"/> </xsd:complexType>

XMLSchema – complexTypes Indikatorer Choice <xsd:element name=“transport"> <xsd:complexType> <xsd:choice> <xsd:element name=“tog” type="xsd:string"/> <xsd:element name=“fly” type="xsd:string"/> <xsd:element name=“bil” type="xsd:string"/> </xsd:choice> </xsd:complexType> </xsd:element> </xsd:schema>

XMLSchema – complexTypes Indikatorer maxOccur: spesifiserer hvor mange ganger et element kan forekomme. minOccur: spesifiserer minimum antall ganger et element kan forekomme. <xs:element name="person"> <xs:complexType> <xs:sequence> <xs:element name="full_name" type="xs:string"/> <xs:element name="child_name" type="xs:string" maxOccurs="10" minOccurs="0"/> </xs:sequence> </xs:complexType> </xs:element>

XMLSchema og datatyper. Eks: <xs:element name="start" type="xs:date"/> <start>2002-09-24</start> <xs:element name="start" type="xs:time"/> <start>09:30:10.5</start> <xs:element name="startdato" type="xs:dateTime"/> <startdato>2002-05-30T09:30:10.5</startdato> <xs:element name=”kunde" type="xs:string"/> <customer> John Smith </customer> <xs:attribute name="disabled" type="xs:boolean"/> <prize disabled="true">999</prize>

Oppsummering Alle XML schema består av komponenter, hovedsakelig elementer, attributter og type definisjoner. XMLSchema er overlegen i detalj i forhold til DTD