ndice

XML Schema (XSD) .......................................................................................................................................... 2 Estructura y enlace con el XSD ...................................................................................................................... 2

El documento XML no tiene su propio espacio de nombres ................................................... 2 El documento XML tiene su propio espacio de nombres....................................................... 3
Componentes principales de un esquema .................................................................................................... 4

Tipos simples predefinidos .................................................................................................... 4 Declaracin de elementos ..................................................................................................... 5

Declaracin de elementos basados en un tipo predefinido ............................................................................... 5 Basados en un Tipo Simple definido por el usuario........................................................................................... 5 Basados en un Tipo Complejo definido por el usuario ...................................................................................... 6

Declaracin de atributos ........................................................................................................ 6 Tipos simples <xs:simpleType> ............................................................................................. 7

Restricciones ..................................................................................................................................................... 7 Listas ............................................................................................................................................................... 10 Uniones ............................................................................................................................................................ 11 Declaracin de los atributos de un elemento ................................................................................................... 12 Elementos con sub-elementos......................................................................................................................... 13 o Secuencia ordenada: la estructura <xs:sequence> ......................................................................................... 13 o Secuencia desordenada: la estructura <xs:all> ............................................................................................... 13 o Eleccin: la estructura <xs:choice> ................................................................................................................. 14 o Cualquier elemento: la estructura <xs:any> .................................................................................................... 15 Elementos con sub-elementos y texto ............................................................................................................. 15 Contenido simple y contenido complejo <xs:simpleContent> <xs:complexContent> ...................................... 15

Tipos complejos <xs:complexType> .................................................................................... 12

Grupos de elementos e atributos ................................................................................................................. 17

Grupos de elementos <xs:group> ........................................................................................ 17 Grupos de atributos <xs:attributeGroup> ............................................................................. 18

ANEXO: Patrones (pattern) ........................................................................................................................... 19

Schema.docx

XML Schema (XSD)

El XML Schema Definition Language (XSDL o XSD) es un lenguaje XML (recomendado por el W3C) creado para describir la estructura y restricciones del contenido de un documento XML. De la misma manera que los DTDs, sirven para validar documentos XML, pero mejorando todos los problemas que estos tenan. El hecho de que su lenguaje sea tambin XML hace que podamos utilizar las mismas herramientas que utilizamos para editar, representar o transformar el documento original.

Estructura y enlace con el XSD

Veremos a continuacin dos posibilidades para crear el documento que contiene el esquema, y su enlace con los documentos. Los dos documentos (.XML y .XSD) son XML, entonces hay que realizar una doble validacin: El documento .XML se valida en el esquema.xsd El documento .XSD se valida en un hipottico XMLSchema.xsd, puesto que el esquema tambin tiene que cumplir una sintaxis.

El documento XML no tiene su propio espacio de nombres

En este caso, simplemente indicamos en el esquema un nico espacio de nombres: el de sus propios elementos. Esto se debe a que los elementos y tipos de datos que usaremos para construir el esquema estn definidos en el espacio de nombres: http:/ /www.w3.org/2001/XMLSchema (al que nos referiremos con el prefijo xs:). (Aqu estn definidos los marcadores de xsd). ESQUEMA.XSD <?xml version="1.0" ... ?> <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"> ... definicin do esquema ... </xs:schema>

Como el documento XML no tiene su propio espacio de nombres, se enlazara a su esquema a travs del atributo xsi:noNamespaceSchemaLocation. Para tener acceso a este atributo, creamos anteriormente el prefijo xsi: (xml schema instance) que se refiere al espacio de nombres especificado en la etiqueta raz. DOCUMENTO.XML

Schema.docx

<?xml version="1.0" ... ?> <elementoRaz xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="esquema.xsd"> ... </elementoRaz>

Ejemplo: ESQUEMACURSOS.XSD <?xml version="1.0" ... ?> <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"> <xs:element name="cursosEmpresa" type="xs:string"/> . </xs:schema>

CURSOS.XML <?xml version="1.0" ... ?> <cursosEmpresa xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="EsquemaCursos.xsd"> . </cursosEmpresa>

El documento XML tiene su propio espacio de nombres

Si queremos que los elementos definidos en este esquema pertenezcan a un cierto espacio de nombres, que usaremos en los documentos (xml) validados por este esquema, entonces usaremos el atributo targetNamespace en la definicin del elemento raz. ESQUEMA.XSD <?xml version="1.0" ... ?> <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" targetNamespace="URIdelEspacioDeNombres"> ... definicin del esquema ... </xs:schema>

