Transcript xs:string - Saregune

Modelos de documento (Schema)
Curso: XML, de los datos a la presentación
Julio de 2005
CAPTIVA · www.captiva.es
Introducción

XML Schema





Descripción formal de un documento XML en XML
El más utilizado  W3C XML Schema
Otros  Relax NG, Schematron
Un XML documento que cumple con schema 
instancia
Métodos para asociar instancia a schema



Atributo xsi:schemaLocation lista de namespaces y
schema para cada uno
Atributo xsi:noNamespaceSchemaLocation schema
para elementos sin namespace
Otros  prefijándoselo al parser, etc.
Introducción (II)

Schema vs DTD





Tipos de datos simples y complejos (en DTD  PCDATA)
para contenido y atributos
Derivación y herencia de tipos
Declaración de elementos y atributos sensibles al namespace
Schema no dispone de ENTITIES  Más sencillo en DTD.
Alternativa Xinclude
Namespaces



Especificación posterior a XML 1.0  No soportado por DTDs
Uso  Reutilización de nombres para diferentes contextos.
P.e. <nombre>Kiko</nombre>  Nombre de persona, equipo,
etc.
Los schemas combinan nombre con namespace
Principios

Ejemplo de XML (direccion.xml):
<?xml version="1.0"?>
<nombre
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="direccion-schema.xsd">
Don Pimpón
</nombre>

Ejemplo de Schema (direccion-schema.xsd):
<?xml version="1.0"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:element name=“nombre“ type="xs:string"/>
</xs:schema>

Significado:


El documento contiene elemento <nombre> y admite contenido de tipo
xs:string (xs  namespace del propio schema).
noNamespaceSchemaLocation  No hemos definido un namespace para
nombre. Requiere hacer referencia al ns que lo define
Principios (II)

Cómo validamos nuestros ejemplos:



Editores  Jedit, Cooktop
Validadores  MSV (MultiSchemaValidator), XSV
Organización del documento



Elemento raíz  <xs:schema>
Hijo de elemento raíz  Definición de elementos raíz para instancias XML
Anotaciones


Elementos orientados a documentación del schema  <xs:annotation>
A su vez <xs:annotation> contiene  <xs:documentation> (hombres) ó
<xs:appinfo> (máquinas, p.e. ayuda contextual)

Ejemplo
<xs:annotation>
<xs:documentation xml:lang=“es-es">
Ejemplo de XML schema para <a
href=“http://www.captiva.es/cursoxml/”> curso XML </a>
(c) 2005 Captiva Soluciones y Seguridad S.L.
</xs:documentation>
</xs:annotation>
Principios (III)

Declaración de elementos

Formato
<xs:element name=“nombre-elemento" type=“tipocontenido">

Tipos de contenidos
 Simples  Tipos predefinidos
 Complejos  Tipos definidos por el usuario
<xs:element name=“nombre-elemento">
<xs:complexType>
<!-- Definición del tipo complejo -->
</xs:complexType>
</xs:element>
Principios (IV)
Algunos tipos básicos
Tipo
string
normalizedString
Descripción
Cadena unicode
Cadena con tabuladores y cambios de linea normalizados a espacios
token
Igual que anterior pero con multiples espacios substituidos por uno único
y eliminados los iniciales y finales
Name
Nombre XML
language
Mismo valor que atributo xml:lang. P.e.: en, es-es
anyURI
URI
boolean
true | false | 0 | 1
byte
127 <= Entero >= -128
integer
Número entero positivo o negativo
decimal
Numero flotante de precisión arbitraria
base64Binary
Datos binarios codificados Base64
dateTime
Fecha y hora
duration
Cantidad de tiempo relativa en años, días, meses, etc.
ID, IDREF, IDREFS, ENTITY, ENTITIES,
NOTATION, NMTOKEN, NMTOKENS
Igual que XML DTD 1.0
Principios (V)

Declaración de atributos



