Validació de Documents XML amb XSD

Llenguatge de marques i sistemes de gestió d'informació

Validació amb XML Schema Definition

Language

Xavier Sala PujolarIES Cendrassos

UF 1: Programació amb XMLPart 3c

Administració de Sistemes Informàtics i Xarxes

XML Schemas

Les limitacions dels DTD van fer sorgir un nou sistema per definir llenguatges XML

XML Schemas Definition Language (XSD)


XSD

● És un estàndard del W3C● La versió actual és la 1.1 però es pot veure si hi

ha versions noves en la pàgina:

http://www.w3c.org/XML/Schema

http://www.w3c.org/XML/Schema


XSD

Els DTD són un llenguatge nou, amb noves regles, etc...

Els XSD són documents XML!


XSD

En DTD no es pot control·lar el contingut de les etiquetes

Els XSD inclouen tipus de dades per control·lar el

contingut

Pemeten definir restriccions


XSD

En DTD no es poden validar documents que estiguin formats per

dos llenguatges diferents

Els XSD inclouen suport per fer servir espais de noms


Validació● La majoria dels validadors poden validar els

XML Schemas

● Per exemple amb xmllint ho podem fer:

$ xmllint --noout --schema ./exercici.xsd exercici.xmlexercici.xml validates

S'hi afegeix la opció “schema” i el fitxer

d'esquema


XMS Schema

Associar l'esquema a un fitxer XML


Associar un XSD● Tots els XML validats per XSD tindran definit

l'espai de noms de XSD en l'arrel:

<?xml version=”1.0” encoding=”UTF-8” ?><lliga xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" ... > ...</lliga>


Associar un XSD a un XML● I el lloc on es troba el fitxer de definició

● El lloc on està el fitxer pot ser una URL:

<?xml version=”1.0” encoding=”UTF-8” ?><lliga xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation=”fitxer.xsd”> <equip>FC Barcelona</equip> <equip>Real Madrid</equip></lliga>

xsi:SchemaLocation=”http://www.lloc.com/fitxer.xsd”

http://www.w3.org/2001/XMLSchema-instance


XMS Schema

Definir un fitxer d'esquema

http://www.w3.org/2001/XMLSchema-instance


Definir un fitxer d'esquema● L'arrel del XSD és l'etiqueta <schema> on

sempre s'hi definirà l'espai de noms 'xmlns'

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

</xs:schema>

El valor xs pot ser qualsevol cosa: xsi, patata, ...


Notes● Es poden fer servir els comentaris XML però

també defineix etiquetes per posar comentaris

<xs:annotation> <xs:documentation> Aquest esquema XML està pensat per fer Proves. Però aquí hi podria posar qualsevol Cosa </xs:documentation></xs:annotation>

Poden anar a qualsevol lloc del document


XML Schemas● En XSD definim dos tipus d'etiquetes:

Etiquetes de tipus simple

Etiquetes de tipus complexe

Només contenen dades

No contenen res, altres etiquetes, o

tenen atributs


XML Schema

Tipus simples

http://www.w3.org/2001/XMLSchema


Tipus simple● Una etiqueta de tipus simple és la que només

conté dades.

<nom>Xavier</nom><any>2010</any>

<cotxe marca=”Opel”> Corsa</cotxe>

<data> <any>2010</any></data>

Simples

Complexes

Aquesta és simple!!


Tipus simples● L'etiqueta que serveix per definir etiquetes és

<element>

<xs:element name=”nom” type=”xs:string”/>

Definició Element

Nom de l'etiquetaEn aquest exemple

és nom Tipus de dades que contindrà

l'etiqueta


Tipus simples● Amb els tipus de dades podem controlar quin

és el contingut de les etiquetes.

<xs:element name=”nom” type=”xs:string” /><xs:element name=”any” type=”xs:integer”/>

<nom>Xavier</nom> <any>2010</any>


Tipus de dades● Els tipus bàsics els podem trobar a

http://www.w3.org/TR/xmlschema-0/#CreatDt :

