xs:string - Saregune
Download
Report
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…)