Upload
posets
View
84
Download
2
Embed Size (px)
DESCRIPTION
explicación sobre XML Schema
Citation preview
Curso: XML, de los datos a la presentaciónJulio de 2005
CAPTIVA · www.captiva.es
Modelos de documento (Schema)
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=“tipo-contenido">
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)
Tipo Descripción
string Cadena unicode
normalizedString 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
Algunos tipos básicos
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=“tipo-simple"> 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-schema-tipobasico.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 tipo-basico2">
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
Ejercicio: Abrir carta.xml y validar. Después cambiar en xsd mixedContent=“false” y repetir.
<?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>
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 carta-partida-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-include-schema.xsd" Allá se define "tipocarta" </xs:documentation> </xs:annotation> <xs:include schemaLocation="carta-partida-include-schema.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/TypeLibrary.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
<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>
<personaje> <nombre>Mortadelo</nombre> <amigo-de>Filemón Pi</amigo-de> <rasgos>camaleónico</rasgos></personaje>
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 xs:string que “colapsa” espacios
tipoNombreCarta Derivada de tipoCadena con valores: “As”, “Dos”, … ”Rey”
tipoPalo “oros”, “copas”, “espadas”, “bastos”
tipoDNI Copiar de ejemplo
tipoJuego “brisca”, “tute”, “poker”, “mus”
tipoMoneda “€”, “$”
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
Contenido: Simple de tipo “tipoNombreCarta” Atributos: “palo” de tipo “tipoPalo”
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: 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…)