Tipus Explicació

xs:string Contindrà una cadena de caràcters

xs:decimal Contindrà un número

xs:boolean Contindrà 'true' o 'false' o (1 o 0)

xs:date Contindrà una data (AAAA-MM-DD)

xs:anyURI Contindrà una referència a un lloc (URL, disc...)

xs:base64binary Es fa servir per representar dades binàries


Tipus de dades● Hi solen haver variants de cada tipus per

adaptar-se millor al que cal:– Text: string, normalizedString, token, Name,

NMTOKEN, ...

– Números: integer, positiveInteger, negativeInteger, nonNegativeInteger, nonPositiveInteger, long, unsignedLong, int, unsignedInt, byte, unsignedByte, decimal, float, double

– Dates: duration, dateTime, date, time, gYear, gMonth, gYearMonth, gDay, gMonthDay,


Tipus de dades: exemples

<xs:element name=”dia” type=”xs:date” />

<dia>2010-09-15</dia>

<xs:element name=”mes” type=”xs:gMonth” /> <mes>--3</mes>

<xs:element name=”altura” type=”xs:integer” />

<altura>220</altura>

<xs:element name=”nom” type=”xs:string” />

<nom>Xavier</nom>

<xs:element name=”altura” type=”xs:float” />

<altura>1.7E2</altura>

<xs:element name=”lloc” type=”xs:anyURI” />

<lloc>http://www.iescendrassos.net</lloc>


Altres atributs● Els elements simples poden ser alterats perquè

funcionin de determinades formes

Atribut

Valors fixes fixed

Valors per defecte default

Vegades que pot sortir l'etiqueta MaxOccurs, MinOccurs

Restringir valors restriction

Llistes de valors

Unions

http://www.w3.org/TR/xmlschema-0/#CreatDt


Valors fixes● Podem definir que un element té un valor fixe

definint-lo amb l'etiqueta 'fixed'

● Això ens permet definir:

● Però no:

<xs:element name=”cap” type=”xs:string” fixed=”Manel” />

<cap>Manel</cap><cap></cap>

<cap>Xavier</cap>


Valors predefinits● Podem definir que un element té un valor

predefinit definint-lo amb l'etiqueta 'default'

● Això ens permet definir:

<xs:element name=”cap” type=”xs:string” default=”Manel” />

<cap>Manel</cap><cap></cap><cap>Xavier</cap>

http://www.iescendrassos.net/


Ocurrències● Es poden definir les vegades que ha de sortir

un element com a mínim

– Si té un valor de 0 és que no té mínim

● O com a màxim:

– 'unbounded' implica un número indeterminat de vegades

<xs:element name=”cap” type=”xs:string” minOccurs=”1” />

<xs:element name=”cap” type=”xs:string” maxOccurs=”3” />


Restriccions● Podem fer modificacions als tipus simples

posant-hi restriccions● Es defineixen els nous tipus restringits amb

SimpleType

<xs:element name=”naixement”> <xs:simpleType> ... </xs:simpleType></xs:element>


Restringir els tipus simples● Després amb l'etiqueta xs:restriction s'hi

defineix el tipus del que es vol fer la restricció

<xs:element name=”naixement”> <xs:simpleType> <xs:restriction base=”xs:integer” > ... </xs:restriction> </xs:simpleType></xs:element>

De quin tipus fem la restricció


Restringir els tipus simples● Dins es defineix quina restricció hi volem

aplicar:

<xs:element name=”naixement”> <xs:simpleType> <xs:restriction base=”xs:integer” >

... </xs:restriction> </xs:simpleType></xs:element>

Quina restricció es vol fer


Restriccions● Les restriccions es defineixen amb etiquetes:

<xs:maxInclusive value=”5” /><xs:minInclusive value=”2” />

Definim un rang de valors. Serveix tant per números com per dates

<xs:length value=”4” /><xs:minLength value=”3” /><xs:maxLength value=”6” />

Definim la llargada del valor d'un camp