Y en el documento crearemos y utilizaremos en los elementos un prefijo para el espacio de nombres. DOCUMENTO.XML <?xml version="1.0" ... ?> <pref:elementoRaz xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:pref=" URIdelEspacioDeNombres " xsi:schemaLocation=" URIdelEspacioDeNombresesquema.xsd"> ... </pref:elementoRaz>

Schema.docx

Ejemplo:

ESQUEMACURSOS.XSD <?xml version="1.0"?> <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"> targetNamespace="http://www.xunta.es/cursos"> <xs:element name="cursosEmpresa" type="xs:string"/> </xs:schema>

CURSOS.XML <?xml version="1.0"?> <xg:cursosEmpresa xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xg="http://www.xunta.es/cursos" xsi:schemaLocation="http://www.xunta.es/cursos/EsquemaCursos.xsd"> ... </xg:cursosEmpresa>

Componentes principales de un esquema

Existen cuatro construcciones bsicas en las que se basa un esquema: Declaracin de elementos.- Sirve para asociar el nombre de un elemento a un tipo predefinido, a un tipo simple o a un tipo complejo. Declaracin de atributos.- Sirve para asociar el nombre de un atributo a un tipo simple (el valor de los atributos slo puede contener texto). Tipos simples.- Nos permiten definir nuevos tipos basados en los tipos simples predefinidos, aplicndoles ciertas restricciones. Su valor siempre es de tipo texto y no pueden contener elementos (marcas <>), ni atributos. Tipos complejos.- Sirven para definir nuevos tipos de datos cuyos valores constan de atributos y/o elementos (tambin pueden incluir texto en su contenido).

Tipos simples predefinidos A continuacin podemos ver algunos de los tipos incorporados (primitivos y derivados) ms utilizados. Categora texto nmeros Tipos xs:string, xs:anyURI, xs:normalizedString xs:byte, xs:decimal, xs:double, xs:float, xs:int, xs:integer, xs:long, xs:negativeInteger (<0), xs:nonNegativeInteger (>=0), xs:positiveInteger (>0), xs:nonPositiveInteger (<=0), xs:short, xs:unsignedByte, xs:unsignedInt, xs:unsignedLong, xs:unsignedShort xs:date, xs:dateTime, xs:duration, xs:gDay, xs:gMonth,

fecha/hora

Schema.docx

lgicos

xs:gMonthDay, xs:gYear, xs:gYearMonth, xs:time xs:boolean

Cuando especifiquemos un contenido deber seguir el formato adecuado al tipo de dato elegido. Por ejemplo, con un nmero real utilizaremos el punto como separador decimal, con una fecha utilizaremos el formato "AAAA-MM-DD", y con una hora utilizaremos el formato "hh:mm:ss". El tipo boolean permite introducir true o 1, y false o 0, indistintamente.

Declaracin de elementos La declaracin de un elemento XML utiliza, en la definicin del esquema, la etiqueta <xs:element ...>. Dependiendo de la utilizacin del elemento en el documento, se puede declarar de alguna de las siguientes maneras. Declaracin de elementos basados en un tipo predefinido Los elementos basados en un tipo simple predefinido slo pueden contener texto que cumpla las restricciones del tipo en el que se basa. No se permiten ni (sub)elementos ni atributos. <xs:element name="nombreElemento" type="tipoPredefinido" /> Ejemplo: La siguiente definicin: <xs:element name="nombreCurso" type="xs:string"/> <xs:element name="numeroAsistentes" type="xs:nonNegativeInteger"/> Permitira incluir en un documento los elementos: <nombreCurso>Programacin en C#</nombreCurso> <numeroAsistentes>15</numeroAsistentes> Basados en un Tipo Simple definido por el usuario Los elementos basados en un tipo simple slo pueden contener texto que cumpla las restricciones impuestas por el tipo simple definido por el usuario. No se permiten ni (sub)elementos ni atributos. Es igual que en el caso de los tipos predefinidos (que se consideran tipos simples), pero especificando a mayores las condiciones que deben cumplir los datos. La definicin del tipo simple se puede realizar en el interior de la declaracin del elemento, por lo que quedara oculta al resto del esquema: <xs:element name="nombreElemento"> <xs:simpleType> ... </xs:simpleType> </xs:element> o fuera, para poderla utilizar en varias declaraciones:

