Tema 3. Validació de documents XML (XSD)

James Clark, desenvolupador d'eines XML i XSL

"XML Schema es tan poderoso que puede hacer casi todo lo que quieras. Y tan complejo que nadie querrá hacerlo."

3.1. Esquemes a XML, una introducció (XSD i DTD).

Una vegada el nostre document XML és correcte sintàcticament (està ben format), veurem com validar-lo. Els esquemes serveixen per a comprobar que un document XML és vàlid respecte a un conjunt de regles ben definit. Donat el següent XML:

<llibre isbn="0-2777-6861-6">
  <autor>J.D. Salinger</autor>
  <titol>The Catcher in the Rye</titol>
</llibre>

Un esquema permetria validar, per exemple, la següent estructura i regles:

L'estructura dels elements i els atributs. Per exemple, l'element llibre ha de contenir els elements autor i titol, i opcionalment l'atribut isbn.
L'ordre dels elements. Per exemple, podem especificar que l'element autor va abans que titol,
Tipus de dades dels elements i els atributs. Enter, decimal o cadena de texte són alguns exemples. També es poden definir tipus de dades basades en rangs, enumeracions o coincidència de patrons (patterns). Per exemple, podem definir que l'atribut isbn tingui el patró 0-0000-0000-0.

Els esquemes XML aporten les següents funcionalitats:

Servir com a contracte entre empreses que es suministren productes. Un esquema indica clarament quins elements han d'aparèixer en els documents que rebrà. Per exemple, pot especificar que totes les factures indiquin el NIF de l'empresa a qui es factura.
Documentació de sistema. Permet a qualsevol que vulgui, entendre els noms, atributs i estructura del document XML. També es poden fer anotacions.
Incorporació de dades noves XSD permet incorporar valors per defecte i fixes al document XML. També permet normalitzar els espais en blanc.

XML Schema o XSD (XML Schema Definition) permet definir de forma molt precisa el contingut dels documents XML i és el que farem servir en aquesta unitat. També existeixen altres llenguatges d'esquema:

Relax NG. Basat en gramàtica. És més fàcil d'entendre que XML Schema. Desenvolupat per Oasis.
Schematron. Està basat en afirmacións enlloc de gramàtica.

També hi ha utilitats per convertir d'aquests formats a XSD.

3.1.1. DTD i XSD

Un document ben format pot ser validat amb les tecnologies DTD (Document Type Definition) o XSD (XML Schema).

DTD defineix els blocs o elements d'un document XML. DTD prové d'un subconjunt del llenguatge SGML. Des de principis de 2000, DTD ha estat substituit per altres opcions com XSD o Relax NG, principalment degut a les seves limitacions.

Algunes de les seves limitacions són:

Un document DTD no és un document XML, per tant no podem verificar que estigui ben format.
No es poden fer restriccions sobre els diferents valors que pot pendre un element: tamany, tipus de dades, etc.
No es pot donar un valor per defecte per als elements (si els atributs).
No soporta espais de noms.

L'alternativa als documents DTD són els esquemes XML o XSD (XML Schema Definition).

XSD supera les limitacions de DTD:

Els documents XSD deriven de XML, per tant són documents XML i es poden comprobar sintàcticament.
XSD defineix molts tipus de dades predefinits.
XSD permet definir la cardinalitat dels elements.
XSD permet mesclar diferents vocabularis XML (espais de noms).

Els documents XSD tenen l'inconvenient de que són lleugerament més difícils d'interpretar que els DTD.

Un Esquema XML és el motlle d'on sortiran els diferents documents XML que compliran l'estructura definida a l'esquema, cadascun amb les seves dades concretes.

Per validar els documents XML, podem fer servir les eines de programació vistes fins ara. També podem trobar alguns validadors on-line, com per exemple:

CoreFiling XML Schema Validator

3.2. Estructura d'un esquema XML.

Per crear un esquema XSD seguim els seguents passos:

Crear el document XML que volem validar. P. ex.: arxiu.xml.
Crear el document de validació (XSD) en un arxiu apart amb extensió .xsd. P. ex.: arxiu.xsd.
Enllaçar el document XML amb el XSD.

Per indicar-li a un document XML quin document de validació volem fer servir, afegirem un atribut a l'element arrel del document XML.

3.2.1. Regles XSD

Un esquema XML és un document XML que ha de complir les següents regles:

L'element arrel s'anomena schema.
L'espai de noms ha de ser http://www.w3.org/2001/XMLSchema. Es pot no usar prefixe, utilitzar xs o xsd:

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

Igual que a DTD, el primer que hem de fer és declarar l'element arrel del nostre XML. La sintaxi de xs:element seria:

<xs:element name = "nom-element-arrel">

Aquest element conté l'atribut name que defineix l'element arrel del document. XSD permet tenir més d'un element arrel al nostre esquema.

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

L'ordre en que es declaren els elements (anomenats components a XSD) no és rellevant.

3.2.2. Vinculació d'un document XML amb un document XSD.

Per a vincular un esquema amb un document XML hem d'afegir l'atribut noNamespaceSchemaLocation a l'element arrel del nostre document XML:

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

En l'exemple anterior, a l'arxiu landrover.xsd tindrem les nostres declaracions XSD. Els blocs principals d'un esquema XSD són xs:element i xs:attribute, que veurem a continuació.

3.2.3. Elements

Els elements i els atributs són els blocs principals amb els que es construeixen els documents XML. Per tant, el nostre esquema XSD contindrà una declaració per a cada element i cada atribut que hi hagi al document.

Cadascun dels elements i atributs està associat a un tipus de dades (veure atribut type més endavant). XSD separa els conceptes d'element i atributs dels seus tipus de dades. Això permet reutilitzar la mateixa estructura a varis elements idèntics. Per exemple, a un a factura podem tenir dos elements anomenats adrecaenviament i adrecafacturacio que tenen la mateixa estructura pero noms diferents. Només hem de declarar un tipus TipoDireccion i fer-lo servir en la declaració dels elements.

Exemple d'estructura repetida:

<factura>
<capcelera>
  <shipping_address>
    <name></name>
    <street></street>
    <city></city>
  </shipping_address>

  <invoice_address>
    <name></name>
    <street></street>
    <city></city>
  <invoice_address>
</capcelera>
<cos></cos>
</factura>

Els elements han d'incloure com a mínim l'atribut name per especificar el nom de l'element XML i type per especificar el tipus de dades.

Exemples de declaració d'elements a XSD:

<!-- L'element nom utilitza el tipus predefinit xsd:string (veure **3.2.4. Tipus de dades** més endavant) -->
<xsd:element name="nom" type="xsd:string"/>

<nom>Joan</nom>

<!-- l'element __tamany__ fa servir el tipus __TamanyTipus__ per indicar el tipus de dades de l'element(veure 3.2.5. Definició de tipus de dades propis) -->
<xsd:element name="tamany" type="TamanyTipus"/>

<tamany>L</tamany>

<!-- 3 Si no hem especificat cap tipus de dades, el tipus serà __anyType__, que permet qualsevol contingut amb fills o caràcters. -->
<xsd:element name="anything"/>

Els atributs principals de <xs:element> són els següents:

nom atribut	propòsit
name	nom de l'element, obligatori si és l'arrel
ref	nom d'un altre element que es troba en el document
type	el tipus d'element (veure tipus de dades)
default	valor per defecte de l'element. Només es pot utilitzar per a continguts amb texte.
fixed	indica l'únic valor possible, sempre que sigui texte.
minOccurs	número mínim d'ocurrències d'un element. veure indicadors.
maxOccurs	número màxim d'ocurrències d'un element. veure indicadors.
id	identificador únic per a l'element

3.2.4. Tipus de dades

Els tipus de dades predefinits més comuns a XSD són:

xs:string (cadena)
xs:decimal (número decimal)
xs:integer (sencer)
xs:boolean (veritable/fals)
xs:date (data)
anyURI (adreça web)

Exemples:

  <xs:element name="dia" type="xs:date" /> <dia>2011-09-15</dia>
  <xs:element name="altura" type="xs:integer"/> <altura>220</altura>
  <xs:element name="nombre" type="xs:string"/> <nombre>Pere Puig</nombre>
  <xs:element name="tamaño" type="xs:float"/> <tamany>1.7E2</tamany>