<xs:enumeration value=”A” /><xs:enumeration value=”B” /><xs:enumeration value=”C” />

Permeten definir un conjunt de valors acceptables

<xs:totalDigits value=”5” /><xs:fractionDigits value=”3” />

Permet definir el número de dígits d'un valor numèric o dels seus decimals

<xs:pattern value=”w_\d{3}” />Defineix valors basats en una expressió regular


Restriccions de valors● En aquest exemple es restringeix el valor de

l'etiqueta naixement a un valor entre 1900 i 2012:

<xs:element name=”naixement”> <xs:simpleType> <xs:restriction base=”xs:integer”> <xs:maxInclusive value=”2012” /> <xs:minInclusive value=”1900” /> </xs:restriction> </xs:simpleType></xs:element>


Crear tipus nous● Els tipus simples es poden reaprofitar en altres

llocs del document posant-hi nom:

<xs:simpleType name=”data_vida”> <xs:restriction base=”xs:integer”> <xs:maxInclusive value=”2010” /> <xs:minInclusive value=”1850” /> </xs:restriction></xs:simpleType>


Crear tipus nous● Un cop definit un tipus amb nom es pot fer

servir com un tipus normal

<xs:element name=”vida” type=”data_vida” /><xs:element name=”mort” type=”data_vida” />

No hi haurà cap diferència amb els altres


Restriccions amb patrons● Els patrons són un avenç força important amb

respecte als DTD– Permeten ajustar el contingut d'una etiqueta de

manera que s'ajusti a valors arbitraris

● Es defineixen amb l'etiqueta <xs:pattern>

● La clau de tot està en els valors que es posen en l'atribut value

<xs:pattern value=”\d{5}” />


Patrons. Qualsevol caràcter

\d Qualsevol dígit

\D Qualsevol no dígit

\s Espais en blanc, tabuladors, salts de línia

\S Qualsevol caràcter que no sigui algun dels anteriors

x* Hi han d'haver zero o més x

x? Hi ha d'haver o una o cap x

x+ Hi ha d'haver una o més x

[abc] Hi ha d'haver algun dels caràcters de dins dels corxets

[0-9] Un valor entre 0 i 9

x{5} Hi han d'haver 5 x seguides

x{5,} Hi han d'haver almenys 5 x seguides

x{5,8} Hi han d'haver entre 5 i 8 x seguides

(xyz){2} Hi ha d'haver dues vegades el de dins del parèntesi


Patrons● Això permet definir una etiqueta que obligui a

que el contingut sigui com un DNI:– 8 números: [0-9]{8}, Un guió: - i una lletra en majúscules: [A-Z]

<xs:element name=”dni”> <xs:simpleType> <xs:restriction base=”xs:string”> <xs:pattern value=”[0-9]{8}-[A-Z]” /> </xs:restriction> </xs:simpleType></xs:element>

<dni>77980433K</dni>


Llistes● Les llistes de valors es defineixen amb <list>

<xs:element name=”partits”> <xs:simpleType> <xs:list itemType=”xs:dateTime” /> </xs:simpleType></xs:element>

<partits> 2010-09-12T17:30 2010-09-19T19:00</partits>


Unions● O definir continguts de diferents grups

● En l'exemple el valor haurà de ser un valor dels tipus “euros” o de “pessetes”

– S'han de posar tipus obligatòriament

<xs:element name=”valor”> <xs:simpleType> <xs:union memberTypes=”euros pessetes” /> </xs:simpleType></xs:element>


XML Schema

Tipus complexes


Tipus complexes● Un tipus complexe és un que conté elements

fills, atributs o una combinació d'ambdós● Normalment sempre hi haurà com a mínim un

tipus complexe en els documents: l'arrel

<cos> <cap> <ulls /> <nas /> <boca /> </cap></cos>


Tipus complexes● Els tipus complexes es divideixen en altres

tipus complexes o en tipus simples

<cos> <cap> <ulls /> <nas /> <boca /> </cap> <cos> <cames /></cos>