Schema.docx

<xs:simpleType name="nombreDelTipoSimple"> ... </xs:simpleType> <xs:element name="nombreElemento" type="nombreDelTipoSimple"/> Basados en un Tipo Complejo definido por el usuario Cuando un elemento contenga atributos y/o sub-elementos en su contenido, entonces ser necesario crear un tipo complejo. La declaracin de un elemento basado en un tipo complejo es exactamente igual a la de un tipo simple, cambiando <xs:simpleType> por <xs:complexType>. La diferencia es, evidentemente, la propia declaracin de estos tipos, que veremos ms adelante.

Declaracin de atributos En la declaracin de un elemento <xs:element ... > podemos especificar diversos atributos que nos permitirn configurarlo de manera adecuada: name: el nombre del elemento, el que se usar en los documentos XML encerrado entre los smbolos <>. type: el nombre del tipo de datos del contenido del elemento. (puede ser un tipo predefinido, un tipo simple o un tipo complejo). maxOccurs: nmero mximo de veces que el elemento puede aparecer dentro del elemento que a su vez lo contiene. Su valor debe ser de tipo nonNegativeInteger o bien la cadena unbounded para que no tenga lmite. Por defecto es 1. minOccurs: nmero mnimo de veces que el elemento debe aparecer dentro del elemento que a su vez lo contiene. Su valor debe ser de tipo nonNegativeInteger. Si especificamos el valor 0 se convierte en un elemento opcional. Por defecto es 1. default: es el valor predeterminado para el contenido del elemento, si no se le da valor en el documento (no compatible con fixed). fixed: su valor es automticamente asignado al contenido del elemento, sin poder cambiarse en el documento (no compatible con default). ref: su valor es el nombre de otro elemento definido en el esquema (o en otro esquema especificando su espacio de nombres). Si especificamos este atributo, la definicin del elemento (donde se pone ref) no puede contener adems los atributos default, fixed o type (entre otros), ni contener los elementos <simpleType> o <complexType>. Ejemplos del uso de estos atributos: <xs:element name="fechaDeNacimiento" type="xs:date" minOccurs="0"/> <xs:element name="linea" type="xs:string" maxOccurs="unbounded"/> <xs:element name="numeroDeCopias" type="xs:positiveInteger" default="1"/> <xs:element name=ejemplo ref="nombreDelElementoReferenciado" />

Schema.docx

Tipos simples <xs:simpleType>

Existen tres mecanismos para crear tipos simples basados en tipos simples predefinidos o a su vez en otros tipos simples: restricciones, listas y uniones.

Restricciones Al definir un tipo simple podemos especificar: el tipo de dato que se espera en el contenido de los elementos y los atributos, y tambin una gran variedad de restricciones que nos permiten leer con tranquilidad el documento sabiendo que todas esas condiciones fueron previamente validadas. Las restricciones siempre se aplican sobre un tipo existente (denominado tipo base), y permiten restringir el conjunto de sus posibles valores. Sintaxis: <xs:simpleType name="nombreDelTipoSimple"> <xs:restriction base="nombreDelTipoBase"> ... </xs:restriction> </xs:simpleType> Las posibles restricciones sobre un tipo base son: length: longitud de la cadena o nmero de elementos de la lista. minLength: longitud mnima. maxLength: longitud mxima. pattern: encajar con una expresin regular. (anexo) enumeration: los valores del tipo solo pueden ser los especificados. whiteSpace: controla la normalizacin de los espacios blancos (tabs, etc.). maxInclusive: valor superior incluido. maxExclusive: valor superior excluido. minInclusive: valor inferior incluido. minExclusive: valor inferior excluido. totalDigits: mximo nmero de dgitos (en los tipos numricos) fractionDigits: mximo nmero de dgitos decimales. Dependiendo del tipo base se podr aplicar un posible conjunto de restricciones. Por ejemplo: Restricciones sobre un tipo string son: length, minLength, maxLength, pattern, enumeration y whitespace. Restricciones sobre un tipo de datos integer son: totalDigits, pattern, whitespace, enumeration, maxInclusive, maxExclusive, minInclusive y minExclusive. Ejemplo1: Un nmero entero entre 1 y 10 ambos incluidos.