Tipus de dades predefinits a XSD (https://www.w3.org)

3.2.5. Definició de tipus de dades propis.

Per a crear un tipus de dades nou personalitzat, fem el següent:

Creem la definició del tipus mitjançant <xs:simpleType> o <xs:complexType>.
Definim un element a XSD i li assignem el nou tipus de dades creat.

Per exemple, volem definir un tipus de dades anomenat tipus_samarreta que només pugui contenir els següents valors: M, L, XL, XXL.

<tamany>M</tamany>

El següent fragment XSD crea un tipus personalitzat simple mitjançant l'element xs:simpleType (el contingut no te altres elements fills i l'element no té atributs). La restricció tipus xs:enumeration defineix uns valors vàlids per a l'element . Les restriccions (també anomenades facetes) es veuen més endavant i permeten definir tipus de dades.

<!-- pas 1 -->
<xs:simpleType name="tipus_samarreta">
  <xs:restriction base="xs:string">
    <xs:enumeration value="L"/>
    <xs:enumeration value="M"/>
    <xs:enumeration value="XL"/>
    <xs:enumeration value="XXL"/>
  </xs:restriction>
</xs:simpleType>

<!-- pas 2 -->
<xs:element name="tamany" type="tipus_samarreta"/>

<!-- element XML -->
<tamany>L</tamany>    <!-- OK -->
<tamany>XXXL</tamany> <!-- No valida -->

El següent fragment XSD crea un tipus personalitzat anomenat tipus_edat indicant que el valor mínim ha de ser 1.

<!-- pas 1 -->
<xs:simpleType name="tipus_edat">
  <xs:restriction base="xs:integer">
    <xs:minExclusive value="0"/>
  </xs:restriction>
</xs:simpleType>

<!-- pas 2 -->
<xs:element name="edat" type="tipus_edat"/>

<!-- element XML -->
<edat>23</edat>
<edat>0</edat>        <!-- No valida -->

3.2.5. Atributs

Fem servir el component <xs:attribute> per especificar els atributs dels nostre document XML.

Atributs principals de <xs:attribute>:

nom atribut	propòsit
name	nom de l'atribut. Aquest atribut no pot aparèixer al mateix temps que ref
ref	referència a la descripció de l'atribut que es troba en altre lloc de l'esquema. Si surt aquest atribut, no apareixeran els atributs type, ni form, ni podrà contenir un component xs:simpleType
type	el tipus d'element (veure tipus de dades)
use	indica si l'existència de l'atribut és opcional, obligatòria o prohibida (optional, required, prohibited)
default	valor que prendrà l'atribut quan sigui procesat per alguna aplicació quan al document XML no hi té cap valor assignat. No pot aparèixer al mateix temps que fixed
fixed	Valor únic que pot contenir el document. No pot aparèixer simultàniament amb default
id	indica identificador únic per al atribut

Exemple:

<xs:attribute name="alias" type="xs:string"/>
<!-- Ahora podemos usarlo dentro de un elemento nombre -->
<nombre alias="Snake"> Plissken </nombre>

Un exemple complet:

XML Schema Tutorial

3.3. Data types i exemples.

Els tipus de dades permeten la validació del contingut dels elements i dels valors dels atributs. Poden ser tipus simples (simpleType) o tipus complexes (complexType).

Els elements que tenen assignats tipus simples tenen dades de caràcters, però no tenen elements fills o atributs. Si tenen fills o atributs, aleshores es consideren tipus complexes.

Els següents elements tenen tipus simple:

<tamany>L<tamany>

<comentari>va molt gran</comentari>

<tamanysDisponibles>10 L 2 M</tamanysDisponibles>

Per altra banda, els elements complexos poden tenir elements fills o atributs.

Els següents elements tenen tipus complexe:

<tamany sistema="EU">L<tamany>

<comentari>va <b>molt molt</b> gran</comentari>

<tamanysDisponibles>
  <size>10</size>
  <size>2</size>
</tamanysDisponibles>

Per declarar l’element <tamanysDisponibles> amb XSD:

<xs:element name="tamanysDisponibles">
  <xs:complexType>
    <xs:sequence>
      <xs:element maxOccurs="unbound" name="size" type="xs:integer"/>
    </xs:sequence>
  </xs:complexType>
</xs:element>

Els atributs sempre són de tipus simple, doncs els atributs no poden tenir elements fills. Per veure com definir atributs, veure (3.3.2 Tipus simples)

3.3.1 Tipus complexes

El contingut d'un element són els caràcters de dades i elements fills dintre de les etiquetes. Hi ha quatre tipus de contingut per a tipus complexes: simple, element, mixed i buit. El tipus de contingut és independent dels atributs. És a dir tots els tipus de contingut poden tenir atributs o no.