Complexe format per complexes

Complexe format per simples


Tipus complexes● No hi ha tipus complexes predefinits i per tant

cal definir-los

<xs:element name=”fabricacio”>

<xs:complexType> ... </xs:complexType>

</xs:element>El definim igual

que abans però el derivem de

complexType


Atributs● Una diferència amb els tipus simples és que els

complexes poden contenir atributs

<cos animal=”cuc”> <cap> <ulls color=”blau” numero=”2”/> <nas /> <boca /> </cap></cos>


Atributs● L'etiqueta que serveix per definir atributs és

<attribute>

<xs:attribute name=”nom” type=”xs:string”/>

Definició d'un atribut

Nom de l'atributEn aquest exemple

és nom Tipus de dades que hi haurà en

l'atribut

Els atributs sempre són per defecte

opcionals


Atributs● S'hi pot treballar igual que amb els elements

<xs:attribute name=”Id”> <xs:simpleType> <xs:restriction base=”xs:integer” /> <xs:pattern value=”\d{4}” /> </xs:restriction> </xs:simpleType></xs:attribute>

Però el seu contingut no pot ser complexe


Atributs: use● Per fer un atribut obligatori es fa servir use=”required”

● Perquè no es faci servir posem use=”prohibited”

● També existeix la opció use=”optional” però rarament es fa servir

<xs:attribute name=”src” type=”xs:anyURI” use=”required” />


Atributs● Com amb les etiquetes podem definir valors per

defecte, valors fixes i grups d'atributs

<xs:attribute name=”numero” type=”xs:integer” Default=”1” />

<xs:attribute name=”especial” type=”xs:integer” fixed=”Disabled” />

<xs:attributeGroup name=”Persones”> ... </xs:attributeGroup>

<xs:attributeGroup ref=”Persones” />


Atributs● Els atributs es defineixen al final de la definició

del ComplexType

<element name=”animal”> <xs:complexType> ... ... <xs:attribute name="nom" type="xs:string" use="required"/> </xs:complexType> </element>


complexType● Resumint, els tipus complexes poden tenir dos

tipus de continguts

Etiquetes

Dades


complexType● Els continguts de tipus de text es defineixen

amb dues etiquetes:

<xs:complexContent>

<xs:simpleContent> Contingut simple

Contingut complex


simpleContent● El cas més simple de tipus complexe és tenir

una etiqueta amb contingut i atributs

<persona tipus=”home”>Manel Puig </persona>

Té un atribut o sigui que és complexType

Però el contingut és simple


simpleContent

<xs:element name="persona"> <xs:complexType>

<xs:simpleContent>

<xs:extension base="xs:string">

<xs:attribute name="tipus" type="xs:string"/>

</xs:extension> </xs:simpleContent> </xs:complexType></element>

simpleContent per indicar que el valor és simple

L'atribut

Tipus integer


complexType● Quan el contingut són etiquetes es defineix a

partir de tres etiquetes

<xs:sequence>

<xs:all>

<xs:choice>

Seqüències d'etiquetes

Tria d'etiquetes


Seqüències ordenades● Seqüències ordenades d'elements

<xs:sequence>

– Es defineixen en l'ordre en el que els volem

– Pot contenir altres seqüències ...

<xs:complexType nom=”persona”> <xs:sequence> <xs:element name=”nom” type=”xs:string”/> <xs:element name=”cognom” type=”xs:string” maxOccurs=”2”/> </xs:sequence></xs:complexType>


Seqüències desordenades● Quan ens interessi que els elements apareguin

en qualsevol ordre fem servir <xs:all>

– Les etiquetes han d'aparèixer només un cop i només pot contenir elements

<xs:complexType nom=”persona”> <xs:all> <xs:element name=”nom” type=”xs:string”/> <xs:element name=”cognom” type=”xs:string”/> </xs:all></xs:complexType>


Seqüències desordenades● Però s'ha de tenir en compte que les etiquetes