(Definiendo el tipo simple fuera de la declaracin del elemento)

<xs:simpleType name="tipoNota"> <xs:restriction base="xs:integer"> <xs:minInclusive value="1"/> <xs:maxInclusive value="10"/> </xs:restriction>

Schema.docx

</xs:simpleType> <xs:element name="nota1Ev" type="tipoNota" />

(Definiendo el tipo simple en el interior de la declaracin del elemento)

<xs:element name="nota1Ev"> <xs:simpleType> <xs:restriction base="xs:integer"> <xs:minInclusive value="1"/> <xs:maxInclusive value="10"/> </xs:restriction> </xs:simpleType> </xs:element> Ejemplo 2: El elemento nivel puede tener varios valores: baixo, medio y alto.

(Definiendo el tipo simple en el interior de la declaracin del elemento)

<xs:element name="nivel"> <xs:simpleType> <xs:restriction base="xs:string"> <xs:enumeration value="baixo"/> <xs:enumeration value="medio"/> <xs:enumeration value="alto"/> </xs:restriction> </xs:simpleType> </xs:element>

(Definiendo el tipo simple fuera de la declaracin del elemento)

<xs:element name="nivel" type="tipoDeNivel"/> <xs:simpleType name="tipoDeNivel"> <xs:restriction base="xs:string"> <xs:enumeration value="baixo"/> <xs:enumeration value="medio"/> <xs:enumeration value="alto"/> </xs:restriction> </xs:simpleType>

valores.xml <?xml version="1.0" encoding="UTF-8"?> <nivel xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="valores.xsd">medio</nivel> valores.xsd <?xml version="1.0" encoding="UTF-8"?> <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"> <xs:element name="nivel" type="tipoDeNivel"/> <xs:simpleType name="tipoDeNivel"> <xs:restriction base="xs:string"> <xs:enumeration value="baixo"/> <xs:enumeration value="medio"/> Schema.docx 8

<xs:enumeration value="alto"/> </xs:restriction> </xs:simpleType> </xs:schema>

Ejemplo 2: El elemento matrcula tiene 4 nmeros y 3 letras maysculas. <xs:element name="matricula"> <xs:simpleType> <xs:restriction base="xs:string"> <xs:pattern value="[0-9][0-9][0-9][0-9][A-Z][A-Z][A-Z]"/> </xs:restriction> </xs:simpleType> </xs:element> matricula.xml <?xml version="1.0" encoding="UTF-8"?> <matricula xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="matricula.xsd">2258ASD</matricula> matricula.xsd <?xml version="1.0" encoding="UTF-8"?> <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"> <xs:element name="matricula"> <xs:simpleType> <xs:restriction base="xs:string"> <xs:pattern value="[0-9][0-9][0-9][0-9][A-Z][A-Z][A-Z]"/> </xs:restriction> </xs:simpleType> </xs:element> </xs:schema> Tambin podra ser: <xs:pattern value="\d\d\d\d[A-Z][A-Z][A-Z]"/> O bien: <xs:pattern value="\d{4}[A-Z]{3}"/> Ejemplo 4: El codigo de cliente de 8 caracteres <xs:element name="codCliente"> <xs:simpleType> <xs:restriction base="xs:string"> <xs:length value="8"/><!-- exactamente 8 carcteres --> </xs:restriction> </xs:simpleType> </xs:element>

Ejemplo 5: El codigo de cliente de 8 caracteres que sean letras minsculas, maysculas y nmeros. <xs:element name="codCliente"> <xs:simpleType> <xs:restriction base="xs:string"> <xs:pattern value="[a-zA-Z0-9]{8}"/> </xs:restriction> </xs:simpleType> Schema.docx 9

</xs:element>

Ejemplo 6: nombre de usuario entre 6 y 15 caracteres. <xs:element name="nombreDeUsuario"> <xs:simpleType> <xs:restriction base="xs:string"> <xs:minLength value="6"/> <xs:maxLength value="15"/> </xs:restriction> </xs:simpleType> </xs:element> Listas Una lista consiste en una secuencia de valores de un cierto tipo, separada por espacios. Sintaxis: <xs:simpleType name="nombreDelTipoLista"> <xs:list itemType="tipoDeLosValores"/> </xs:simpleType>

