Capítulo 2: Validación por DTD

Contenido
1 Introducción ......................................................................................................... 3
1.1 Los documentos bien formados ........................................................................ 3
1.2. Construcción de un DTD .................................................................................. 4
1.2.1 Vinculación de los datos XML a un DTD ........................................................ 4
1.3. Definir elementos ............................................................................................. 5
2 DIFERENTES TIPOS DE DECLARACIONES ..................................................... 5
2.1 Los grupos ........................................................................................................ 5
2.1.1 Las palabras clave ANY y EMPTY ................................................................. 5
2.1.2 Los operadores (?), (+) y (*) ........................................................................... 5
2.1.3 El operador de elección | (exOR) ................................................................... 6
2.1.4 Los datos textuales (#PCDATA) .................................................................... 6
2.2. Definir atributos ................................................................................................ 6
2.2.1 Lista de atributos ............................................................................................ 7
2.2.2 Los atributos IMPLIED, REQUIRED y FIXED ................................................ 7
2.3. Tipos de atributos............................................................................................. 7
2.2.1 Los datos textuales (tipo CDATA y enumeraciones) ...................................... 7
3.2.2 Los atributos de tipo NOTATION ................................................................... 7
2.3.3 Los atributos ID o IDREF ............................................................................... 8
2.3.4 Los atributos de tipo ENTITY ......................................................................... 8
2.3.5 Los atributos de tipo NMTOKEN .................................................................... 9
2.4 Las entidades .................................................................................................... 9
2.4.1 Las entidades internas ................................................................................... 9
2.4.2 Las entidades externas ................................................................................ 10
2.5 Las secciones condicionales ........................................................................... 10
3. INTRODUCCIÓN AL CONCEPTO DE ESQUEMAS XML ............................. 11
3.1 Diferencias entre DTD y XMLSchema ............................................................ 11
3.1.1 La contribución del tipaje ............................................................................. 11
3.1.2 La contribución de la sintaxis XML ............................................................... 11
3.2 Construir un esquema ................................................................................. 12
3.2.1 Construcción del esquema "en muñecas rusas" .......................................... 12
3.2.2. Construcción por clonación ......................................................................... 14
3.3 Conceptos adicionales de construcción ...................................................... 15
3.3.1 Los grupos ................................................................................................... 15
3.3.2. El compositor choice ................................................................................... 15
3.3.3. El compositor all ........................................................................................ 15
3.4 Utilización de los tipos ................................................................................. 16
3.4.1 Los tipos predefinidos .................................................................................. 16
3.4.2 Los tipos personalizados .............................................................................. 16
3.5 Vincular un esquema a un documento XML ................................................ 17
1 Introducción
1.1 Los documentos bien formados
No se considerará un documento XML como "bien formado" si tiene fallos como los
siguientes:
• El documento no contiene un prólogo válido.
• Algunas etiquetas no se han cerrado.
• Los elementos no están anidados correctamente.
• Los valores de los atributos no se han colocado entre comillas.
• Los nombres de los elementos contienen caracteres no permitidos.
• No existe ningún elemento raíz en el documento

Un documento XML bien formado contendrá un prólogo del tipo :

<?xml version="1.0" encoding= "iso-8859-1" standalone="yes"?>
El término standalone nos permite especificar si el documento depende de la
gramática estándar impuesta por XML —valor “yes”, que es el valor por defecto y,
por lo tanto se puede omitir en este caso— o depende otra gramática distinta. El
valor "no" de standalone significa que el documento depende de un documento
DTD (Document Type Definition) que especifique la gramática que le describe:
Un documento válido contiene y respeta la gramática (la DTD) que le describe.
Recuerde que una DTD es la que declara las normas de validez de un documento
XML. Define, entre otras cosas, el orden de aparición y de imbricación de los
elementos, los atributos y sus tipos.
Si el documento está bien formado, al abrirlo con el navegador, podrá ver cómo la
información que contiene aparece en forma de árbol cuyos nodos son dinámicos.
Si, por el contrario, el documento contiene errores, el navegador los señalará y se
situará en el primer elemento que contenga un error. De todos modos, si estamos
construyendo el documento XML con VisualStudio, será muy difícil que lo hagamos
mal formado aunque “hay gente pa tó”.

1.1.1 Los analizadores

La palabra analizador (parser en inglés) se utiliza frecuentemente cuando se habla
del XML. Se trata simplemente de la herramienta que permite interpretar un
documento XML. Dicha interpretación consiste a menudo en transformar un
documento XML textual en una página Web. Los navegadores Web incluyen su
propio analizador XML. Probablemente, en algún momento necesitaremos
desarrollar nuestro propio interpretador para realizar manipulaciones específicas
en los datos descritos por un documento.
El analizador debe detectar si se trata de un documento bien formado. Si un
documento depende de una DTD, el interpretador debe validar el cumplimiento de
la gramática especificada.
1.2. Construcción de un DTD
Definir explícitamente un lenguaje permite implementar procesos de validación que
se ajusten a los documentos. Por ejemplo, si define una gramática para describir
unos libros, los autores pueden utilizar el mismo analizador para asegurar la
conformidad de sus documentos con respecto a un lenguaje definido. El siguiente
es un ejemplo de utilización de una DTD para definir la gramática de un documento
XML de descripción de libros.
Recuerde que un documento XML es un una jerarquía de elementos que posee una
sola raíz. Los elementos pueden contener caracteres, elementos terminales (las
hojas del árbol) o una combinación de ambos. Además, también pueden tener
atributos.
A diferencia de lo que ocurre con los atributos, los elementos terminales siguen un
orden estricto.
Aquí se muestra el documento XML con los datos del que se van a definir.
<?xml version="1.0"?>
<libro autor="anónimo">
<titulo>libro de ejemplo</titulo>
<capitulo numero="l">
Escriba aquí el contenido del capítulo 1
</capitulo>
<capitulo numero="2">
Escriba aquí el contenido del capítulo 2
</capitulo>
</libro>

1.2.1 Vinculación de los datos XML a un DTD

Como hemos dicho, la gramática de un documento XML se encuentra contenida en
un documento DTD, que comienza con la etiqueta <!DOCTYPE>.
Existen dos maneras de vincular los datos DTD a los datos XML:
1. Mediante la inserción de la DTD dentro del archivo XML: En este caso, la
sintaxis de la etiqueta <!DOCTYPE> es:
<!DOCTYPE nombreDeLaRaíz [ declaraciones ]>
Por ejemplo, la gramática DTD correspondiente al documento XML anterior, si lo
colocamos en el mismo documento, sería como sigue:
<!DOCTYPE libro [
<!ELEMENT libro (titulo, capitulo+)>
<!ATTLIST libro autor CDATA #REQUIRED>
<!ELEMENT titulo (#PCDATA)>
<!ELEMENT capitulo (#PCDATA)>
<!ATTLIST capitulo numero ID #REQUIRED>
]>
2. Mediante la integración de una referencia a un archivo DTD distinto. Para
vincular un documento a un archivo DTD específico, basta con utilizar la
siguiente instrucción justo después del prólogo —en el que hay que poner
standalone="no"— y antes de los datos XML:
<!DOCTYPE libro SYSTEM "nombrefichero.dtd">
Es aconsejable crear nuestros DTD en archivos separados para así optimizar la
utilización y las operaciones de actualización de las gramáticas de los XML.

1.3. Definir elementos

Los elementos son los nodos del árbol de un documento XML. A través de la
etiqueta < !ELEMENT > se declara cada elemento de un documento dentro de la
DTD. Existen dos tipos de elementos: los elementos terminales —que son las hojas
del árbol XML— y los elementos no terminales.
Un elemento es un grupo compuesto de varios subgrupos. Estos subgrupos
pueden contener, a su vez...
 Otros elementos: <!ELEMENT A (B, C)> El elemento A contiene el elemento B
seguido del elemento C:
 Datos textuales: <!ELEMENT elem (#PCDATA)>
 Nada: <!ELEMENT elem (EMPTY)>
 Cualquier cosa de las anteriores: <!ELEMENT elem (ANY)>

2 DIFERENTES TIPOS DE DECLARACIONES

2.1 Los grupos
Un grupo se sitúa entre paréntesis y se compone de referencias a elementos o a
subgrupos. Los elementos que declaran un grupo son elementos no terminales. Sin
embargo, los elementos que contienen EMPTY, ANY o datos textuales, son
elementos terminales.
2.1.1 Las palabras clave ANY y EMPTY
EMPTY impide a un elemento tener un elemento hijo o datos textuales.
ANY permite a un elemento contener cero o varios elementos hijos declarados o
datos textuales. Esto permite mezclar todos los tipos de elementos declarados.
2.1.2 Los operadores (?), (+) y (*)

Los operadores opción (?), uno-o-más (+) y cero-o-más (*) pueden aplicarse a los
grupos o a los subgrupos en la definición de un elemento.
- El operador (?) define un componente opcional.
<!—El sub-elemento fijo es opcional-->
<!ELEMENT numeroTel (fijo?, movil)>

- El operador (+) define un componente que aparece al menos una vez.

<!—El subgrupo (codPost, ciudad) al menos aparece una vez-->
<!ELEMENT provincia (nombreProv, (codPost, ciudad)+)>

- El operador (*) define un componente que aparece cero o más veces.

<!—El grupo (dirIP, nombreMaquina) aparece cero o más veces-->
<!ELEMENT maquina (dirIP, nombreMaquina)*>
2.1.3 El operador de elección | (exOR)
El operador I (Alt Gr + 1) significa que se pone sólo uno de los dos elementos entre
los que se encuentra.
Ejemplo: si tenemos la siguiente declaración
<!ELEMENT numeroTel (fijo | movil)>
<!ELEMENT fijo (#PCDATA)>
<!ELEMENT movil(#PCDATA)>

..., sería incorrecto el siguiente fragmento de documento XML:

<numeroTel>
<movil>654654654</movil>
<fijo>954959654</fijo>
</numeroTel>

porque por fuerza sólo puede existir uno de los dos.

2.1.4 Los datos textuales (#PCDATA)

Como ya hemos visto en los ejemplos anteriores, cuando un elemento sólo tiene
datos textuales, se representa así:
<!ELEMENT elemento (#PCDATA)>

Pero a veces, un elemento puede combinar datos textuales con otros elementos:
<!ELEMENT elem1 (#PCDATA | elem2 | elem3)*>

Estas declaraciones combinadas deben respetar los siguientes criterios:

 Los datos textuales #PCDATA aparecen en el encabezado de la declaración.
 El grupo debe ser una elección (separaciones con la ayuda del carácter |).
 El grupo debe aparecer cero o más veces (operador *) .
Nota: El término PCDATA significa Parsed Character DATA.

2.2. Definir atributos

Los elementos pueden tener cero o más atributos. La etiqueta <!ATTLIST> permite
declarar una lista de atributos para un elemento especificado. Por ejemplo
<!ELEMENT capitulo (#PCDATA)>
<!ATTLIST capitulo numero ID #REQUIRED>

Estos son datos XML conformes a la anterior declaración:

<capitulo numero="id15">
La Musaraña de la montaña
</capitulo>
2.2.1 Lista de atributos
La etiqueta <!ATTLIST> permite declarar una lista de atributos para un elemento
especificado. Y esto se puede hacer de dos formas:
1. Repitiendo la etiqueta:
<!ELEMENT libro (titulo, capitulo+)>
<!ATTLIST libro autor CDATA #REQUIRED>
<!ATTLIST libro editorial CDATA #IMPLIED>

2. Sin repetir la etiqueta:

<!ELEMENT libro (titulo, capitulo+)>
<!ATTLIST libro
autor CDATA #REQUIRED
editorial CDATA #IMPLIED>

2.2.2 Los atributos IMPLIED, REQUIRED y FIXED

Los atributos pueden ser opcionales (#IMPLIED) u obligatorios (#REQUIRED) y en
ocasiones presentan valores fijos (# FIXED). Los atributos opcionales pueden tener
valores por defecto.
En el ejemplo anterior vemos atributos obligatorios y opcionales. Un ejemplo de
atributo fijo puede ser el siguiente:
<!ATTLIST archivoAudio formato CDATA #FIXED "mp3">

Hasta aquí el viernes 18

2.3. Tipos de atributos

Los atributos son en ocasiones identificadores o referencias a atributos
identificadores. También puede representar una enumeración de valores posibles.

2.2.1 Los datos textuales (tipo CDATA y enumeraciones)

El siguiente ejemplo muestra una simple declaración de un atributo textual:
<!ATTLIST vehiculo tipo CDATA #IMPLIED>

El siguiente ejemplo utiliza una enumeración de datos textuales dentro de la

declaración de un atributo:
<!ATTLIST vehiculo tipo(coche | moto) #IMPLIED>

3.2.2 Los atributos de tipo NOTATION

Este tipo de atributo permite asociar una aplicación a un tipo de información. A
continuación se muestra un ejemplo de declaración de una notación:
<!NOTATION jpg PUBLIC "JPEG">
Sustituya la palabra clave PUBLIC por SYSTEM si desea seleccionar una aplicación en
particular.
Los atributos pueden ser del tipo de una notación previamente declarada. También
es posible declarar una enumeración de notaciones declaradas para un atributo.
<!ATTLIST foto apartamento NOTATION (gif | jpg) #IMPLIED>

2.3.3 Los atributos ID o IDREF

Un atributo puede utilizarse como identificador de un elemento. Este identificador
debe ser único en el documento.
<!--id será el identificador del elemento receta-->
<!ATTLIST receta id ID #REQUIRED>
El identificador debe comenzar por una letra o por el carácter de subrayado.
Los atributos de tipo IDREF son referencias a los identificadores. El valor del
atributo IDREF debe corresponder a un identificador de elemento existente.
<!--atributo ref apunta al identificador de otro elemento-->
<!ATTLIST ingrediente ref IDREFS #IMPLIED>
A continuación se muestra la DTD que especifica la gramática de un libro de cocina:
<?xml version="1.0" encoding= "iso-8859-1" standalone="no"?>
<!--Declaraciones DTD-->
<!DOCTYPE librococina [
<!ELEMENT librococina (receta|ingrediente)*>
<!ELEMENT receta (#PCDATA)>
<!--id será el identificador del elemento receta-->
<!ATTLIST receta id ID #REQUIRED>
<!ELEMENT ingrediente (#PCDATA)>
<!--atributo ref apunta al identificador de otro elemento-->
<!ATTLIST ingrediente ref IDREFS #IMPLIED>
]>

<!--Datos XML válidos según este DTD-->

<librococina>
<receta id="rec_1"> Mousse de chocolate </receta>
<receta id="rec_2"> Fondue saboyana </receta>
<receta id="rec_3"> Fondue de chocolate </receta>
<ingrediente ref="rec_1 rec_3"> chocolate </ingrediente>
<ingrediente ref="rec_2"> Comté </ingrediente>
</librococina>

2.3.4 Los atributos de tipo ENTITY

ENTITY es la palabra clave que designa las entidades. En una de las secciones
siguientes, aprenderemos con más precisión su significado. A grandes rasgos, las
entidades permiten definir las constantes para el documento. Así pues, los atributos
pueden ser de tipo entidad. También pueden hacer referencia a varias entidades
(separadas por el carácter de espacio) utilizando la palabra clave ENTITIES:
<!-- El atributo aa apunta a una única entidad-->
<!ATTLIST A aa ENTITY #IMPLIED>
<!-- El atributo bb apunta a varias entidades-->
<!ATTLIST A bb ENTITIES #IMPLIED>
2.3.5 Los atributos de tipo NMTOKEN
El tipo NMTOKEN especifica los caracteres permitidos por XML. Los atributos
pueden utilizar el tipo NMTOKEN o NMTOKENS para una lista de NMTOKEN
separados por caracteres de espacio:
<!--Elatributo aa debe contener una palabra-->
<!--utilizando únicamente caracteres permitidos por XML-->
<!ATTLIST A aa NMTOKEN #IMPLIED>
<!--Elatributo bb debe contener una o varias palabras-->
<!--utilizando únicamente caracteres permitidos por-->
<!--XML y separados por el caracter espacio-->
<!ATTLIST A bb NMTOKENS #IMPLIED>

2.4 Las entidades

Las entidades permiten definir las constantes de los documentos XML. Existen dos
tipos de entidades: las entidades internas y las externas. El primer tipo permite la
declaración de una variable cuyo alcance se limita al documento XML. Sin
embargo, las entidades externas permiten vincular el documento XML a otros
documentos (de todo tipo). Inserte &nombreentidad; en el documento XML para
utilizar el valor de la entidad llamado nombreentidad.
Algunas entidades de utilidad predefinidas en XML:
Entidad Valor
&It; <
&gt; >
&amp; carácter espacio
&apos; carácter ' (apóstrofo)
&quot; carácter " (comilla)

2.4.1 Las entidades internas

Las entidades internas pueden utilizarse únicamente dentro del documento en el
que han sido declaradas. A continuación se muestra un ejemplo de declaración de
entidad interna:
<!ENTITY nombreEntidad "aquí estaría el nombre de la entidad">
Ejemplo de utilización de una entidad interna en un documento XML:

<?xml version="1.0" encoding= "iso-8859-1" standalone="no"?>

<!--Declaraciones DTD-->
<!DOCTYPE tarjetaVisita[
<!ENTITY miCalle "Calle del Pez">
]>

<tarjetaVisita>
<apellido> Bond </apellido>
<nombre> James </nombre>
<profesión> Agente Secreto </profesión>
 <dirección>
<!--aquí utilizo la entidad -->
<calle>&miCalle;</calle>
<número>172</número>
<codPostal>41006</codPostal>
<población>Sevilla</población>
</dirección>
</tarjetaVisita>

2.4.2 Las entidades externas

Las entidades externas permiten vincular el documento XML a otro documento a
través de su URL. Este documento puede ser de tipo XML o de cualquier otro tipo.
<!ENTITY otrodoc SYSTEM "http://localhost/docsxml/otrodoc.xml">

Las referencias a la entidad otrodoc de un documento XML serán reemplazadas

por el contenido de dicho documento.

2.5 Las secciones condicionales

En ocasiones puede resultar útil ocultar algunas partes de la declaración del DTD.
Las palabras clave INCLUDE e IGNORE le permitirán respectivamente incluir o
ignorar secciones de declaraciones dentro de una DTD. La siguiente tabla muestra
la sintaxis utilizada para realizar este tipo de operación:
Palabras Sintaxis Ejemplo
< ! [ I NCLUDE[ <!ELEMENT
INCLUDE < ! [INCLUDE [declaraciones visibles > pseudo (#PCDATA) >
< ! [ IGNORE [< !ELEMENT
IGNORE < ! [IGNORE [declaraciones a ocultar]]> contraseña(#PCDATA)]]>

Al utilizar INCLUDE, el contenido de la declaración es visible en la DTD. Si

embargo, la palabra clave IGNORE permite ocultar e ignorar algunos elementos del
DTD. El contenido ignorado o incluido aparece entre corchetes justo después de las
palabras clave IGNORE o INCLUDE. El siguiente es un ejemplo de su utilización:
3. INTRODUCCIÓN AL CONCEPTO DE ESQUEMAS XML
Los esquemas aparecieron hace poco. Se espera que con el tiempo lleguen a
sustituir los DTD. Estas son, de hecho, demasiado limitadas. No se definen tipos
para los datos y los únicos elementos terminales son los datos textuales. Los
esquemas XML permiten utilizar varios tipos para sus datos. En la mayoría de las
ocasiones, los documentos XML se utilizan para insertarlos o para extraerlos de
una base de datos. Conocer los tipos de datos que se manejan permite realizar con
mayor eficacia algunas operaciones (como las de inserción o extracción). En el
mejor de los casos, los tipos de datos de los documentos XML corresponden a los
tipos utilizados por la base de datos. En este sentido, los esquemas son un activo
real y una herramienta esencial para la integración de una solución XML. Además,
la contribución del tipaje en la gramática no es su única ventaja: los esquemas son
fáciles de leer y de comprender ya que están escritos en lenguaje XML.
Nota: Es posible construir un esquema a partir de una DTD. Existen algunas herramientas
disponibles en Internet que permiten convertir automáticamente una DTD en XMLSchema.
En nuestro caso, podemos utilizar el propio Visual Studio. Sin embargo, una vez obtenido
el esquema, habrá añadir manualmente lo que la herramienta no pueda decidir.

3.1 Diferencias entre DTD y XMLSchema

3.1.1 La contribución del tipaje
Un documento DTD describe el árbol de los elementos que constituyen el
documento XML. Las hojas del árbol representan a los elementos terminales. Las
DTD atribuyen necesariamente el tipo #PCDATA a los valores de estos elementos.
Ya no se definen tipos de atributos.
La integración de esquemas permite diferenciar los elementos terminales y los
atributos por su tipo. Podremos utilizar los tipos predefinidos por la gramática o
crear nuestros propios tipos para ajustarlos a nuestras necesidades.

3.1.2 La contribución de la sintaxis XML

Las DTD utilizan un lenguaje propio que es necesario comprender. La lectura de
una gramática compleja descrita por un documento DTD resulta difícil.
Los esquemas, en cambio, especifican las gramáticas de documentos XML en
XML. El documento resultante es mucho más fácil de leer y entender.

sigue en la página siguiente

3.2 Construir un esquema
Vamos a construir esquemas simples que reagrupen la mayoría de las
características que es necesario conocer. Basándose en el siguiente ejemplo XML,
construiremos un esquema siguiendo dos tipos de enfoque diferentes: la
construcción "en muñecas rusas" y la construcción "por clonación".
<?xml version="1.0" encoding= "iso-8859-1"?>

<revista codigo="0954651235" >

<nombre>
El XML libre
</nombre>
<fechasalida>18-06-2002</fechasalida>
<articulo>
<titulo>Los esquemas XML</titulo>
<autor> Sébastien L. </autor>
<numeropalabras>5OO</numeropalabras>
<texto>
Contenido del artículo
</texto>
</articulo>
<articulo>
<titulo>XML y DTD</titulo>
<autor> Yasmine S. </autor>
<autor> Lourdin H. </autor>
<numeropalabras>260</numeropalabras>
<texto>
Contenido del artículo
</texto>
</articulo>
</revista>

3.2.1 Construcción del esquema "en muñecas rusas"

Construcción "en muñecas rusas" consiste en seguir simplemente la estructura del
documento XML y definir cada uno de los elementos según se van encontrando.
Como el esquema es un documento XML, posee un prólogo que define la versión
del lenguaje XML y los códigos de caracteres utilizados. La primera declaración que
hay que realizar consiste en abrir un elemento esquema:

<?xml version="1.0" encoding= "iso-8859-1"?>

<xsd: schema xmlns:xsd="http://www.w3.org/2000/lO/XMLSchema">

Este elemento esquema se refiere al espacio de nombre XMLSchema publicado

por W3C. También puede aplicar nuestros propios espacios de nombres.
A continuación, para definir la etiqueta de apertura del elemento revista , se
construirá un elemento con el mismo nombre. Tendrá el tipo complexType como
cualquier elemento que ofrezca atributos o subelementos. El tipo simpleType está
reservado a los elementos que no poseen atributos ni otros elementos.
Las listas de subelementos se describen en el interior de un elemento sequence.
Así, la declaración del esquema puede ser (sólo la apertura de las etiquetas):
 <xsd:element name="revista">
<xsd:complexType>
<xsd:sequence>

elemento sequence (llamado compositor sequence) define una lista ordenada de

subelementos (veremos los compositores choice y all en este mismo capítulo).
A los elementos nombre y fechasalida se les describe como tipos simples ya que
no poseen ni atributos ni subelementos. Para el primer elemento, se escoge el tipo
xsd:string. El segundo elemento tendrá el tipo xsd:date. Estos son tipos
predefinidos por el espacio de nombre XMLSchema de W3C:
<xs:element name="nombre" type="xs:string" />
<xs:element name="fechasalida" type="xs:date" />
Entonces, el elemento articulo se considera como un tipo complejo. Los esquemas
permiten definir con precisión la cardinalidad de los elementos. La cardinalidad
define el número de veces que puede aparecer un elemento:
<xs:element minOccurs="0" maxOccurs="unbounded" name="articulo">
<xs:complexType>
<xs:sequence>

Los atributos minOccurs y maxOccurs representan el número mínimo y

máximo de veces que puede aparecer y unbounded significa que el elemento
puede repetirse tantas veces como se desee. Ten en cuenta que los dos atributos
tienen un valor igual a 1 por defecto.
A continuación se muestra la declaración de los elementos que componen el
elemento artículo :
<xs:element name="titulo" type="xs:string" />
<xs:element maxOccurs="unbounded" name="autor" type="xs:string" />
<xs:element name="numeropalabras" type="xs:string" />
<xs:element name="texto" type="xs:string" />
</xs:sequence>
La descripción del elemento articulo finaliza con el cierre de las etiquetas
sequence, complexType y element:
</xs:sequence>
</xs:complexType>
</xs:element>
La secuencia de los elementos para el elemento revista también finaliza:
</xs:sequence>
El atributo de este elemento aquí se declara como sigue:
<xs:attribute name="codigo" type="xs:unsignedInt" use="required" />
Ya se ha finalizado la creación del esquema y los elementos que se encontraban
abiertos se cierran:
</xs:complexType>
</xs:element>
</xs:schema>
3.2.2. Construcción por clonación
Aunque el estilo de esquema en "muñecas rusas" es muy sencillo de implementar,
puede llegar a resulta r difícil su lectura o asegurar el mantenimiento cuando la
estructura del documento se vuelve más compleja. Se aleja considerablemente de
la organización de las DTD, complicando las operaciones de conversión manual en
esquema.
El estilo de esquema "por clonación" retoma los conceptos vistos en la construcción
anterior. Sin embargo, la manera de construirlo es diferente. Al igual que las DTD,
consiste en un simple catálogo de elementos presentes en el documento,
precisando para cada uno la lista de sus atributos y elementos. Los elementos
terminales y los atributos se declaran en primer lugar. La declaración de las
secuencias y de tipos complejos aparece a continuación y hacen referencia a los
elementos y atributos declarados anteriormente utilizando el atributo ref .
Este sería el esquema completo (después de la cabecera) correspondiente al
documento XML presentado anteriormente según una construcción "por clonación":
<!--Definición de elementos simples-->
<xs:element name="nombre" type="xs:string" />
<xs:element name="fechasalida" type="xs:date" />
<xs:element name="titulo" type="xs:string" />
<xs:element name="autor" type="xs:string"/>
<xs:element name="numeropalabras" type="xs:string" />
<xs:element name="texto" type="xs:string" />

<!--Definición de los atributos-->

<xs:attribute name="codigo" type="xs:unsignedInt"/>

<!--Definición de elementos de tipo complejo-->

<xs:element name="articulo">
<xs:complexType>
<xs:sequence>
<!-- Referencia a sus elementos simples-->
<xs:element ref="titulo"/>
<xs:element ref="autor" maxOccurs="unbounded"/>
<xs:element ref="numeropalabras"/>
<xs:element ref="texto"/>
</xs:sequence>
</xs:complexType>
</xs:element>

<xs:element name="revista" >

<xs:complexType>
<xs:sequence>
<!-- Referencia a sus elementos simples-->
<xs:element ref="nombre"/>
<xs:element ref="fechasalida" />
<xs:element ref="articulo" minOccurs="0" maxOccurs="unbounded"/>
<xs:element ref="texto"/>
</xs:sequence>
<xs:attribute name="codigo" use="required" />
</xs:complexType>
</xs:element>
</xs:schema>
3.3 Conceptos adicionales de construcción
3.3.1 Los grupos
Podemos definir grupos de elementos y de atributos:
<!--Definición de un grupo de elementos -->
<xs:group name ="InfoRevista">
<xs:sequence>
<xs:element name="nombre" type="xs:string" />
<xs:element name="fechasalida" type="xs:date" />
</xs:sequence>
</xs:group>
<!--Definición de un grupo de atributos -->
<xs:attributeGroup name="AtributosRevista" >
<xs:attribute name="codigo" type="xs:unsignedInt"/>
<xs:attribute name="pais" type="xs:string"/>
</xs:attributeGroup>

3.3.2. El compositor choice

Hasta ahora hemos utilizado el compositor sequence que define un grupo
ordenado de elementos. Los esquemas XML de W3C permiten utilizar otros dos
tipos de compositores: los compositores choice y all .
Los compositores pueden poseer por si solos atributos minOccurs y maxOccurs
para definir su cardinalidad.
El compositor choice define un grupo de elementos. Se debe seleccionar
únicamente uno de estos elementos. De acuerdo con la siguiente construcción,
aparecerán un elemento identidad o un grupo de tres elementos: nombre,
otronombre (opcional) y apellido:
<xs:group name="IdentidadType">
<xs:choice>
<xs:element name="identidad" type="xs:string"/>
<xs:sequence>
<xs:element name="nombre" type="xs:string"/>
<xs:element name="otronombre" type="xs:string" minOccurs="O"/>
<xs:element name="apellido" type="xs:string"/>
</xs:sequence>
</xs:choice>
</xs:group>

3.3.3. El compositor all

El compositor all define un conjunto no ordenado de elementos. La siguiente
definición describe un grupo en el que los elementos pueden aparecer en cualquier
orden:
<xs:group name="articuloType">
<xs:all>
<xs:element name="titulo" type="xs:string" />
<xs:element name="autor" type="xs:string"
maxOccurs="unbounded"/>
<xs:element name="texto" type="xs:string" />
</xs:all>
</xs:group>
3.4 Utilización de los tipos
3.4.1 Los tipos predefinidos
Los esquemas permiten utilizar tipos de datos predefinidos tal como hemos visto en
los ejemplos anteriores.

3.4.2 Los tipos personalizados

Los esquemas también permiten utilizar tipos de datos personalizados.
Los tipos ofrecen la posibilidad de poder cortar en partes el esquema y vincularlas
entre ellas.
los tipos de datos simples son elementos simpleType y los tipos de datos
complejos, elementos complexType. Los simples contienen datos, pero no
atributos o sub-elementos. Estas definiciones deben realizarse a parte de cualquier
definición de elemento o de atributo.
A menudo, la creación de un tipo consiste en derivar un tipo a partir de una
resticción a los valores aceptados. Por lo ejemplo: para definir un tipo de datos
(cadena32) que corresponda a una cadena de caracteres que acepte un máximo
de 32 caracteres, el tipo creado será:
<xsd:simpleType name="cadena32" >
<xsd:restriction base="xsd:string">
<xsd:maxLength value="32" />
</xsd:restriction>
</xsd:simpleType>

El elemento de restricción permite anunciar la derivación por restricción a partir del

especificado por el atributo base (aquí, el tipo que se derivará es string). Al
parámetro maxLength se le conoce como "faceta". Permite realizar una restricción
en el tamaño de la unidad correspondiente al tipo que se va derivar (aquí, la unidad
es el carácter).
La faceta pattern puede resultar muy útil en ocasiones. Permite introducir una
expresión regular para definir el dominio de aceptación de un valor. Por ejemplo,
documento XML de la revista, el primer atributo utilizado es un código.
Vamos a definir el tipo de este código utilizando esta faceta, como sigue:
<xsd:simpleType name="tipoCodigoLibro" >
<xsd:restriction base="xsd:string">
<xsd:pattern value="[0-9]{10}" />
</xsd:restriction>
</xsd:simpleType>
Así, el código se define como una cadena de diez caracteres numéricos.
Los tipos complejos se definen de la misma manera.
Como podemos ver, la definición y la utilización de tipos de datos son comparables
a la creación de una clase y a su utilización para crear un objeto.
3.5 Vincular un esquema a un documento XML
Para realizar este vínculo, el documento XML debe hacer referencia a un espacio
de nombre particular:
http://www.w3.org/2000/10/XMLSchema-instance
Por lo general se asocia al prefijo xsi.
Existen dos tipos de vínculos que corresponden a dos sintaxis diferentes. En primer
lugar consideramos un esquema que no define ningún espacio de nombre. En este
caso, el vínculo para nuestro ejemplo se creará siguiendo la siguiente sintaxis:
<codigorevista
xmlns:xsi="http://www.w3.org/2000/10/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="file:prensa.xsd">