dins de all només poden sortir UN COP

● Una solució alternativa pot ser crear un tipus complexe amb la repetició

<A> <a>A1</a> B1 B2</A>

<xs:all> <xs:element name=”a” type=”xs:string”/> <xs:element name=”b” type=”xs:string” maxOccurs=”2” /></xs:all>

<A> <a>A1</a> B1 B2</A>

<xs:all> <xs:element name=”a” type=”xs:string”/> <xs:element name=”b” type=”tipus-B” /></xs:all>


Tria d'elements● Podem definir o uns elements o uns altres

<xs:choice>

– A dins hi poden haver seqüències i es pot niuar

<xs:complexType nom=”persona”> <xs:choice> <xs:element name=”nomCognom” type=”xs:string”/> <xs:element name=”dni” type=”xs:string”/> </xs:choice></xs:complexType>


Tria d'elements: Determinisme● S'ha de tenir en compte que davant de cada

decisió el processador ha de saber per quin camí ha de tirar

● No es poden fer coses com:<xs:choice> <xs:sequence> <xs:element name=”nom”/> <xs:element name=”alies”/> <xs:element name=”cognom”/> </xs:sequence> <xs:sequence> <xs:element name=”nom”/> <xs:element name=”cognom”/> </xs:sequence></xs:choice>

El processador no sabrà quina alternativa triar


Tipus complexes buits

<xs:element name=”Persona”> <xs:complexType name="Mida">

<xs:attribute name="metres" type="xs:token"/>

</xs:complexType></xs:element>

Es defineixen els atributs sense res més

● Si no té atributs podem definir<xs:complexContent> <xs:restriction base="xs:anyType"/></xs:complexContent>


Elements buits● Si no té atributs també podria haver definit la

etiqueta amb el tipus simple– Definint-ne la llargada a zero

<xs:element name="delegat"> <xs:simpleType> <xs:restriction base="xs:string"> <xs:length value="0"/> </xs:restriction> </xs:simpleType></xs:element>


Tipus complexes mixtes

<xs:complexType name="Mida" mixed=”true” >

<xs:sequence> <xs:element name=”metres” /> <xs:element name=”centimetres” /> </xs:sequence> </xs:complexType>

● Un element pot contenir etiquetes i text.

Si volem fer les mescles hem de declarar que l'element serà de

tipus mixed


Contingut barrejat● Amb això podrem validar coses com:

<carta>Estimat senyor <nom>Pere<nom>:Li envio aquesta carta per recordar-li que hem quedat per trobar-nos el dia <cita>12</cita> Joan</carta>

<xs:element name=”carta”> <xs:complexType mixed=”true”> <xs:sequence> <xs:element name=”nom” type=”xs:string” /> <xs:element name=”cita” type=”xs:integer” /> </xs:sequence> </xs:complexType></xs:element>


Altres● Per determinar quants n'hi ha d'haver podem

fer servir minOccurs i maxOccurs en l'element

● Si un grup d'elements surten varies vegades podem definir un grup

– S'han de definir al principi del fitxer

<xs:complexType name="moneder"> <xs:choice minoccurs=”1” maxoccurs=”4”>

<xs:group name="moneder"> ...</xs:group>

<xs:group ref=”moneder” />


Referències a elements● Podem definir els elements de forma global i

després usar-los en les definicions de tipus

– Això ens permetrà reusar-los quan ens facin falta

<xs:element name=”nom” type=”xs:string” /> <xs:element name=”cognom” type=”xs:string” />

<xs:element name=”persona”> <xs:complexType> <xs:element ref=”nom” /> <xs:element ref=”cognom” /> </xs:complexType></xs:element>


XML Schema

Exemple


XML● Volem fer un Schema per validar aquest

document:

<?xml version="1.0" encoding="UTF-8"?> <classe> <curs>1r ASIX</curs> <professor> <nom>Xavier Sala</nom> </professor> <alumnes> <nom>Federicu Garcia</nom> <nom>Mariano Pi</nom> <nom>Filomenu Bonany</nom> </alumnes></classe>