Por ejemplo: <xs:simpleType name="tipoTemperaturas"> <xs:list itemType="xs:integer"/> </xs:simpleType> <xs:element name="temperaturas" type="tipoTemperaturas"/> Permitira el siguinte contenido en el documento XML: <temperaturas>9 13 15 21 17 12</temperaturas> Las listas no siempre son un buen recurso debido a que se pierden las ventajas del formato XML. Es mejor idea incrementar el nmero de marcas de la siguiente manera: <temperaturas> <temperatura>9</temperatura> <temperatura>13</temperatura> <temperatura>15</temperatura> <temperatura>21</temperatura> <temperatura>17</temperatura> <temperatura>12</temperatura> </temperaturas> (Se ver ms adelante)

Schema.docx

10

 Uniones Una unin es una estructura que nos permite unir en un nico tipo, valores con distintos tipos de datos. (Un valor puede ser del tipo1, o del tipo2, .) Sintaxis: <xs:simpleType name="nombreTipoUnion"> <xs:union> <xs:simpleType> ...</xs:simpleType> <xs:simpleType> ...</xs:simpleType> ... </xs:union> </xs:simpleType> o bien: <xs:simpleType name="nombreTipoUnion"> <xs:union memberTypes="tipo1 tipo2 ..." /> </xs:simpleType> Ejemplo: Una nota en la que podamos poner un nmero entre 1 y 10, o bien No presentado. Formato1: <xs:element name="nota" type="tipoNota"/> <xs:simpleType name="tipoNota"> <xs:union> <xs:simpleType> <xs:restriction base="xs:integer"> <xs:minInclusive value="1"/> <xs:maxInclusive value="10"/> </xs:restriction> </xs:simpleType> <xs:simpleType> <xs:restriction base="xs:string"> <xs:enumeration value="No presentado"/> </xs:restriction> </xs:simpleType> </xs:union> </xs:simpleType>

Formato2: <xs:element name="nota" type="tipoNota"/> <xs:simpleType name="tipoNota"> <xs:union memberTypes="notaNumero notaLetra" /> </xs:simpleType> <xs:simpleType name="notaNumero"> <xs:restriction base="xs:integer"> <xs:minInclusive value="1"/>

Schema.docx

11

<xs:maxInclusive value="10"/> </xs:restriction> </xs:simpleType> <xs:simpleType name="notaLetra"> <xs:restriction base="xs:string"> <xs:enumeration value="No presentado"/> </xs:restriction> </xs:simpleType>

Tipos complejos <xs:complexType> Son aquellos elementos XML que, adems de poder tener atributos, su contenido puede tener otros elementos y/o contenido textual. Sintaxis: <xs:complexType name="nombreDoTipoComplexo"> ... </xs:complexType> Declaracin de los atributos de un elemento En el caso de que un elemento tenga atributos, la declaracin de estos se realiza en el interior de la definicin del tipo complejo. Debido a que los atributos slo se pueden igualar a valores de tipo simple, su definicin se podr hacer de las siguientes maneras: <xs:complexType name="nombreTipo"> <xs:attribute name="nombreAtributo" type="tipoDoAtributo" [default="valorPorDefecto" | fixed="valorFijo"] [use="required"] /> </xs:complexType>

o bien: <xs:attribute name="nombreAtributo" [default="valorPorDefecto" | fixed="valorFijo"] [use="required"] > <xs:simpleType> <xs:restriction type="tipoSimple"> ... </xs:restriction> </xs:simpleType> </xs:attribute> El atributo use="required" obliga a introducir el atributo con su elemento, pues por defecto son opcionales (use="optional"). Ejemplo 1: <xs:complexType name="tipoPgina"> <xs:attribute name="numDeCopias" type="xs:positiveInteger" use="required"/> </xs:complexType>

Schema.docx

12