Siempre son tipos básicos  no pueden contener elementos
Pega  Un elemento de tipo básico no puede tener atributos
Se declaran mediante: <xs:attribute>


Posible definir atributos “globales” o locales a la definición de “complexType” de un
elemento
Ejemplo
<xs:element name=“nombre">
<xs:complexType>
<xs:simpleContent>
<xs:extension base="xs:string">
<xs:attribute name="language" type="xs:language"/>
</xs:extension>
</xs:simpleContent>
</xs:complexType>
</xs:element>
Principios (VI)

Grupos de atributos




DTDs  Parameter entities
Definición de un xs:attributeGroup global identificado por id único name
Dentro del complex type se hace referencia al attributeGroup
Ejemplo:
<xs:attributeGroup name=“idioma">
<xs:attribute name=“language” type=“xs:lang”/>
</xs:attributeGroup>
...
<xs:element name=“nombre">
<xs:complexType>
<xs:simpleContent>
<xs:extension base="xs:string">
<xs:attributeGroup ref=“idioma"/>
</xs:extension>
</xs:simpleContent>
</xs:complexType>
</xs:element>
Namespaces

Un namespace se identifica con una URL



Por abreviar se suele asignar un prefijo  Hace referencia a
elementos de ese namespace
El prefijo no identifica el namespace, es la URL
¿Cómo se asocia un Schema con un namespace?

Declaración tipica
<xs:schema
xmlns:xs="http://www.w3.org/2001/XMLSchema"
targetNamespace=“http://www.captiva.es”
xmlns=“http://www.captiva.es”>