A continuació tenim un exemple de cadascun i com definir-los a XSD.

Simple:

<tamany sistema="EU">10</size>

Definició amb XSD:

<xs:element name="tamany">
  <xs:complexType>
    <xs:simpleContent>
      <xs:extension base="xs:string">
        <xs:attribute name="sistema" type="xs:string"></xs:attribute>
      </xs:extension>
    </xs:simpleContent>
  </xs:complexType>

Element:

<producte>
  <numero>34D</numero>
  <tamany>10</tamany>
</producte>

Definició amb XSD:

<xs:element name="producte">
  <xs:complexType>
    <xs:sequence>
      <xs:element name="numero" type="xs:string"/>
      <xs:element name="tamany" type="xs:integer"/>
    </xs:sequence>          
  </xs:complexType>
</xs:element>

Mixed (contingut mixte):

<carta> Estimat <nomClient>Carles Puig</nomClient> ...</carta>

Definició amb XSD:

<xs:element name="carta">
  <xs:complexType mixed="true">
    <xs:sequence>
      <xs:element name="nomClient"></xs:element>
    </xs:sequence>
  </xs:complexType>
</xs:element>

Element Buit:
```
<color valor="blau"/>
```

Definició amb XSD:

<xs:element name="color">
  <xs:complexType>
    <xs:attribute name="valor" type="TipusColorValors"/>
  </xs:complexType>
</xs:element>