<xs:element name="pgina" type="tipoPgina"/> o bien: <xs:element name="pgina"> <xs:complexType> .. <xs:attribute name="numDeCopias" type="xs:positiveInteger" use="required"/> </xs:complexType> </xs:element> que permitira un documento XML con el siguiente elemento: <pgina numDeCopias="3"> ... </pgina> Exemplo 2: <xs:element name="cliente"> <xs:complexType> <xs:attribute name="idCliente" type="xs:integer"/> </xs:complexType> </xs:element> permitira un documento XML con el siguiente elemento: <cliente idCliente="255"/> Elementos con sub-elementos Un elemento puede contener a su vez otros elementos. Para especificar sus caractersticas podemos utilizar alguna de las siguientes estructuras: <xs:sequence>, <xs:all>, <xs:choice> y <xs:any>. (Aunque contenga un solo elemento hay que poner una de estas estructuras) o Secuencia ordenada: la estructura <xs:sequence> Todos los elementos que contenga la estructura tendrn que ir en el documento en el orden indicado. Ejemplo: Una persona con nombre, apellido1, apellido2 y correo (0 o varios) <xs:element name="persoa"> <xs:complexType> <xs:sequence> <xs:element name="nombre" type="xs:string"/> <xs:element name="apellido1" type="xs:string"/> <xs:element name="apellido2" type="xs:string"/> <xs:element name="correo" type="xs:string" minOccurs="0" maxOccurs="unbounded"/> </xs:sequence> </xs:complexType> </xs:element> o Secuencia desordenada: la estructura <xs:all> Similar al anterior pero donde todos los elementos que contenga la estructura tendrn que aparecer, aunque no importa el orden. A diferencia de la estructura anterior, los elementos deben aparecer como mximo una vez, es decir, el atributo minOccurs de los elementos slo puede estar a 0 o a 1 y maxOccurs slo puede estar a 1 (si se especifica).

Schema.docx

13

Ejemplo: Una persona con nombre, apellido1, apellido2 y correo (0 o 1 vez) y que aparezcan en cualquier orden. valores.xsd <?xml version="1.0" encoding="UTF-8"?> <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"> <xs:element name="persoa"> <xs:complexType> <xs:all> <xs:element name="nombre" type="xs:string"/> <xs:element name="apellido1" type="xs:string"/> <xs:element name="apellido2" type="xs:string"/> <xs:element name="correo" type="xs:string" minOccurs="0" /> </xs:all> </xs:complexType> </xs:element> </xs:schema> valores.xml <?xml version="1.0" encoding="UTF-8"?> <persoa xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="valores.xsd"> <apellido2>Prez</apellido2> <nombre>Pepe</nombre> <apellido1>Lpez</apellido1> </persoa> o Eleccin: la estructura <xs:choice> Se elige slo uno de los elementos indicados dentro de la estructura. Ejemplo: <xs:element name="persoa"> <xs:complexType> <xs:sequence> <xs:element name="nombre" type="xs:string"/> <xs:element name="apellido1" type="xs:string"/> <xs:element name="apellido2" type="xs:string"/> <xs:choice> <xs:element name="NIF" type="xs:string"/> <xs:element name="NumTarxetaResidencia" type="xs:string"/> </xs:choice> </xs:sequence> </xs:complexType> </xs:element> Valores vlidos: <nombre>pepe</nombre> <apellido1>Lpez</apellido1> <apellido2>Prez</apellido2> <NumTarxetaResidencia>33333</NumTarxetaResidencia> <nombre>pepe</nombre> Schema.docx 14

<apellido1>Lpez</apellido1> <apellido2>Prez</apellido2> <NIF>33333</NIF> o Cualquier elemento: la estructura <xs:any> La estructura <xs:any> permite que el esquema acepte en ese lugar cualquier elemento y su contenido. Elementos con sub-elementos y texto Son aquellos que, en su contenido, permiten mezclar texto libre junto con otros elementos. Se declara especificando el atributo mixed="true" de la etiqueta <xs:complexType>. Ejemplo: Mostramos a continuacin parte de un documento XML y su correspondiente esquema: <mensaxeErro> A pxina <sitioWeb>www.larompiente.com</sitioWeb>xerou o erro nmero <numErro>404</numErro>:<descErro>Pxina 'estadoDoMar.html' non atopada</descErro>s <hora>23:12:45</hora> </mensaxeErro> <xs:element name="mensaxeErro"> <xs:complexType mixed="true"> <xs:sequence> <xs:element name="sitioWeb" type="xs:string"/> <xs:element name="numErro" type="xs:integer"/> <xs:element name="descErro" type="xs:string"/> <xs:element name="hora" type="xs:time"/> </xs:sequence> </xs:complexType> </xs:element> Contenido simple y contenido complejo <xs:simpleContent> <xs:complexContent> Dependiendo del contenido de un elemento de tipo complexo, podemos describirlos usando dos tipos de contenidos: simple y complejo. Adems nos sirve para crear nuevos tipos complejos derivando de tipos existentes, facilitando la reusabilidad. contenido simple (<xs:simpleContent>): texto y atributos, sin elementos. contenido complejo (<xs:complexContent [mixed=true]>): texto, elementos y atributos