Modificar l'XML● El primer és afegir en la definició de l'etiqueta

arrel, “classe”, quin serà el document.

– Com que no definirem cap espai de noms fem servir noNamespaceSchemaLocation

● En el document XML no hi hem de fer res més

<?xml version="1.0" encoding="UTF-8"?><classe xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="classe.xsd">


Crear el XSD● Hem de crear el document XSD:

● Hi ha diverses formes d'atacar-lo:– Anar definint les etiquetes tal com estan en el

document

– Definir els tipus simples i anar muntant els complexes a partir d'aquests

– Amb tipus amb nom

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


Crear el XSD: possibilitat 1● Partim de la etiqueta arrel i hi definim el

contingut: curs, professor i alumnes

– L'etiqueta “curs” és simple : ja està

– Les altres els haurem de definir més detalladament

<xs:element name="classe"> <xs:complexType> <xs:sequence> <xs:element name="curs" type="xs:string" /> <xs:element name="professor"> </xs:element> <xs:element name="alumnes"> </xs:element> </xs:sequence> </xs:complexType></xs:element>


Crear el XSD: possibilitat 1● O sigui:

<xs:element name="classe"><xs:complexType>

<xs:sequence><xs:element name="curs" type="xs:string" /><xs:element name="professor" maxOccurs="1"> <xs:complexType>

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

</xs:sequence> </xs:complexType></xs:element><xs:element name="alumnes" > <xs:complexType>

<xs:sequence><xs:element name="nom" type="xs:string"

maxOccurs="unbounded"/></xs:sequence>

</xs:complexType></xs:element>

</xs:sequence></xs:complexType>

</xs:element>


Crear el XSD: possibilitat 2● Normalment un millor sistema és definir-ho amb

referències perquè és més mantenible– Comencem pels tipus simples

– I després els complexes a partir de les referències

<xs:element name="curs" type="xs:string" /><xs:element name=”nom” type=”xs:string” />

<xs:element name="professor"> <xs:complexType> <xs:sequence> <xs:element ref=”nom” maxOccurs=”1” /> </xs:sequence> </xs:complexType></xs:element>


Crear el XSD: possibilitat 2<xs:element name="alumnes"> <xs:complexType> <xs:sequence> <xs:element ref=”nom” maxOccurs=”unbounded” /> </xs:sequence> </xs:complexType></xs:element>

<xs:element name=”classe”> <xs:complexType> <xs:sequence> <xs:element ref=”curs” /> <xs:element ref=”professor” /> <xs:element ref=”alumnes” /> </xs:sequence> </xs:complexType></xs:element>


Crear el XSD: possibilitat 3● I sempre podem recórrer a fer tipus amb nom

per crear l'esquema:– Hem de definir els tipus simples per poder-los

combinar en compostos

<xs:simpleType name="tipusnom" > <xs:restriction base="xs:string"/> </xs:simpleType> <xs:simpleType name="tipuscurs"> <xs:restriction base="xs:string" /> </xs:simpleType>


Crear el XSD: possibilitat 3

<xs:complexType name="tipusprofessor"> <xs:sequence> <xs:element name="nom" type="tipusnom" maxOccurs="1" /> </xs:sequence></xs:complexType> <xs:complexType name="tipusalumne"> <xs:sequence> <xs:element name="nom" type="tipusnom" maxOccurs="unbounded"/> </xs:sequence></xs:complexType>

● I després la resta


Crear el XSD: possibilitat 3● I acabem amb l'element arrel

<xs:complexType name="tipusalumne"> <xs:sequence> <xs:element name="curs" type="tipuscurs" /> <xs:element name="professor" type="tipusprofessor" /> <xs:element name="alumnes" type="tipusalumne" /> </xs:sequence></xs:complexType> <xs:element name=”classe” type=”tipusalumne” />

http://www.w3.org/2001/XMLSchema

Education

Validació de Documents XML amb XSD