1 / 55

XMLSchema

XMLSchema. XMLSchema. Hvorfor ikke bare bruke DTD? 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

garima
Télécharger la présentation

XMLSchema

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. XMLSchema

  2. XMLSchema • Hvorfor ikke bare bruke DTD? • 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…

  3. 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.

  4. 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.

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

  6. XMLSchema • Innledende eksempler: 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:

  7. XMLSchema <?xml version="1.0"?> <xs:schemaxmlns: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>

  8. XMLSchema • I eksempelet ovenfor kan en se at notatinneholder kompleksetyper, 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>

  9. 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).

  10. 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.

  11. XMLSchema • <xs:schema> elementet er rot elementet i et XMLSchema. • En schema deklarasjon ser ofte slik ut: <xs:schemaxmlns: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:schemaxmlns: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…

  12. 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.

  13. 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.

  14. 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.

  15. 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.

  16. 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 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 Innebygde Datatyper INF = infinity NAN = not-a-number

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

  18. 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>

  19. 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” />

  20. 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.

  21. <?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> <quantity>1</quantity> <USPrice>39.98</USPrice> <shipDate>1999-05-21</shipDate> </item> </items> </purchaseOrder> Dette eksempelet viser En Purchase Order, po.xml

  22. <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: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> <xsd:complexType name="Items"> <xsd:sequence> <xsd:element name="item" minOccurs="0" maxOccurs="unbounded"> <xsd:complexType> <xsd:sequence> <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> </xsd:element> </xsd:sequence> </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:restriction> </xsd:simpleType> </xsd:schema> Her er XMLSchema for xml instans dokumentet po.xml

  23. 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.

  24. 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>

  25. 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.

  26. 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"/>

  27. 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

  28. 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>

  29. 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>

  30. 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>

  31. 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.

  32. Restriksjoner

  33. <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)

  34. 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

  35. 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 <element name=”ansatt”> <complexType > <sequence> <element name=”fornavn” type=”string”> <element name=”etternavn” type=”string”> </sequence> </complexType> </element> <ansatt> <fornavn>John</fornavn > <etternavn>Smith</etternavn> </ansatt>

  36. 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>

  37. 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>

  38. 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”>

  39. 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>

  40. 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

  41. 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”.

  42. 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.

  43. 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.

  44. 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

  45. 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>

  46. 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>

  47. 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:sequence> <xsd:element name="ISBN" type="xsd:string"/> <xsd:element name="Publisher" type="xsd:string"/> </xsd:sequence> </xsd:extension> </xsd:complexContent> </xsd:complexType> <xsd:element name="Book" type="BookPublication"/> Element deklarasjonen

  48. 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:simpleContent> <extension base="Y"> … </extension> </xsd:simpleContent> </xsd:complexType> <xsd:complexType name="…"> <xsd:complexContent> <extension base="X"> … </extension> </xsd:complexContent> </xsd:complexType> versus Y må være en simpleType X må være en complexType

  49. 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

  50. 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>

More Related