Por defecto, si no se especifica el tipo de contenido en un tipo complejo (complexType), se asume contenido complejo (complexContent).

Schema.docx

15

En el interior del contenido (simple o complejo) indicaremos si queremos extender o restringir el tipo base. Para eso utilizaremos las siguientes etiquetas: <xs:restriction base="tipoBaseRestrinxido"> <xs:extension base="tipoBaseExtendido"> Ejemplo 1: Elemento no vaco con atributos. <distancia unidad="cm">75</distancia> (Nos llega un simpleContent.) Necesitara un esquema como el siguiente: <xs:element name="distancia" type="distanciaConUnidades"/> <xs:complexType name="distanciaConUnidades"> <xs:simpleContent> <xs:extension base="xs:integer"> <xs:attribute name="unidad" type="xs:string" /> </xs:extension> </xs:simpleContent> </xs:complexType> Ejemplo 2: <!-- Tipo de datos llamado peces, un string que slo puede tomar esos tres valores--> <!--simpleType: no tiene ni subelementos, ni atributos, slo restriction--> <xs:simpleType name="peces"> <xs:restriction base="xs:string"> <xs:enumeration value="robaliza"/> <xs:enumeration value="sargo"/> <xs:enumeration value="trucha"/> <xs:enumeration value="salmn"/> </xs:restriction> </xs:simpleType> <!-- Tipo de datos llamado pezCapturado: aadimos al tipo peces un atributo:peso tipo decimal obligatorio--> <!--complexType: tiene atributos --> <!--simpleContent: no tiene subelementos, tiene atributos --> <xs:complexType name="pezCapturado"> <xs:simpleContent> <xs:extension base="peces"> <xs:attribute name="peso" type="xs:decimal" use="required"/> </xs:extension> </xs:simpleContent> </xs:complexType> <!-- Tipo de datos llamado capturasDeRo: son de tipo pezCapturado, pero slo pueden ser los valores trucha y salmn--> <xs:complexType name="capturasDeRo"> <xs:simpleContent> <xs:restriction base="pezCapturado" > <xs:enumeration value="trucha"/> <xs:enumeration value="salmn"/> </xs:restriction> </xs:simpleContent> </xs:complexType>

Schema.docx

16

<xs:element name="pez" type="peces"/> <xs:element name="pez" type="pezCapturado"/> <xs:element name="pez" type="capturasDeRo"/>

<pez>robaliza</pez> <pez peso="20">robaliza</pez> <pez peso="20">trucha</pez>

Ejemplo 3: Creamos un tipo direccin con calle y poblacin. Creamos otro tipo direccionEspaa al que le aadimos codPostal y provincia. <xs:complexType name="direccion"> <xs:sequence> <xs:element name="calle" type="xs:string"/> <xs:element name="poblacion" type="xs:string"/> </xs:sequence> </xs:complexType>

<!--complexContent: tiene subelementos -->

<xs:complexType name="direccionEspaa"> <xs:complexContent> <xs:extension base="direccion"> <xs:sequence> <xs:element name="codigoPostal" type="xs:string"/> <xs:element name="provincia" type="xs:string"/> </xs:sequence> </xs:extension> </xs:complexContent> </xs:complexType>

<xs:element name="dir" type="direccion"/>

<xs:element name="dir" type="direccionEspaa"/>

<dir> <calle>mayor</calle> <poblacion>lugo</poblacion> </dir> <dir> <calle>mayor</calle> <poblacion>lugo</poblacion> <codigoPostal>15000</codigoPostal> <provincia>lugo</provincia> </dir>

Grupos de elementos e atributos

Grupos de elementos <xs:group> Permiten agrupar elementos con <xs:group> para utilizarlos posteriormente en otros elementos. Sintaxis: Para crear el grupo: <xs:group name="nombreGrupo" />

Schema.docx

17