xmlns:xs = …  Este documento usa namespace de
XMLSchema (http://.../XMLSchema) y se usará el prefijo xs

targetNamespace = …  Los elementos definidos en
este schema pertenecen al namespace “http://www.captiva.es”

xmlns = …  Identifica el namespace por defecto.
Namespaces (II)

¿Cómo se asocia una instancia con un namespace?

Declaración tipica
<nombre
xmlns:xsi="http://www.w3.org/2001/XMLSchema“
xsi:schemaLocation=“http://www.captiva.es
direccion.xsd”
xmlns=“http://www.captiva.es”
elementFormDefault="qualified" >Yo mismo
</nombre>

xmlns:xsi = …  XMLSchema en sí es una instancia XML. La
hacemos accesible a través de prefijo “xsi”

xsi:schemaLocation = “schema fich-schema.xsd” 
Token list con el schema a utilizar (debe coincidir con targetSchema)
y fichero que contiene la def del schema

xmlns = …  Identifica el namespace por defecto.

elementFormDefault = “qualified” -> Los nombres simpre
son cualificados  Evita errores
Tipos Complejos

Tipos complejos


Sólo para elementos
Definición de nuevos tipos


xs:complexType
Alternativas

Declaración global (fuera definición de cualquier elemento)



Se puede referenciar a través de atributo name
Declaración dentro de definición de elementos
Ejemplo:
<identificacion>
<nombre>Fulano<nombre>
<apellido1>de Tal</apellido1>
<apellido2>y Cual</apellido2>
</identificacion>
<xs:element name=“identificacion”>
<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:sequence>
</xs:complexType>
</xs:element>
Tipos Complejos (II)

Restricción de ocurrencias


Equivalente a modificadores de DTDs (+ * ?)
Parámetros minOccurs y maxOccurs de xs:element

Ejemplo:


<xs:element name=“apellido2” type=“xs:string”
minOccurs=“0”/>
Alternativas para contenido de un elemento




Vacío
Contenido simple
Contenido mixto
Cualquier tipo
Elementos vacíos

Elemento vacío


<elemento /> ó <elemento></elemento>
Ejemplo de elemento vacío  <xhtml:img
src=“”/>


Tipo complejo sin más elementos anidados
Ejemplo definición de elemento img:
<xs:element name=“img“>
<xs:complexType>
<xs:attribute name=“src“ type="xs:anyURI"/>
</xs:complexType>
</xs:element>
Elementos con contenido
simple

Se especifican con modificador

<xs:simpleContent/>

Se permite definir tipos simples derivados de los que
incorpora Schema  <xs:extension base=“tiposimple">

Declaramos un tipo complejo con contenido simple y lo
usamos para definir el elemento “nombre” con atributo “dni”:
<xs:element name=“nombre”>
<xs:complexType>
<xs:simpleContent>
<xs:extension base=“xs:string”/>
<xs:attribute name=“dni” type=“xs:ID”>
<xs:extension base=“xs:string”/>
</xs:complexType>
</xs:element>
</xs:element>
Elementos con contenido
simple (II)

Defininición de tipos simples

En vez de definir tipo complejo con contenido simple podemos
definir tipo simple

Ej:
<xs:simpleType name=“tipoMatricula">
<xs:restriction base="xs:string"/>
</xs:simpleType>

Facetas


Son posibles valores para los tipos simples
Para ello se emplean restricciones de valores xs:restriction
<xs:restriction base=“tipo-simple”>
<xs:nombre-faceta value=“valor-faceta”/>
</xs:restriction>
Tipos simples: Facetas

Lista de posibles facetas








length (o minLength y maxLength)
pattern
enumeration
whiteSpace
maxInclusive y maxExclusive
minInclusive y minExclusive
totalDigits
fractionDigits
Tipos simples: Facetas (II)

Espaciado



Antes de “parsear” el dato se normalizan los
espacios
Con whiteSpace podemos determinar cómo se
normalizan
Posibles valores:



preserve  Deja todos los espacios intactos
replace  Substituye \t \r \n por espacio (#x20)
collapse  Hace replace y luego substituye multiples
espacios por uno sólo
Tipos simples: Facetas (III)

Longitud

Tres alternativas:




length  Fija longitud exacta permitida
minLength  Fija longitud mínima
maxLength  Fija longitud máxima
Ejemplo
<xs:simpleType name=“tipoNombre">
<xs:restriction base="xs:string">
<xs:minLength value=“3"/>
<xs:maxLength value=“15"/>
</xs:restriction>
</xs:simpleType>

Ejemplo  direccion-tipobasico.xml y direccion-schematipobasico.xsd
Tipos simples: Facetas (IV)

Enumeraciones

Lista de valores válidos (DTD  (a | b | c) )
<xs:simpleType name=“tipoMoneda">
<xs:restriction base="xs:string">
<xs:enumeration value=“cara"/>
<xs:enumeration value=“cruz"/>
</xs:restriction>
</xs:simpleType>
Tipos simples: Facetas (V)

Restricciones numéricas


•
Rangos: minInclusive (<=) , minExclusive (<),
maxInclusive (>=), maxExclusive (>)
Control de valores decimales: totalDigits,
fractionDigits
Ejemplo restricción decimal a XXX.XX
<xs:simpleType name=“tipoPrecio">
<xs:restriction base="xs:decimal">
<xs:totalDigits value=“5"/>
<xs:fractionDigits value=“2"/>
</xs:restriction>
</xs:simpleType>
Tipos simples: Facetas (VI)

Formato específico de cadenas


Se utiliza <xs:pattern> para especificar el patrón que ha se seguir
la cadena
Algunos ejemplos de patrones:







[a-z]  Letras de la ‘a’ a la ‘z’
\d  Dígito numérico
\D  Cualquier carácter que no sea un dígito
.  Cualquier carácter excepto CR LF
\s  Espacio, tabulador o CR o LF
Más información: http://www.w3.org/TR/xmlschema-2/#regexs
Ejemplo definición tipo DNI:
<xs:simpleType name=“tipoDNI">
<xs:restriction base="xs:string">
<xs:pattern
value=“\d\d\d\d\d\d\d\d[TRWAGMYFPDXBNJZSQVHLCKEF]"/>
</xs:restriction>
</xs:simpleType>
Tipos simples: Facetas (VII)

Listas


Lista de elementos de tipo básico separados por
espacios
Sintaxis:
<xs:list itemType=“tipo-basico">



Atención: No va dentro de restriction.
Se pueden aplicar restricciones que se aplican a
todos los elementos
Ejemplo lista de DNIs:
<xs:simpleType name=“tipoListaDNI">
<xs:list itemType=“tipoDNI">
</xs:simpleType>
Tipos simples: Facetas (VIII)

Uniones


Alternativa entre varios tipos posibles
Sintaxis:
<xs:union memberTypes=“tipo-basico1 tipobasico2">


Atención: No va dentro de restriction
Ejemplo:
<xs:simpleType name=“textoOentero">
<xs:union memberTypes=“xs:integer
xs:string">
</xs:simpleType>
Elementos con contenido
mixto


Contenido mixto  Texto y elementos
DTD  Número ilimitado de combinación texto
elementos
<!ELEMENT raiz (hijo | #PCDATA)*>

Schema


Además control del número y secuencia de elementos
mezclados con texto
¿Cómo se permite contenido mixto?
<xs:element name=“detodounpoco">
<xs:complexType mixed="true">
<!-- Definicion del tipo -->
</xs:complexType>
</xs:element>
Elementos con contenido
mixto (II)

Mezclado de texto con secuencia de
elementos

Ejemplo:
carta.xml y carta-schema.xsd
<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
targetNamespace="http://www.captiva.es"
xmlns="http://www.captiva.es"
elementFormDefault="qualified">
<!-- Definicion de elementos -->
<xs:element name="carta">
<xs:complexType mixed="true">
<xs:sequence>
<xs:element name="saludo" type="xs:string"/>
<xs:element name="cuerpo" type="xs:string"/>
<xs:element name="despedida" type="xs:string"/>
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:schema>

Ejercicio: Abrir carta.xml y validar. Después cambiar
en xsd mixedContent=“false” y repetir.
Elementos con contenido
mixto (II)

Mezclado de texto con elementos alternativos

En vez de mezclar con <xs:sequence> utilizamos
<xs:choice>

Ejemplo
<xs:element name=“saludo”>
<xs:complexType mixed="true">
<xs:choice>
<xs:element name="hola"/>
<xs:element name=“estimado"/>
<xs:element name=“querido"/>
</xs:choice>
</xs:complexType>
</xs:element>
Elementos con contenido
mixto (III)

Mezclado de texto con secuencias desordenadas



Se utiliza la construcción <xs:all>
Implica que todos los elementos han de estar presentes pero en cualquier
orden
Ejemplo
<xs:element name=“pedido”>
<xs:complexType mixed="true">
<xs:all>
<xs:element name=“fruta"/>
<xs:element name=“hortaliza"/>
<xs:element name=“legumbre"/>
</xs:all>
</xs:complexType>
</xs:element>

Fragmento XML que es válido de acuerdo al schema
<pedido>Puedes traerme 3 kg de
<legumbre>alubias</legumbre>, unos 5 kg de
<hortaliza>pimientos</hortaliza> y quizá también
8 kg de <fruta>naranjas</fruta>
</pedido>
Elementos con contenido
mixto (IV)

Una vuelta más de tuerca: Agrupaciones


Utlizando la construcción <xs:group> podemos combinar <xs:sequence> <xs:choice> y
<xs:all>
Ejemplo
<xs:element name=“menu”>
<xs:complexType mixed="true">
<xs:group>
<xs:all>
<xs:element name=“canapes"/>
<xs:element name=“ibericos"/>
<xs:element name=“pate"/>
</xs:all>
<xs:sequence>
<xs:element name=“carne"/>
<xs:element name=“pescado"/>
<xs:element name=“marisco"/>
</xs:sequence>
<xs:choice>
<xs:element name=“tarta"/>
<xs:element name=“helado"/>
</xs:choice>
</xs:group>
</xs:complexType>
</xs:element>
Cualquier contenido

Cualquier elemento, incluso de schemas externos


Sintaxis: <xs:any>  Cualquier elemento
Ejemplo podemos incluir texto XHTML dentro de nuestro doc. XML:
<xs:element name=“textoXHTML" minOccurs="0">
<xs:complexType>
<xs:sequence>
<xs:any
namespace="http://www.w3.org/1999/xhtml“
minOccurs="0" maxOccurs="unbounded“
processContents="skip"/>
</xs:sequence>
</xs:complexType>
</xs:element>
Cualquier contenido (II)

Inclusión de declaraciones en ficheros externos




Sintaxis: <xs:include schemaLocation=“otro-schema.xsd”>
El fichero incluido no es un fragmento es un schema completo
Para utlizar elementos definidos externamente  Utilizar correctamente
namespaces
Ejemplos:


carta-partida.xml se valida contra carta-partida-schema.xsd que incluye cartapartida-include-schema.xsd , donde se define el tipo tipoCarta
carta-partida-schema.xsd
<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
targetNamespace="http://www.captiva.es"
xmlns="http://www.captiva.es"
elementFormDefault="qualified">
<xs:annotation>
<xs:documentation>
Incluimos de "carta-partida-includeschema.xsd"
Allá se define "tipocarta"
</xs:documentation>
</xs:annotation>
<xs:include schemaLocation="carta-partida-includeschema.xsd"/>
<xs:element name="carta" type="tipoCarta"/>
</xs:schema>
Cualquier contenido (III)

Inclusión de definiciones de otros namespaces

Para ello utilizamos namespace
<xs:import
namespace="http://www.w3.org/2001/03/XMLSchema/TypeLibrary"
schemaLocation="http://www.w3.org/2001/03/XMLSchema/TypeLibrar
y.xsd"/>

Redefinición de tipos de otros schemas



Se utiliza <xs:redefine schemaLocation=anyURI>
Funciona como <xs:include> pero adicionalmente permite redefinir tipos
Ejemplo, redefinimos tipoCarta (secuencia con saludo, cuerpo, despedida):
<xs:redefine schemaLocation=“carta-partida-include-schema.xsd">
<xs:complexType name=“tipoCarta">
<xs:complexContent>
<xs:extension base=“tipoCarta">
<xs:sequence>
<xs:element name=“firma"/>
</xs:sequence>
</xs:extension>
</xs:complexContent>
</xs:complexType>
</xs:redefine>
Derivación de tipos complejos

Alternativas para derivar tipos complejos

Por extensión  <xs:extension>


Equivale a añadir contenidos a los contenidos de la declaración
base
Ej. Añadimos código postal a tipoDireccionFisica para formar el
nuevo tipo tipoDireccionPostal
<xs:complexType name=“tipoDireccionPostal">
<xs:complexContent>
<xs:extension base=“tipoDireccionFisica">
<xs:sequence>
<xs:element name=“CP“ type="xs:string"/>
</xs:sequence>
</xs:extension>
</xs:complexContent>
</xs:complexType>
Derivación de tipos complejos

Alternativas para derivar tipos complejos (II)

Por restricción  <xs:restriction>



Si el tipo derivado es subtipo del original
Con tipos simples es sencilla su utilización (facets)
Con tipos complejos hay que volver a definir el tipo base
eliminando los elementos o atributos que deseamos restringir
<xs:complexType nombre=“tipoNombreCompleto”>
<xs:sequence>
<xs:element name=“nombre” type=“xs:string”/>
<xs:element name=“apellido1” type=“xs:string”/>
<xs:element name=“apellido2” type=“xs:string”/>
</xs:sequence>
</xs:complexType>
<xs:complexType nombre=“tipoNombreCorto”>
<xs:complexContent>
<xs:restriction base=“tipoNombreCompleto”/>
<xs:sequence>
<xs:element name=“nombre” type=“xs:string”/>
<xs:element name=“apellido1” type=“xs:string”/>
</xs:sequence>
</xs:restriction>
</xs:complexContent>
</xs:complexType>
Derivación de tipos complejos
(II)

Polimorfismo




Característica interesante de tipos derivados
Permite instanciar objetos derivados como si fueran hijos.
El atributo xsi:type permite especificar a qué tipo derivado
conforma una instancia.
Ejemplo:
<nombreCompleto
xmlns:xsi"http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.captiva.es nombre.xsd“
xmlns=http://www.captiva.es
xsi:type=“tipoNombreCorto”>
<nombre>Pedro</nombre>
<apellido1>Ruiz</apellido1>
</nombreCompleto>
Derivación de tipos complejos
(III)

Grupos de substitución


Mediante el atributo substitutionGroup de
<xs:element> podemos crear formas de llamar
al mismo elemento con otro nombre.
Ejemplo trozo schema:
<xs:element name=“calle” type=“xs:string”/>
<xs:element name=“Strasse” substitutionGroup=“calle”/>

Serían igualmente válidos:
<calle>Madrid 43</calle>
<Strasse>Berlin 34</Strasse>
Control sobre derivación

Elementos y tipos abstractos


Si atributo abstract=true en definición de elemento o tipo
 No puede instanciarse el mismo
Atributo final

Si atributo final de complexType puede tener los valores
#all, extension, restriction para restringir la
derivación.

P.e.: <xs:complextType name=“nombre” final=“extension”>


Evita que se derive por extension este tipo
Facetas fijas


Algunas facetas admiten atributo fixed=“true”
Evita que futuras derivaciones anulen la restricción impuesta
por ella
<xs:maxInclusive fixed="true" value="100">
Control sobre derivación (II)

Valores únicos


El elemento xs:unique permite definir valores únicos para elementos y
atributos.
Funcionamiento




Se utiliza una expresión xpath para coger subcojunto del documento 
xs:selector
Se utiliza otra expresión xpath para seleccionar el campo determinado dentro de
subgrupo  xs:field
Si dos campos son iguales se genera un error
Ejemplo. Vamos a limitar en “contactos” contactos con mismo nombre:
<xs:complexType name=“tipoContactos”>
<element “contacto” type=“tipoNombreCompleto” maxOccurs=10/>
</xs:complexType>
<xs:element name=“contactos" type=“tipoContactos">
<xs:unique name=“nombre">
<xs:selector xpath=“contactos"/>
<xs:field xpath=“nombre"/>
</xs:unique>
</xs:element>
Control sobre derivación (III)

Claves


Igual que xs:unique pero no pueden ser nulas y se crean con
xs:key
Referencias


Con xs:keyref puede referenciarse una clave definida
previamente
Ejemplo:


Definimos clave única nombre del personaje
Definimos campo “amigo-de” que debe apuntar a un nombre de
personaje
<personaje>
<nombre>Mortadelo</nombre>
<amigo-de>Filemón Pi</amigo-de>
<rasgos>camaleónico</rasgos>
</personaje>
<xs:key name=“nomPersonaje”>
<xs:selector xpath=“personaje”/>
<xs:field xpath=“nombre”/>
</xs:key>
<xs:keyref name=“nomPersonajeRef”
refer=“nomPersonaje”>
<xs:selector xpath=“personaje”/>
<xs:field xpath=“amigo-de”/>
</xs:key>
Ejemplo: articulo

Articulo-schema.xsd (1/3):
<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
elementFormDefault="qualified">
<!-- RaÃz -->
<xs:element name="articulo">
<xs:complexType>
<xs:sequence>
<xs:element name="titulo"/>
<xs:element name="subtitulo"
minOccurs="0"/>
<xs:element name="autor" minOccurs="0"
maxOccurs="unbounded"/>
<xs:choice minOccurs="0"
maxOccurs="unbounded">
<xs:element name="parrafo"/>
<xs:element name="lista"/>
</xs:choice>
<xs:element name="bibliografia"
minOccurs="0"/>
</xs:sequence>
</xs:complexType>
</xs:element>
Ejemplo: articulo (II)

Articulo-schema.xsd (2/3):
<xs:element name="autor" type="xs:string"/>
<xs:element name="bibliografia">
<xs:complexType>
<xs:sequence>
<xs:element name="recurso"
minOccurs="0" maxOccurs="unbounded"/>
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:element name="itemlista" type="xs:string"/>
<xs:element name="lista">
<xs:complexType>
<xs:sequence>
<xs:element name="itemlista"
minOccurs="0" maxOccurs="unbounded"/>
</xs:sequence>
<xs:attribute name="tipo" use="required">
<xs:simpleType>
<xs:restriction
base="xs:string">
<xs:enumeration
value="numerada"/>
<xs:enumeration
value="nonumerada"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
</xs:complexType>
</xs:element>
Ejemplo: articulo (II)

Articulo-schema.xsd (3/3):
<xs:element name="parrafo">
<xs:complexType mixed="true">
<xs:sequence minOccurs="0"
maxOccurs="unbounded">
<xs:element name="referencia"/>
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:element name="recurso">
<xs:complexType mixed="true">
<xs:simpleContent>
<xs:extension base="xs:string">
<xs:attribute name="id"
type="xs:ID" use="required"/>
</xs:extension>
</xs:simpleContent>
</xs:complexType>
</xs:element>
<xs:element name="referencia">
<xs:complexType mixed="true">
<xs:simpleContent>
<xs:extension base="xs:string">
<xs:attribute name="idref"
type="xs:IDREF" use="required"/>
</xs:extension>
</xs:simpleContent>
</xs:complexType>
</xs:element>
<xs:element name="subtitulo" type="xs:string"/>
<xs:element name="titulo" type="xs:string"/>
</xs:schema>
Ejercicio (1/3)

Partir de casino.xml de 2º capítulo y modificarlo ligeramente

Añadir un elemento a cada jugador (detrás de las cartas):
<apuesta moneda=“€”>
12.23
</apuesta>


Añadir al elemento “jugador” un atributo “dni” con el formato visto en los
ejemplos
Crear un XML Schema que permita verificar el fichero casino.xml.



Para crearlo ir definiendo primero tipos simples y luego tipos complejos
De tal forma que no sea necesario definir tipos complejos dentro de
elementos
La última línea del fichero ha de ser de la forma:
<xs:element name=“casino” type=“tipoCasino”/>
Ejercicio (2/3)

Tipos simples a ir definiendo en orden:

tipoCadena


tipoNombreCarta


“brisca”, “tute”, “poker”, “mus”
tipoMoneda


Copiar de ejemplo
tipoJuego


“oros”, “copas”, “espadas”, “bastos”
tipoDNI


Derivada de tipoCadena con valores: “As”, “Dos”, … ”Rey”
tipoPalo


xs:string que “colapsa” espacios
“€”, “$”
tipoValorDinero

Decimal con 2 números decimales máximo
Ejercicio (3/3)

Tipos complejos (Nota  Todos los atributos han de tener atributo
use=“required”)

tipoCarta



tipoDinero



Contenido: Simple de tipo “tipoValorDinero”
Atributos: “moneda” de tipo “tipoMoneda”
tipoJugador



Contenido: Secuencia de “nombre”, “carta” (1-10), “apuesta”
Atributos: “dni” de tipo “tipoDNI”
tipoMesa



Contenido: Secuencia de “jugador” (2-infinito)
Atributos: “juego” de tipo “tipoJuego”
tipoCasino



Contenido: Simple de tipo “tipoNombreCarta”
Atributos: “palo” de tipo “tipoPalo”
Contenido: Secuencia de “bienvenida”, ”mesa” (1-infinito)
Restricciones: El atributo “dni” de cada jugador es una clave única 
xs:key
Hacer pruebas sobre casino.xml (poner apuestas sin tipo de moneda, poner
formato incorrecto en campos, repetir DNIs, etc…)