sintaxis de los “xml schema”

SINTAXIS DE LOS
“XML SCHEMA”
Introducción
Qué es XML Schema:
–
es un conjunto de reglas que sirve para forzar la estructura y las restricciones de los contenidos de
los documentos XML de una forma muy precisa
–
es un documento XML con un vocabulario especializado
Ventajas con respecto a los documentos DTD :
– se basa en XML y no en una sintaxis especializada
– puede ser analizado sintácticamente y manipulado como cualquier otro documento XML
– se pueden combinar distintos esquemas fácilmente
– soporta más tipos de datos que tienen una analogía directa con lenguajes de programación y
Bases de Datos (string, int, float, boolean, date, ...)
– en los DTD no se puede forzar el orden y la cantidad de elementos hijos
– soporta integración con los espacios de nombres (Name Space)
–
ESPACIOS DE NOMBRES : permiten escribir esquemas y validar documentos que usan elementos
y atributos de múltiples vocabularios XML. Se utilizan los espacios de nombres para evitar
conflictos entre nombres de elementos o nombres de atributos con igual nombre, pero significado
distinto.
ESTRUCTURA DE UN ESQUEMA (1)
titulo.xsd
<?xml version="1.0" encoding="UTF-8"?>
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema“ elementFormDefault="qualified">
<xsd:element name=“TITULO” type=“xsd:String”/>
</xsd:schema>
****************************************************
<xsd:schema>
–
este elemento se utiliza como elemento raíz del documento y actúa como contenedor del resto del contenido
del esquema
xmlns:xsd
–
todos los elementos en el esquema tienen el prefijo “xsd:”, el cual está asociado al espacio de nombre del
XML Schema a través de la declaración “xmlns:xsd”
–
Atributo elementFormDefaut:
“qualified”: los elementos de un documento XML instancia de un esquema deberán ir todos
precedidos de un prefijo del namespace (a menos que haya namespace por defecto)
“unqualified”: sólo llevará prefijo el elemento raíz, y los elementos hijo lo herederán (salvo que se les
indique expresamente otro prefijo)
–
Atributo attributeFormDefault:
“unqualified”: en los atributos no hace falta indicar un prefijo (salvo que difiera del del elemento en el
que se encuadran), ya que su namespace será el mismo del elemento.
“qualified”: en los atributos se debe incluir siempre el prefijo del namespace.
los prefijos xsd: o xs: son usados por convención para denotar el espacio de nombre del XML Schema, aunque
cualquier otro prefijo podría ser usado
ESTRUCTURA DE UN ESQUEMA (2)
Definir un namespace por defecto para un elemento nos evita tener que usar prefijos en todos los
elementos hijo. La sintaxis es: <xmlns="namespaceURI">.
Hay dos formas distintas de declarar espacios de nombres:
–
declaración explícita
se declara con un prefijo, y todos los nombres de elementos y atributos que estén
asociados con el espacio de nombre deberán utilizar el prefijo como parte de sus
nombres cualificados
resultan útiles cuando se quiere crear un documento que se apoya en múltiples
espacios de nombre
–
declaración predeterminada (namespace por defecto)
se declara sin un prefijo, y se hace referencia a todos los nombres de atributos y
elementos que haya en su ámbito con nombres no cualificados, y se presupone que
estos se encuentran en el espacio de nombre
Los prefijos no tienen que coincidir en el Schema en y los documentos instancia, sólo tienen que
coincidir los espacios de nombres a los que se refieren. De hecho, uno podría usar prefijos y el
otro podría usar el espacio de nombres por defecto.
Sólo los elementos del nivel más alto de un esquema pueden ser los elementos raíz de los
documentos instancia de un esquema, aunque en general no tienen por qué ser el elemento raíz.
DECLARACION DE UN ESQUEMA
Hay
dos maneras de declarar un esquema en un documento XML instancia de un esquema:
A) Si se quiere que los elementos del documentos instancia referencien a un único esquema
<?xml version="1.0"?>
<TITULO xsi:noNamespaceSchemaLocation=“http://igae.pap.meh.es/xml/titulo.xsd"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
CURSO XML
</TITULO>
B) Si se quiere que los elementos del documento instancia puedan referenciar a uno o varios espacios de nombres
<?xml version="1.0"?>
<TITULO xmlns=“http://igae.pap.meh.es/xml/titulo "
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance“
xsi:schemaLocation=“http://igae.pap.meh.es/xml/titulo http://igae.pap.meh.es/xml/titulo.xsd”
>
CURSO XML
</TITULO>
El elemento raíz sólo puede tener un atributo “xsi:schemaLocation”, y por tanto si hubiera varios espacios de nombres en el esquema, en ese atributo se
recogerían todas las parejas URI_del espacio_de_nombre / URL (los dos componentes de la pareja se separan con un espacio en blanco, al igual que las
parejas).
En el caso B, es necesario que el fichero .xsd del esquema defina un espacio de nombre destino mediante targetnamespace
<?xml version="1.0" encoding="UTF-8"?>
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema“
xmlns= “http://igae.pap.meh.es/xml/titulo “
targetNamespace= “http://igae.pap.meh.es/xml/titulo”
elementFormDefault="qualified">
•
El atributo targetNamespace (que es una URI) permite especificar el espacio de nombres para el cual un esquema define componentes.
Hay que declarar en el esquema un espacio de nombres igual que el valor del atributo targetNamespace del esquema, con o sin prefijo, según se quiera o no
anteponer éste a los tag de xml.
•
COMPOSICION DE ESQUEMAS
Si la mayoría de la información que se necesita en un esquema ya está contenida en otro fichero XSD, no
tiene sentido duplicarla en el resto de ficheros que la usen, ya que además se producirían problemas
cuando haya que modificar una parte de un esquema que se repita en otros.
Para importar un fichero de esquema XSD en otro fichero se utiliza el elemento <include>, si ambos
ficheros tienen el mismo espacio de nombres de destino :
<include schemaLocation=“ficheroejemplo.xsd“/>
Para importar un fichero de esquema XSD, con un espacio de nombres de destino diferente, en otro
fichero XSD, se usa el elemento <import>:
<import namespace=“espacio_de_nombres" schemaLocation=“URI_del_esquema_XSD"/>
El atributo namespace es opcional. Indica que el documento de esquema contenedor puede contener
referencias completas a los componentes del esquema en el espacio de nombres (a través de uno o
varios prefijos declarados con atributos xmlns).
Si falta este atributo, el esquema en el que está contenido puede incluir referencias sin cualificar a
componentes del espacio de nombres importado.
TIPOS DE ELEMENTOS
DECLARACION DE UN ELEMENTO :
<xsd:element name="nombreElemento"
type="tipoSimple/tipoCompuesto"
minOccurs="valor"
maxOccurs="valor"/>
El valor por defecto de minOccurs y maxOccurs es “1”
Tipos simples y tipos complejos
–
tipos complejos :
pueden contener elementos, atributos y texto
– los elementos se declaran utilizando el elemento <xsd:element>
– los atributos se declaran utilizando el elemento <xsd:attribute>
se definen utilizando el elemento <xsd:complexType>
– este elemento puede tener los siguientes subelementos
<xsd:sequence>, <xsd:choice>, <xsd:all>
–
tipos simples :
no contienen elementos ni atributos
– sólo contienen texto
estos son algunos de los tipos simples más comunes
– xsd:string, xsd:integer, xsd:positiveInteger, xsd:int, xsd:long, xsd:short,
xsd:decimal, xsd:float, xsd:double, xsd:boolean, xsd:time, xsd:date, ...
ELEMENTOS GLOBALES (1)
Para facilitar la legibilidad de los XML Schemas y reutilizar definiciones de otros esquemas, nos puede ser
útil crear un elemento global, y hacer referencias al mismo.
Los elementos globales son elementos que son hijos inmediatos del elemento “schema”. Los elementos
locales son elementos anidados dentro de otros elementos.
Un elemento global :
–
tiene que estar declarado como un subelemento del elemento <xsd:schema>, pero nunca como
parte de un elemento de tipo complejo
–
no puede contener referencias
es decir no pueden albergar el atributo ref
–
no pude indicar el número de ocurrencias que tiene que aparecer un elemento
Esta es la sintaxis de una declaración local que hace referencia a un elemento global
<xsd:element ref="nombreElementoGlobalYaExistente" minOccurs="valor">
el atributo ref hace referencia a un elemento global (que puede estar definido en otro fichero xsd, al que
se referencia mediante un espacio de nombres)
en la declaración local, si queremos podemos indicar la cardinalidad del elemento global con los atributos
minOccurs y maxOccurs
ELEMENTOS GLOBALES (2)
EJEMPLO
SIN REFERENCIAS A ELEMENTOS GLOBALES:
<?xml version="1.0" encoding="UTF-8"?>
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema“
targetNamespace=“http://igae.meh.es/cancion”
elementFormDefault="qualified">
<xsd:element name=“CANCION” type=“Tipocancion”/>
<xsd:complexType name=“Tipocancion”>
<xsd:sequence>
<xsd:element name=“NOMBRE” type=“xsd:string”>
<xsd:element name=“AUTOR” type=“xsd:string”>
</xsd:sequence>
</xsd:complexType>
</xsd:schema>
Ahora vamos a definir otro esquema que agregará a sus elementos y atributos locales otros procedentes del esquema
“http://igae.meh.es/cancion”. Esto se hace mediante un elemento xsd:import
EJEMPLO
CON REFERENCIAS A ELEMENTOS GLOBALES:
<?xml version="1.0" encoding="UTF-8"?>
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema“
xmlns:cc=“http://igae.meh.es/cancion” elementFormDefault="qualified">
<xsd:import namespace=“http://igae.meh.es/cancion” schemaLocation=" http://igae.meh.es/cancion.xsd" />
<xsd:element name=“DISCO">
<xsd:complexType>
<xsd:sequence>
<xsd:element ref=“cc:CANCION” maxoccurs=“unbounded”/>
<element name=“EDITORIAL” type=“xsd:string”/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
</xsd:schema>
TIPOS DE DATOS SIMPLES
NUMERICOS
xsd:float
Número en coma flotante de 32 bits
xsd:double
Número en coma flotante de 64 bits
xsd:decimal
Números decimales de precisión arbitraria
xsd:integer
Entero arbitrariamente grande o pequeño
xsd:nonPositiveInteger
Entero menor o igual que cero
xsd:negativeInteger
Entero estrictamente menor que cero
xsd:long
Entero de 8 bytes en complemento a dos
xsd:int
Entero de 4 bytes en complemento a dos
xsd:short
Entero de 2 bytes en complemento a dos
xsd:byte
Entero de 1 byte en complemento a dos
xsd:nonNegativeInteger
Entero mayor o igual que cero
xsd:positiveInteger
Entero estrictamente mayor que cero
xsd:unsignedLong
Entero sin signo de ocho bytes
xsd:unsignedInt
Entero sin signo de cuatro bytes
xsd:unsignedShort
Entero sin signo de dos bytes
xsd:unsignedByte
Entero sin signo de un byte
TIPOS DE DATOS SIMPLES (2)
TEMPORALES
xsd:DateTime
Un momento específico en Coordinated
Universal Time hasta una fracción
arbitrariamente pequeña de segundo
xsd:date
Un día específico en la historia
xsd:time
Un momento específico del día que se repite
cada día
xsd:gDay
Un día de cada mes, o de ningún mes
concreto
xsd:gMonth
Un mes en ningún año concreto
xsd:gYear
Un año concreto
xsd:gYearMonth
Un mes concreto de un año específico
Xsd:gMonthDay
Un día de ningún año concreto, o de cada año
xsd:duration
Duración de un intervalo de tiempo sin
extremos fijos, hasta una fracción arbitraria de
un segundo
TIPOS DE DATOS SIMPLES (3)
TIPOS DE DATOS XML (1)
xsd:ID
atributo que es único entre los atributos de tipo ID y
elementos
xsd:IDREF
Tipo atributo. Cualquier nombre XML que se usa como
valor de un atributo o elemento de tipo ID situado en
cualquier otro lugar del documento
xsd:ENTITY
Atributo con una entidad no parseada. Permiten incluir
contenido no-XML en un documento XML. Las
ENTIDADES resultan muy útiles para repetir información
o bloques grandes de texto que pueden estar guardados
en archivos separados.
xsd:NOTATION
Tipo atributo. definición de una notación para describir el
formato de datos no XML dentro de un documento XML
(ef: GIF, jpeg, pdf, etc)
xsd:IDREFS
Tipo atributo. Lista de nombres separados por comas
que se usan como valores de un atributo o elemento de
tipo ID situado en cualquier otro lugar del documento
xsd:ENTITIES
Tipo atributo. Lista de nombres tipo ENTITY separados
por comas
xsd:NMTOKEN
Atributo Cadena de caracteres. Sólo puede contener
letras, dígitos, punto [ . ], guión [ - ], subrayado [ _ ] y dos
puntos [ : ]
xsd:NMTOKENS
Atributo Cadena de caracteres. Mismos caracteres que
NMTOKEN más espacio en blanco.
TIPOS DE DATOS SIMPLES (4)
TIPOS DE DATOS XML (2)
xsd:language
Nombre válidos de idiomas según xml_lang (en, en-GB, en-US, fr, sp, etc)
xsd:Name
Un nombre XML, que puede contener “:” (pero no se le da a este carácter
ningún significado). Se puede usar como un nombre de tipo de elemento o
nombre de atributo. El tipo de caracteres que permite coincide con
NMTOKEN.
xsd:QName
Un nombre con prefijo. Ej: song:title
xsd:NCName
Un nombre local sin ningún carácter “:”
TIPOS DE DATOS SIMPLES (5)
CADENA
xsd:string
Una secuencia de cero o más caracteres Unicode
permitidos en documentos XML
NOTA -> no se permiten en XML los caracteres:
",',&,<,>, á,é, í,ó,ú,ñ,Á,É,Í,Ó,Ú,Ñ
xsd:normalizedString
Una cadena que no contiene tabuladores, ni retornos de
carro, ni saltos de línea
xsd:token
Una cadena sin espacios en blanco iniciales ni finales, sin
tabuladores, sin saltos de línea, y sin más de un espacio en
blanco consecutivo
BINARIO
xsd:hexBinary
Codifica cada byte de la entrada como dos dígitos
hexadecimales (usa sólo los dígitos 0-9 y las letras A-F)
xsd:base64Binary
Utiliza un conjunto de caracteres más amplio (65 caracteres
ASCII), que pasan a través de todos los gateways, relays de
correo y servidores de terminales. Base64 codifica cada 3 bytes
en 4 caracteres.
TIPOS DE DATOS SIMPLES (6)
URI
xsd:anyURI
Representa una referencia URI(Uniform Resource Identifier).
Las URIs se usan para identificar recursos, y pueden ser
absolutas o relativas. Las URIs Relativas se especifican como
la diferencia respecto a una URI de base, tal como :
../prod.html.
También es posible especificar un identificador de fragmento,
usando el carácter #, tal como : ../prod.html#shirt.
ELEMENTOS COMPLEJOS
El
elemento <xsd:sequence>
Utilizamos este elemento para indicar que la secuencia de elementos anidados tienen que aparecer en el documento
XML y con el mismo orden.
Este es un ejemplo :
<xsd:element name="camiseta">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="color" type="xsd:string"/>
<xsd:element name="talla" type="xsd:string"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element name="camiseta">
El
elemento <xsd:choice>
Este elemento es muy útil cuando tenemos una lista de elementos y queremos que en el documento XML aparezca
solamente uno de ellos
Este es un ejemplo :
<xsd:element name="vehiculoMotor">
<xsd:complexType>
<xsd:choice>
<xsd:element name="coche" type="xsd:string"/>
<xsd:element name="moto" type="xsd:string"/>
<xsd:element name="fugoneta" type="xsd:string"/>
<xsd:element name="camion" type="xsd:string"/>
</xsd:choice>
</xsd:complexType>
</xsd:element name=“vehiculoMotor">
ELEMENTOS COMPLEJOS (2)
El elemento <xsd:all>
Se comporta igual que el elemento <xsd:sequence>, pero no es obligado que la secuencia de elementos anidados
aparezcan en el documento XML con el mismo orden.
Este es un ejemplo :
<xsd:element name="camiseta">
<xsd:complexType>
<xsd:all>
<xsd:element name="color" type="xsd:string"/>
<xsd:element name="talla" type="xsd:string"/>
</xsd:all>
</xsd:complexType>
</xsd:element name="camiseta">
ELEMENTOS COMPLEJOS (3)
ATRIBUTOS (I)
Esta es la declaración de un atributo
<xsd:attribute name="nombreAtributo"
type="tipoSimple"
use="valor"
default="valor"
fixed="valor"/>
type
–
los atributos sólo pueden contener tipos simples
use (Opcional)
–
conjunto de valores de use
required
–
el atributo debe aparecer en el documento XML
optional (valor por defecto)
–
el atributo puede aparecer o no aparecer en el documento XML
prohibited
–
el atributo no debe aparecer en el documento XML
default (Opcional)
–
si el atributo no aparece en el documento instanciado, el parser del esquema se encarga de ofrecer el valor contenido en
el atributo default
–
los valores por defecto sólo se permiten si el atributo es opcional
fixed (Opcional)
–
si el valor del atributo está presente en la instancia del documento XML, el valor debe ser el mismo que el que indica el
atributo fixed
–
si el atributo no está presente en el documento XML, el parser del esquema ofrecerá el valor contenido en el atributo
fixed
–
los valores de los atributos default y fixed son mutuamente exclusivos
por lo tanto habrá un error si una declaración contiene ambos
ELEMENTOS COMPLEJOS (4)
ATRIBUTOS (II)
Un elemento con atributos tiene por definición un tipo complejo. Los elementos xsd:attribute deben venir después
del grupo xsd:sequence, xsd:choice o xsd:all que forma el cuerpo de un elemento.
<xsd:complextype name=“Tipopersona">
<xsd:sequence>
<xsd:element name=“Nombre">
<xsd:complexType>
<xsd:all>
<xsd:element name=“Nombre de pila" type="xsd:string"/>
<xsd:element name=“Apellido" type="xsd:string"/>
</xsd:all>
</xsd:complexType>
</xsd:element>
</xsd:sequence>
<xsd:attribute name="ID" type="xsd:ID"/>
</xsd:complexType>
ELEMENTOS COMPLEJOS (5)
ATRIBUTOS (III)
Para añadir atributos a elementos que contienen sólo texto, se genera un nuevo tipo complejo a
partir de uno simple, dándole al elemento xsd:complexType un elemento hijo xsd:simpleContent
en vez de un elemento xsd:sequence, xsd:choice o xsd:all.
El elemento xsd:simpleContent tiene un elemento hijo xsd:extension, cuyo atributo base identifica el tipo
simple a extender (como xsd:string). Los atributos xsd:attribute se sitúan dentro del elemento
xsd:extension.
<xsd:complexType name=“CadenaConID">
<xsd:simpleContent>
<xsd:extension base="xsd:string">
<xsd:attribute name="ID" type="xsd:ID"/>
</xsd:extension>
</xsd:simpleContent>
</xsd:complexType>
ELEMENTOS COMPLEJOS (6)
CONTENIDO MIXTO
Permite introducir en un elemento compuesto texto extra que no pertenezca a sus elementos hijo.
Se configura mediante atributo Mixed=“true” en los elementos complexType del esquema
Ej:
<xsd:element name=“COMPOSITOR">
<xsd:complexType mixed=“true”>
<xsd:all>
<xsd:element name=“NOMBRE" type="xsd:string"/>
<xsd:element name=“APELLIDO" type="xsd:string"/>
</xsd:all>
</xsd:complexType>
</xsd:element name=“COMPOSITOR">
En este caso, en un documento instancia del esquema podría figurar (el texto extra es “Sr”) :
…
<COMPOSITOR> Sr.
<NOMBRE> Antonio </NOMBRE>
<APELLIDO> Vivaldi </APELLIDO>
</COMPOSITOR>
…
ELEMENTOS GRUPO
El elemento grupo se usa para definir un grupo de elementos que pueden reutilizarse en varias
definiciones de tipos complejos.
<?xml version="1.0"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:group name="custGroup">
<xs:sequence>
<xs:element name="customer" type="xs:string"/>
<xs:element name="orderdetails" type="xs:string"/>
<xs:element name="billto" type="xs:string"/>
<xs:element name="shipto" type="xs:string"/>
</xs:sequence>
</xs:group>
<xs:element name="order" type="ordertype"/>
<xs:complexType name="ordertype">
<xs:group ref="custGroup"/>
<xs:attribute name="status" type="xs:string"/>
</xs:complexType>
</xs:schema>
En un documento XML instancia de un esquema, no se pueden definir elementos que sean de un tipo
correspondiente al group del esquema, sino que tienen que ser de un tipo elemento complejo que incluya
en su interior al grupo en cuestión.
También existen grupos de atributos, que se definirían mediante xs:attributegroup, de manera análoga
RESTRICCIONES EN TIPOS SIMPLES
<xsd:restriction base="tipoSimple">
propiedades
</xsd:restricion>
PROPIEDADES
–
para limitar valores numéricos :
<xsd:minExclusive>, <xsd:minInclusive>, <xsd:maxExclusive>, <xsd:maxInclusive>
–
para limitar la longitud de una string :
<xsd:length>, <xsd:minLength>, <xsd:maxLength>
–
para limitar un tipo simple a un conjunto acotado de valores
<xsd:enumeration>
–
para aplicar expresiones regulares :
<xsd:pattern>
Ejemplo : <xsd:pattern value=“\p{Sc}\p{Nd}+(\.\p{Nd}\p{Nd})?”>
Símbolo monetario + uno o más digitos + parte opcional compuesta de : punto y dos decimales
Ejemplo propiedades <xsd:minInclusive> y <xsd:maxInclusive>
De esta forma por ejemplo se puede restringir un tipo simple que se basará en un integer que queremos que tenga un
rango entre 28 y 210
<xsd:simpleType name="miInteger">
<xsd:restriction base="xsd:integer">
<xsd:minInclusive value=“28"/>
<xsd:maxInclusive value=“210"/>
</xsd:restriction>
</xsd:simpleType>
RESTRICCIONES TIPOS SIMPLES (2)
La propiedad <xsd:enumeration> se utiliza para restringir el valor de casi todos los tipos simples. Esta propiedad limita
un tipo simple a un conjunto acotado de valores. En este ejemplo el elemento diasDeLaSemana está restringido a los 7
días de la semana :
<xsd:element name="diasDeLaSemana">
<xsd:simpleType>
<xsd:restriction base="xsd:string">
<xsd:enumeration value="lunes"/>
<xsd:enumeration value="martes"/>
<xsd:enumeration value="miércoles"/>
<!-- y así sucesivamente ... -->
</xsd:restriction>
<xsd:simpleType>
</xsd:simpleType>
Definiciones
de tipos anónimos
Un tipo anónimo es útil cuando se quiere usar un tipo solamente una vez, y no se quieren crear muchos elementos
diferentes con el mismo tipo. Se evita la sobrecarga de tener que nombrarlo y referenciarlo explícitamente.
Para
crear una definición de tipo anónimo, simplemente se incrusta un elemento <xsd:simpleType> o
<xsd:complexType> dentro de una declaración de elemento <xsd:element>. No hay que nombrar el tipo ni asignar un
valor explícito al atributo type de <xsd:element>.
Además, permite dar a elementos con el mismo nombre diferentes tipos cuando se usan en diferentes elementos. Por
ejemplo, puedes decir que el NOMBRE de una PERSONA contiene elementos hijos NOMBRE DE PILA y FAMILIA,
mientras que el NOMBRE de una PELICULA contiene un xsd:string, y el NOMBRE de una VARIABLE contiene una
cadena que posee sólo caracteres alfanuméricos del conjunto de caracteres ASCII.
También permiten evitar que determinados tipos de elementos puedan ser hijos de cualquier otro elemento, sino
únicamente de aquellos dentro de los cuales se definan.
EJEMPLO CON TIPOS ANONIMOS
<?xml version="1.0“ encoding='ISO-8859-1' ?>
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<xsd:element name=“CANCION" type=“TipoCancion"/>
<xsd:complexType name="TipoPersona">
<xsd:sequence>
<xsd:element name="NOMBRE">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="NOMBRE DE PILA" type="xsd:string"/>
<xsd:element name="FAMILIA" type="xsd:string"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
</xsd:sequence>
</xsd:complexType>
<xsd:complexType name="TipoCancion">
<xsd:sequence>
<xsd:element name="TITULO" type="xsd:string"/>
<xsd:element name="COMPOSITOR" type="TipoPersona"
maxOccurs="unbounded"/>
<xsd:element name="PRODUCTOR" type="TipoPersona"
minOccurs="0" maxOccurs="unbounded"/>
<xsd:element name="EDITORIAL" type="xsd:string"
minOccurs="0"/>
<xsd:element name="DURACION" type="xsd:string"/>
<xsd:element name="ARTISTA" type="xsd:string"
maxOccurs="unbounded"/>
</xsd:sequence>
</xsd:complexType>
</xsd:schema>
HERENCIA: EXTENSION DE
ELEMENTOS
Un elemento de tipo complejo se puede extender, ya sea añadiéndole atributos (como vimos
anteriormente), o bien incluyendo nuevos elementos dentro del tipo extendido :
<?xml version="1.0"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:element name="employee" type=“infopersonacompleta"/>
<xs:complexType name="infopersona">
<xs:sequence>
<xs:element name="nombre" type="xs:string"/>
<xs:element name=“apellido" type="xs:string"/>
</xs:sequence>
</xs:complexType>
<xs:complexType name="infopersonacompleta">
<xs:complexContent>
<xs:extension base="infopersona">
<xs:sequence>
<xs:element name=“direccion" type="xs:string"/>
<xs:element name="ciudad" type="xs:string"/>
<xs:element name=“provincia" type="xs:string"/>
</xs:sequence>
</xs:extension>
</xs:complexContent>
</xs:complexType>
</xs:schema>
FACETAS
Además de las restricciones anteriores de los tipos simples, existen otras “facetas” o propiedades :
–
xsd:totalDigits : el número máximo de dígitos permitidos en un elemento numérico
–
xsd:fractionDigits : el número máximo de dígitos permitidos en la parte decimal
–
xsd:whitespace : especifica el tratamiento de los espacios en blanco. Se aplica a elementos de
tipo xsd:string, xsd:normalizedString y xsd:token. Esta faceta tiene tres posibles valores :
preserve : los espacios en blanco del documento se mantienen
replace : cada tabulador, retorno de carro y salto de línea se reemplaza con un solo espacio.
collapse: cada tabulador, retorno de carro y salto de línea se reemplaza con un solo espacio. Una vez hecho
esto, todas las series de múltiples espacios se condensan en uno solo. Se borran los espacios en blanco iniciales
y finales.
LISTAS
El elemento <xsd:list> define un elemento de tipo simple como una lista de valores de un tipo
especificado.
El siguiente ejemplo muestra un tipo simple que es una lista de enteros :
<?xml version="1.0"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:element name=“valoresenteros" type="listavalores“/>
<xs:simpleType name=“listavalores">
<xs:list itemType="xs:integer"/>
</xs:simpleType>
</xs:schema>
El elemento "valoresenteros" en un documento podría tener este aspecto (observar que la lista tendrá 5 items):
<valoresenteros>100 34 56 -23 1567</valoresenteros>
NOTA: el espacio en blanco se trata como separador de los elementos de la lista.
COMENTARIOS A LOS ESQUEMAS
Además de los comentarios XML, que comienzan por la cadena "<!--" y terminan con "-->“, XML Schema
también proporciona un mecanismo más formal para comentar esquemas.
Todos los elementos de un esquema pueden contener elementos hijo xsd:annotation que describan esa
parte del esquema para lectores humanos o programas de ordenador. Este elemento tiene dos tipos de
hijos :
–
El elemento hijo <xsd:documentation> describe el esquema para lectores humanos.
–
El elemento hijo <xsd:appInfo source=cualquierURL> describe información sobre el esquema para
ser usada por programas de ordenador. Por ejemplo, puede contener instrucciones sobre qué hojas
de estilo aplicar al esquema.
Por ejemplo, el siguiente comentario podría añadirse al esquema de canción visto anteriormente :
<xsd:annotation>
<xsd:documentation>
Esquema de Cancion para el Curso de XML Schema
Copyright 2011 Blancanieves
</xsd:documentation>
</xsd:annotation>
REFERENCIAS CRUZADAS
Se puede utilizar el lenguaje de vínculos XML XLink para crear enlaces entre elementos y archivos (por ejemplo imágenes)
situados en Internet u otras redes.
Por ejemplo, se podría definir dentro de un esquema el tipo de dato “TipoFoto” que emplea XLink:
<xsd:element name=“FOTO” type=“TipoFoto”>
<xsd:complexType name=“TipoFoto">
<xsd:attribute name=“ANCHURA" type="xsd:positiveInteger"
use="required" />
<xsd:attribute name=“ALTURA" type="xsd:positiveInteger"
use="required" />
<xsd:attribute name="ALT" type="xsd:string"
use="required" />
<xsd:attribute ref="xlink:type"/>
<xsd:attribute ref="xlink:href" use="required"/>
<xsd:attribute ref="xlink:actuate"/>
<xsd:attribute ref="xlink:show"/>
</xsd:complexType>
(Habiendo incluido en el elemento xsd:schema la definición del espacio de nombres xmlns:xlink=“http://www.w3.org/1999/xlink”)
REFERENCIAS CRUZADAS (2)
En el documento instancia del esquema XML en el que se ha definido el tipo de dato “TipoFoto” puede figurar el siguiente
elemento :
<FOTO xlink:type=“simple” xlink:href=“disfrazpolicia.jpg” xlink:show=“embed” xlink:actuate=“onLoad”
ALT=“Jose Garcia en disfraz de policia verano 2008”
ANCHURA=“100” ALTURA=“200”/>
xlink:type="simple" crea un enlace simple unidireccional entre dos puntos (“de aquí a allí”)
xlink:href define la URL a la que se enlaza.
xlink:show -> Con este atributo podemos describir cómo se verá el resultado del hecho de seguir el enlace
–
new: se abre una nueva ventana y se muestra la URI enlazada
–
replace: muestra el recurso en la ventana actual, sustituyendo el documento
–
embed: incrusta el recurso enlazado en el documento actual, en la ubicación del elemento enlace.
–
none: no se proporcionan detalles
xlink:actuate -> define cuándo se lee y se muestra el recurso enlazado
–
onLoad: se debería seguir el enlace en cuanto lo ve la aplicación
–
onRequest: se debería seguir el enlace cuando lo pide el usuario
–
none: no se proporcionan detalles