Para referenciar el grupo creado antes: <xs:group ref="nombreGrupo"/> Ejemplo: <!-- grupo: nombreCompleto formado por nombre y apellidos --> <xs:group name="nombreCompleto"> <xs:sequence> <xs:element name="nombre" type="xs:string"/> <xs:element name="apellidos" type="xs:string"/> </xs:sequence> </xs:group> <!-- grupo: direccion formado por calle, numero y piso --> <xs:group name="direccion"> <xs:sequence> <xs:element name="calle" type="xs:string"/> <xs:element name="numero" type="xs:integer"/> <xs:element name="piso" type="xs:string"/> </xs:sequence> </xs:group> <!-- tipo: tipoPersona formado por nombreCompleto(nombre direccin(calle, numero y piso) y provincia. --> <xs:complexType name="tipoPersona"> <xs:sequence> <xs:group ref="nombreCompleto"/> <xs:group ref="direccion"/> <xs:element name="provincia" type="xs:string"/> </xs:sequence> </xs:complexType> <xs:element name="persona" type="tipoPersona"/> Grupos de atributos <xs:attributeGroup> Permiten agrupar atributos con <xs:attributeGroup> para utilizarlos posteriormente en otros elementos. Sintaxis: Para crear el grupo: <xs: attributeGroup name="nombreGrupo" /> Para referenciar el grupo creado antes: <xs: attributeGroup ref="nombreGrupo"/> Ejemplo:
<xs:attributeGroup name="atributosPersona"> <xs:attribute name="nome" type="xs:string"/> <xs:attribute name="apelidos" type="xs:string"/> <xs:attribute name="dataNacemento" type="xs:date"/> </xs:attributeGroup> <xs:element name="persona"> <xs:complexType>

apellidos),

Schema.docx

18

<xs:attributeGroup ref="atributosPersona"/> </xs:complexType> </xs:element>

ANEXO: Patrones (pattern)

http://www.infosintesis.net/portal/apendice/expresionesRegulares/sintaxis/index.html

Gua de referencia y sintaxis de las expresiones regulares Las expresiones regulares se utilizan para buscar, editar o manipular texto. La siguiente tabla muestra la sintaxis de las expresiones regulares.
Expresin
Capitulo\d Apndice\D Capitulo\s\d Apndice\s\w a *x a ?x a +x

Coincidencias
Capitulo0, Capitulo1, Capitulo2 .... ApndiceA, ApndiceB, ApndiceC ... Capitulo 0, Capitulo 1, Capitulo 2 .... Apndice A, Apndice B, Apndice C ... x, ax, aax, aaax .... ax, x ax, aax, aaax .... ax, bx, aax, abx, bax, bbx, aaax, aabx, abax, abbx, baax, babx, bbax, bbbx ... ax, bx, cx, dx, ex ax, bx, cx, dx, ex -x, ax, ex ax, ex, -x ax, Bx ... ax, Bx ... ax, Bx, 2x... 1x2abc, abc1x2, z3456abchooray .... abbx abbx, abbbx, abbbbx abbx, abbbx, abbbbx .... ababx

Significado
\d representa cualquier dgito, es decir 0, 1, 2, 3, 4 , 5, 6, 7, 8, 9 \D representa cualquier valor no dgito \s representa espacio en blanco, retorno de carro, nueva lnea o intro \w representa a cualquier carcter * indica que el carcter al que sigue puede aparecer cero, una, o ms veces ? indica que el carcter al que sigue puede aparecer como mucho una vez + indica que el carcter al que sigue debe aparecer al menos una vez (|) cualquier combinacin de los caracteres incluidos en el grupo [abcde] slo un carcter de la lista [a-e] slo un carcter en el intervalos de la a hasta la e [-ae] slo un carcter de la lista [ae-] slo un carcter de la lista [^0-9]cualquier carcter no-dgito \D cualquier carcter no-dgito . cualquier carcter .* caulquier carcter puede aparecer cero, una, o ms veces {n} el valor anterior se repite n veces {n,m} por lo menos n veces pero no mas de m veces {n,} por lo menos n veces (ab){n} el grupo ab aparece n veces

(a|b)+x [abcde]x [a -e ]x [-ae]x [ae-]x [^0-9]x \Dx .x .*abc.*

ab{2}x ab{2,4}x ab{2,}x

(ab){2}x

Ejemplos: Restringir el texto de un nmero de telfono con este aspecto 93 209-58-45 en un XML Schema. <xs:element name="numeroTelefono"> <xs:simpleType> <xs:restriction base="xsd:string"> <xs:pattern value="\d{2}\s\d{3}-\d{2}-\d{2}"/> </xs:restriction> </xs:simpleType> </xs:element>

Schema.docx

19