3.3.2 Tipus simples (definició d'atributs i extensions)

Per definir un atribut per un element qualsevol, podem diferenciar si el contingut de l'element és simple o complex (conté altres elements). A continuació veiem dos exemples i com definir-los a XSD.

<!-- Exemple 1: aquest element és complexType (té atributs) pero el seu contingut és simple -->
<ciutat poblacio="45258">Reus</ciutat>

<!-- Exemple 2: aquest element és complexType (té atributs) i el seu contingut és complexe -->
<ciutat poblacio="45258">
  <nom>Reus</nom>
</ciutat>

Donat que el primer element té un contingut simple, hem d'extendre el contingut de texte. Per tant utilitzem la seqüencia d'elements: xs:complexType->xs:simpleContent->xs:extension.

<!-- Exemple 1: aquest element és complexType (té atributs) pero el seu contingut és simple -->
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
    <xs:element name="ciutat">
        <xs:complexType>
            <xs:simpleContent>
                <xs:extension base="xs:string">
                    <xs:attribute name="poblacio" type="xs:integer" use="required"/>
                </xs:extension>
            </xs:simpleContent>
        </xs:complexType>
    </xs:element>
</xs:schema>

En aquest cas definim l'atribut dintre de l'element complexe:

<!-- Exemple 2: aquest element és complexType (té atributs) pero el seu contingut és simple -->
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
    <xs:element name="ciutat">
        <xs:complexType>
            <xs:sequence>
                <xs:element name="nom" type="xs:string"/>
            </xs:sequence>
            <xs:attribute name="poblacio" type="xs:integer" use="required"/>
        </xs:complexType>
    </xs:element>
</xs:schema>

Es possible definir el primer exemple sense l'ús de simpleContent, per exemple declarant el contingut mixte:

<!-- Exemple 1 alternatiu: utilitzem el contingut mixte -->
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
    <xs:element name="ciutat">
        <xs:complexType mixed="true">
            <xs:attribute name="poblacio" type="xs:integer" use="required"/>
        </xs:complexType>
    </xs:element>
</xs:schema>

3.4. Indicadors

Hi ha set indicadors a XML. Els indicadors especifiquen com s'utilitzen els elements dintre del document XML. Per exemple defineixen l'ordre, el número de instàncies o l'obligatorietat.

3.4.1. Indicadors d'ordre

Cada element complexe (excepte els elements buits) conté un únic model de grup.

Sequence L'indicador sequence s'utilitza per indicar l'ordre dels elements fills (si apareixen) de l'element complexe. Els elements poden conentir un indicador d'ocurrència, com minOccurs, però aquest és opcional.

Exemple:

<xs:element name="employee">
<xs:complexType >
  <xs:sequence>
    <xs:element name="firstname" type="xs:string"/>
    <xs:element name="lastname" type="xs:string"/>
    <xs:element name="registration-date" type="xs:date"/>
  </xs:sequence>
</xs:complexType>
</xs:element>

All L'indicador all es comporta com el seqüence, excepte que no es necessari que surtin tots els elements ni en el mateix ordre. Si surten, només poden sortir un cop.

Exemple:

<xsd:element name="samarreta">
  <xsd:complexType>
    <xsd:all>
      <xsd:element name="color" type="xsd:string"/>
      <xsd:element name="tamany" type="tamanys-roba"/>
    </xsd:all>
  </xsd:complexType>
</xsd:element>

Choice L'indicador choice declara un grup d'elements del qual només un sortirà un al document XML.

Exemple:

<xs:element name="vehicle-motor">
<xs:complexType >
  <xs:choice>
    <xs:element name="cotxe" type="xs:string"/>
    <xs:element name="moto" type="xs:string"/>
    <xs:element name="camio" type="xs:string"/>
  </xs:choice>
</xs:complexType>
</xs:element>

3.4.2. Indicadors d'ocurrència

Els indicadors d'ocurrència determinen el número de vegades que surt un element en el document XML. Els valor per defecte de minOccurs i maxOccurs és 1.

Els indicadors maxOccurs i minOccurs es poden utilitzar com a atributs dintre dels xs:element i els indicadors d'ordre (xs:sequence, xs:choice).

Exemple:

<xs:element name="book" maxOccurs="unbounded">
<xs:complexType>
  <xs:sequence>
    <xs:element name="cotxe" type="xs:string"/>
    <xs:element name="moto" type="xs:string"/>
    <xs:element name="camio" type="xs:string"/>
  </xs:sequence>
</xs:complexType>
</xs:element>

Dintre d'aquests indicadors podem fer servir un valor numèric o unbounded que indica un número il.limitat d'elements.

3.4.3. Indicadors de grup

Group name i attributeGroup name Podem definir un grup d'elements o atributs, donar-li un nom i fer referència al grup desde una altra definició.

Exemple:

<xs:group name="persona-grup">
  <xs:sequence>
    <xs:element name="nom" type="xs:string"/>
    <xs:element name="cognom" type="xs:string"/>
    <xs:element name="data-naixement" type="xs:date"/>
  </xs:sequence>
</xs:group>

<xs:element name="person" type="personinfo"/>

<xs:complexType name="personinfo">
  <xs:sequence>
    <xs:group ref="persona-group"/>
    <xs:element name="country" type="xs:string"/>
  </xs:sequence>
</xs:complexType>

3.5. Facetes

Las restriccions a XSD -també anomenades facetes- s'utilizan per a definir un rang de valors acceptable per als elements simples o atributs XML.

1. Restriccions per rang de valors

El següent exemple defineix un element anomenat edat amb una restricció. El valor de l'edat no pot ser més petita que 0 o més gran que 120.

<xs:element name="edat">
  <xs:simpleType>
    <xs:restriction base="xs:integer">
      <xs:minInclusive value="0"/>
      <xs:maxInclusive value="120"/>
    </xs:restriction>
  </xs:simpleType>
</xs:element>

2. Restriccions per una sèrie de valors

Per limitar el contingunt d'un element XML a una sèrie acceptable de valors, farem servir la restricció d'enumeració. L'exemple que ve a continuació defineix un element anomenat cotxe amb una restricció. Els únics valors acceptables son: Audi, Golf, BMW.

<xs:element name="marca_cotxe">
  <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>

L'exemple de dalt també es pot escrire com segueix:

<xs:element name="car" type="marca_cotxe"/>
  <xs:simpleType name="marca_cotxe">
    <xs:restriction base="xs:string">
      <xs:enumeration value="Audi"/>
      <xs:enumeration value="Golf"/>
      <xs:enumeration value="BMW"/>
    </xs:restriction>
</xs:simpleType>

Nota: En aquest cas el tipus "carType" es pot fer servir en altres elements perquè no és part de l'element "car".

3. Restriccions per una sèrie de valors (patrons)

Per limitar el contingut d'un element XML per a definir una sèrie de números o lletres que es poden fer servir, farem servir la restricció de patró. L'exemple següent defineix un element anomenat "letter" amb una restricció, que consisteix en contenir UNA lletra MINÚSCULA (de a fins a z).

<xs:element name="letter">
  <xs:simpleType>
    <xs:restriction base="xs:string">
      <xs:pattern value="[a-z]"/>
    </xs:restriction>
  </xs:simpleType>
</xs:element>

En el següent exemple només s'admeten tres lletres majúscules (a fins z):

<xs:element name="initials">
  <xs:simpleType>
    <xs:restriction base="xs:string">
      <xs:pattern value="[A-Z][A-Z][A-Z]"/>
    </xs:restriction>
  </xs:simpleType>
</xs:element>

En el següent exemple només s'admeten tres lletres majúscules o minúscules:

<xs:element name="initials">
  <xs:simpleType>
    <xs:restriction base="xs:string">
      <xs:pattern value="[a-zA-Z][a-zA-Z][a-zA-Z]"/>
    </xs:restriction>
  </xs:simpleType>
</xs:element>

En el següent exemple només s'admet una de les següents lletres x, y o z:

<xs:element name="choice">
  <xs:simpleType>
    <xs:restriction base="xs:string">
      <xs:pattern value="[xyz]"/>
    </xs:restriction>
  </xs:simpleType>
</xs:element>

Només s'accepten cinc digits en seqüència, cada dígit ha d'estar en el rang 0 fins a 9.

<xs:element name="prodid">
  <xs:simpleType>
    <xs:restriction base="xs:integer">
      <xs:pattern value="[0-9][0-9][0-9][0-9][0-9]"/>
    </xs:restriction>
  </xs:simpleType>
</xs:element>

4. Restriccions amb els caràcters "white-space"

Per especificar com es tracten els caràcters "white-space", farem servir la restricció whiteSpace. El següent exemple defineix un element anomenat "address" amb una restricció. La restricció está establerta a "preserve", que vol dir que el processador XML no esborrarà cap caracter "white-space" (espais, tabuladors, noves línees i retorns de carro).

<xs:element name="address">
  <xs:simpleType>
    <xs:restriction base="xs:string">
      <xs:whiteSpace value="preserve"/>
    </xs:restriction>
  </xs:simpleType>
</xs:element>

Aquest exemple utilitza replace, que reemplaça els caràcters whiteSpace amb espais:

<xs:element name="address">
  <xs:simpleType>
    <xs:restriction base="xs:string">
      <xs:whiteSpace value="replace"/>
    </xs:restriction>
  </xs:simpleType>
</xs:element>

Aquest exemple utilitza collapse, que esborra tots els caràcters whiteSpace. Els espais en blanc múltiples es redueixen a un únic espai en blanc:

<xs:element name="address">
  <xs:simpleType>
    <xs:restriction base="xs:string">
      <xs:whiteSpace value="collapse"/>
    </xs:restriction>
  </xs:simpleType>
</xs:element>

5. Restriccions de tamany

Per a limitar la longitud d'un valor en un element farem servir les restriccions length, maxLength i minLength.

L'exemple següent defineix un element "password" amb la restricció que el valor ha de ser exactament de vuit caràcters:

<xs:element name="password">
  <xs:simpleType>
    <xs:restriction base="xs:string">
      <xs:length value="8"/>
    </xs:restriction>
  </xs:simpleType>
</xs:element>

Aquest exemple defineix altre element "password" amb una restricció. El valor ha de tenir mínim cinc caràcters i un màxim de vuit.

<xs:element name="password">
  <xs:simpleType>
    <xs:restriction base="xs:string">
      <xs:minLength value="5"/>
      <xs:maxLength value="8"/>
    </xs:restriction>
  </xs:simpleType>
</xs:element>

6. Restriccions disponibles per als tipus de dades

Restricció	Descripció	Valors
enumeration	Defineix una llista de valors acceptables
fractionDigits	Número màxim de decimals permesos	>= 0
length	Número exacte de caràcters o elements de llista permesos	>= 0
maxExclusive	Limit superior per valors numèrics	<
maxInclusive	Limit superior per valors numèrics	<=
minExclusive	Limit inferior per valors numèrics	>
minInclusive	Limit inferior per valors numèrics	>=
maxLength	Número máxim de caràcters o elements de llista permesos	>= 0
minLength	Número mínim de caràcters o elements de llista permesos	>= 0
pattern	Defineix la seqüència exacta de caràcters permesos	regex
totalDigits	Especifica el número exacte de dígits	>= 0
whiteSpace	Especifica com es tracten els espais en blanc	preserve replace collapse

7. Altres exemples amb patrons (Expressions regulars)

Els patrons és un tipus de restricció molt potent que permet detectar patrons dintre d'una cadena.

El següent exemple defineix un element anomenat "letter" amb una restricció. Els valors acceptables són zero o més ocurrències de lletres en minúscula de la a a la z:

<xs:element name="letter">
  <xs:simpleType>
    <xs:restriction base="xs:string">
      <xs:pattern value="([a-z])*"/>
    </xs:restriction>
  </xs:simpleType>
</xs:element>

El següent exemple defineix un element anomenat "letter" amb una restricció. Els valors acceptables són un o més parells de lletres, cada parell format per una minúscula seguit d'una majúscula. Per exemple, "sToP" es validaria correctament amb aquest patró, però no les cadenes de caràcters "Stop", "STOP" or "stop".

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

El següent exemple defineix un element anomenat "genere" amb una restricció. Els únics valors acceptables són home o dona:

<xs:element name="genere">
  <xs:simpleType>
    <xs:restriction base="xs:string">
      <xs:pattern value="(home|dona)"/>
    </xs:restriction>
  </xs:simpleType>
</xs:element>

El següent exemple defineix un element "password" amb una restricció. Ha d'haver exactament vuit caràcters seguits que poden ser lletres de la a a la z en (minúscula o majúscula) o un número del 0 al 9.

<xs:element name="password">
  <xs:simpleType>
    <xs:restriction base="xs:string">
      <xs:pattern value="[a-zA-Z0-9]{8}"/>
    </xs:restriction>
  </xs:simpleType>
</xs:element>

Els símbols que s'utilitzen a les expressions regulars (el que va dintre de l'element pattern), són els següents:

Metacaràcters Comuns:
- .: Qualsevol caràcter excepte el caràcter de nova línea
- \d: Dígit (equivalent a [0-9]).
- \w: Caràcter de paraula (lletra, dígit o guió baix).
- \s: Espai en blank
Quantificadors: estableixen el número de repeticions:
- *: Zero o més repeticions.
- +: Una o més repeticions.
- ?: Zero o cap repetició.
- {n}: Exactament n repeticions.
- {n,}: Almenys n repeticions.
- {n,m}: Entre n y m repeticions.
Grups i Alternatives:
- (...): Agrupació de patrons.
- |: Alternativa (OR).
- []: rang de valors

Escapat de caràcters especiales:

Si volen un dels caràcters amb significat especial (com . o *), s'han d'escapar amb una barra invertida.

Veiem alguns exemples més. Per validar un número de telèfon a Espanya:

<xs:element name="telefon">
    <xs:simpleType>
        <xs:restriction base="xs:integer">
            <xs:pattern value="[69][0-9]{8}"></xs:pattern>
        </xs:restriction>
    </xs:simpleType>
</xs:element>

Primer tindrem el digit 6 ó 9 i després qualsevol combinació de 8 digits. Per validar una adreça d'email tenim la següent restricció

<xs:element name="email">
    <xs:simpleType>
        <xs:restriction base="xs:string">
            <xs:pattern value="[A-Za-z._%+-]+@[A-Za-z\.]+[A-Za-z]{2,}"></xs:pattern>
        </xs:restriction>
    </xs:simpleType>
</xs:element>

Aquesta expressió té tres parts:

[A-Za-z._%+-]+@. Aquesta primera part defineix la part anterior a l'arroba d'una adreça. Es permeten totes les lletres més els símbols _, %, + i - un número indefinit de vegades (simbol +).
[A-Za-z\.]+. La segona part (nom del domini) permet un número indefinit de totes les lletres i punts
[A-Za-z]{2,}. La part del TLD té mínim dues lletres o més (.com, .edu, .io).

Per últim, volem validar una data amb format americà (AAAA-MM-DD):

<xs:element name="data">
    <xs:simpleType>
        <xs:restriction base="xs:string">
            <xs:pattern value="\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])" />
        </xs:restriction>
    </xs:simpleType>
</xs:element>

Aquesta expressió es divideix com segueix:

\d{4}-: quatre digits qualsevols seguit d'un guió.
(0[1-9]|1[0-2])-: el més pot ser un 0 més un digit del 1 al nou o un 1 més un altre 1 o un 2.
(0[1-9]|[12]\d|3[01]): el dia pot ser del 0 al 9, del 10 al 29 o el 30 i 31.

Aquest document està llicenciat sota els termes de la Licencia Creative Commons Attribution 4.0 International (CC BY 4.0).