Tutorial XSD (XML Schema Definition)

El Tutorial de XSD (XML Schema Definition, Definición de Esquema XML) es una excelente continuación después de aprender sobre XML, DTD y XPath. XSD es un lenguaje de esquema que se utiliza para definir la estructura y las restricciones de un documento XML.

En este tutorial, exploraremos los conceptos fundamentales de XSD y cómo se utiliza para validar y describir la estructura de un documento XML. Aprenderás a definir elementos, atributos, tipos de datos, restricciones y mucho más.

Con el conocimiento de XSD, podrás crear esquemas sólidos y precisos para tus documentos XML, lo que te proporcionará un mayor control y garantía de calidad en tus proyectos.

1. Tutorial: Introducción a XSD

El XSD es un estándar del World Wide Web Consortium (W3C) que se utiliza para definir la estructura de los documentos XML, permitiendo su validación. Proporciona un conjunto de reglas que permiten especificar los elementos, atributos, tipos de datos y relaciones entre ellos en un documento XML.

Permite establecer la estructura jerárquica de los elementos, especificar los tipos de datos que pueden contener y definir restricciones como valores mínimos y máximos, formatos de datos, entre otros.

Al utilizar XSD, se puede garantizar la consistencia y la integridad de los datos en los documentos XML, lo que resulta especialmente útil en aplicaciones como intercambio de datos, integración de sistemas y validación de entradas en aplicaciones web.

En la actualidad existen dos formas principales de definir la estructura de los documentos XML: mediante DTD y con XSD. Veamos sus diferencias.

2. Diferencias entre DTD y XSD

Los esquemas XSD tienen una forma diferente a los DTD de crear reglas para validar archivos XML. Las diferencias principales son las siguientes:

• Admiten tipos de datos con verificación, como enteros, fechas y otros tipos.
• Permiten agregar restricciones, como valores mínimos y máximos para un número, o especificar el patrón que debe seguir una cadena válida.

3. Estructura de un schema

Para crear un XSD, se utiliza un nodo raíz que contiene todo el esquema y se define mediante el uso del prólogo, que incluye la versión XML. El nodo «schema» contiene todos los elementos y atributos que definen la estructura del documento y las restricciones que se deben cumplir. Por ejemplo, se puede utilizar el siguiente prólogo:

<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
 ...
</xs:schema>

Como se puede observar, el nodo raíz se define utilizando el espacio de nombres XML «http://www.w3.org/2001/XMLSchema». Esto se especifica utilizando el atributo «xmlns:xs» (o «xmlns:xsd») en el nodo «schema«. El prefijo «xs» (o «xsd») se utiliza como una abreviatura para referirse al espacio de nombres en el resto del esquema.

Es importante destacar que la URL utilizada en el atributo «xmlns:xs» no implica que se deba estar conectado a Internet para trabajar con XML. Simplemente se utiliza como una referencia a la definición de elementos y atributos que se pueden utilizar en el esquema.

4. Definición de un elemento

Para declarar o definir un elemento tenemos dos tipos de estructuras:

a) Estructura vacía

<xs:tipoelemento/> <!-- Se puede usar también el prefijo xsd -->

b) Estructura llena

<xs:tipoelemento> <!-- Se puede usar también el prefijo xsd -->
 ...
</xs:tipoelemento>

Un elemento puede contener atributos cuyos valores siempre van entre comillas:

<xs:tipoelemento name="Nombre elemento" />

Los tipos de atributos de los elementos son los siguientes:

Atributo	Descripción
name	Nombre del elemento
type	Tipo simple predefinido, ya sean los estándares o unos propios
maxOccurs	Número máximo de veces que puede aparecer el elemento (p. ej., [0..unbounded])
minOccurs	Número mínimo de veces que puede aparecer el elemento
ref	Para importar de otros esquemas o hacer referencia a un elemento ya declarado

Por defecto, si no definimos maxOccurs ni minOccurs, el elemento aparece una sola vez.

5. Tipos de elementos

En XSD distinguimos entre dos tipos de elementos: simples y complejos.

5.1. Elementos simples <xs:element>

Los elementos simples son aquellos que contienen un solo valor sin subelementos. Estos elementos se definen utilizando el elemento <xs:element> junto con el atributo type para especificar el tipo de datos del elemento.

A continuación se muestra un ejemplo de cómo se define un elemento simple en XSD:

<xs:element name="texto" type="xs:string" />

Existen varios tipos de datos predefinidos en XSD que se pueden utilizar para definir elementos simples mediante el atributo type, como:

Tipo de Datos	Descripción
xs:string	Representa una cadena de texto.
xs:integer	Representa un número entero.
xs:boolean	Representa un valor booleano (true o false).
xs:date	Representa una fecha en formato YYYY-MM-DD.
xs:time	Representa una hora en formato HH:MM:SS.
xs:decimal	Representa un número decimal.
xs:float	Representa números de punto flotante de 32 bits de precisión simple.
xs:double	Representa números de punto flotante de 64 bits de doble precisión.

5.2. Elementos simples personalizados <xs:simpleType>

Además de los tipos de datos predefinidos en la tabla anterior, también es posible definir tipos de datos simples personalizados utilizando el elemento <xs:simpleType> con el atributo name para establecer un nombre. De esta forma, podemos agregar restricciones adicionales al valor del elemento, como rangos numéricos, patrones de caracteres, valores permitidos, entre otros.

Dentro del elemento <xs:simpleType>, se pueden establecer restricciones utilizando otros elementos como los siguientes:

• <xs:restriction>: Para poner rangos, patrones, enumerar posibles valores etc.
• <xs:list>: Para definir un tipo de lista.
• <xs:union>: Para unir varios tipos definidos anteriormente en uno.

5.2.1. Elemento <xs:restriction>

La estructura básica del elemento <xs:restriction> en XSD es la siguiente:

<xs:restriction base="tipoDeDatoBase">
   <!-- Restricciones y atributos adicionales aquí -->
</xs:restriction>

En esta estructura, el atributo base especifica el tipo de dato base del cual se está realizando la restricción. Dentro del elemento <xs:restriction>, se pueden agregar diferentes restricciones y atributos para definir las reglas específicas que se aplican al tipo de dato base.

A continuación se muestra una tabla con las restricciones más comunes que se pueden utilizar dentro del elemento <xs:restriction> en XSD:

Restricción	Descripción
<xs:length>	Especifica la longitud exacta del valor permitido.
<xs:minLength>	Especifica la longitud mínima del valor permitido.
<xs:maxLength>	Especifica la longitud máxima del valor permitido.
<xs:minInclusive>	Especifica el valor mínimo permitido, incluyendo ese valor.
<xs:maxInclusive>	Especifica el valor máximo permitido, incluyendo ese valor.
<xs:minExclusive>	Especifica el valor mínimo permitido, excluyendo ese valor.
<xs:maxExclusive>	Especifica el valor máximo permitido, excluyendo ese valor.
<xs:enumeration>	Especifica un conjunto de valores permitidos para seleccionar.
<xs:pattern>	Especifica un patrón utilizando la sintaxis de expresiones regulares.

A continuación se muestran algunos ejemplos de cómo utilizar el elemento <xs:restriction> en XSD para restringir los valores de un tipo de dato simple:

1.Ejemplo <xs:maxLength>: Restricción de un tipo de dato string a una longitud máxima de 10 caracteres.

<xs:simpleType name="Nombre">
  <xs:restriction base="xs:string">
    <xs:maxLength value="10"/>
  </xs:restriction>
</xs:simpleType>

2. Ejemplo <xs:minInclusive>: Restricción de un tipo de dato integer a un rango específico.

<xs:simpleType name="Edad">
  <xs:restriction base="xs:integer">
    <xs:minInclusive value="18"/>
    <xs:maxInclusive value="99"/>
  </xs:restriction>
</xs:simpleType>

3. Ejemplo <xs:enumeration>: Restricción de un tipo de dato decimal a un conjunto específico de valores.

<xs:simpleType name="Puntuacion">
  <xs:restriction base="xs:decimal">
    <xs:enumeration value="1.0"/>
    <xs:enumeration value="2.5"/>
    <xs:enumeration value="4.0"/>
    <xs:enumeration value="5.0"/>
  </xs:restriction>
</xs:simpleType>

4. Ejemplo <xs:pattern>: Restringido a ser una cadena de texto de 5 dígitos numéricos.

<xs:simpleType name="codigoPostal">
  <xs:restriction base="xs:string">
    <xs:pattern value="[0-9]{5}" />
  </xs:restriction>
</xs:simpleType>

5.2.2. Elemento <xs:list>

El elemento <xs:list> en XSD se utiliza para definir una lista de valores de un tipo de dato específico. Permite especificar múltiples valores separados por un espacio en blanco. Ejemplo:

<xs:element name="numeros" type="xs:list">
  <xs:simpleType>
    <xs:restriction base="xs:string">
      <xs:pattern value="\d+(\s+\d+)*" />
    </xs:restriction>
  </xs:simpleType>
</xs:element>

En este ejemplo, se define un elemento llamado «numeros» que contiene una lista de valores. El tipo de dato del elemento se establece como <xs:list>. Dentro de <xs:list>, se define un <xs:simpleType> que especifica las restricciones del tipo de dato. En este caso, se utiliza una restricción de patrón <xs:pattern> para asegurarse de que los valores sean números separados por espacios en blanco.

5.2.3. Elemento <xs:union>

El elemento <xs:union> se utiliza para definir varios tipos de datos en una única opción de tipo de dato.

1.Ejemplo. Unión de diferentes tipos de datos: En este ejemplo, la opción memberTypes del elemento <xs:union> especifica que el tipo de dato «tipoUnion» puede ser una fecha o una hora.

<xs:simpleType name="tipoUnion">
  <xs:union memberTypes="xs:date xs:time" />
</xs:simpleType>

Aquí tienes algunos ejemplos adicionales de cómo se puede utilizar el elemento <xs:union> en XSD:

2. Ejemplo: Unión de tipos de datos numéricos: se define un tipo de dato llamado «numericUnion» que puede ser de tipo <xs:integer>, <xs:decimal>, <xs:float> o <xs:double>. Esto permite que el valor sea cualquier número entero o decimal, ya sea de precisión simple o doble.

<xs:simpleType name="numericUnion">
  <xs:union memberTypes="xs:integer xs:decimal xs:float xs:double" />
</xs:simpleType>

5.3. Elementos complejos <xs:complexType>

El elemento <xs:complexType> se utiliza para definir tipos de datos complejos que tienen sub-elementos y/o atributos. Los tipos de datos complejos permiten especificar la estructura interna de un elemento XML, es decir, sus atributos y elementos hijos.

Dentro del elemento <xs:complexType>, se pueden agregar elementos como los siguientes:

Elemento	Descripción
<xs:sequence>	Se utiliza para especificar una secuencia ordenada de elementos hijos. Los elementos deben aparecer en el orden indicado.
<xs:choice>	Se utiliza para especificar que solo uno de los elementos hijos puede estar presente en un momento dado. Solo uno de los elementos enumerados dentro de <xs:choice> puede aparecer en el XML válido.
<xs:all>	Se utiliza para especificar que los elementos hijos pueden estar en cualquier orden. Todos los elementos enumerados dentro de <xs:all> pueden aparecer en cualquier orden en el XML válido.
<xs:attribute>	Se utiliza para agregar atributos a un tipo complejo. Se puede especificar el nombre y el tipo de atributo. Los atributos se agregan al elemento utilizando la sintaxis @nombreAtributo.

Veamos algunos ejemplos de uso:

1. Ejemplo <xs:sequence>: En este ejemplo, se define un tipo complejo llamado «Person» que contiene dos elementos hijos: «FirstName» y «LastName». Ambos elementos tienen un tipo de dato simple «xs:string».

<xs:complexType name="Person">
  <xs:sequence>
    <xs:element name="FirstName" type="xs:string"/>
    <xs:element name="LastName" type="xs:string"/>
  </xs:sequence>
</xs:complexType>

2. Ejemplo de <xs:choice>: En este ejemplo, se define un tipo complejo «Animal» que permite que solo uno de los elementos hijos («Cat», «Dog» o «Bird») esté presente en un momento dado.

<xs:complexType name="Animal">
  <xs:choice>
    <xs:element name="Cat" type="xs:string"/>
    <xs:element name="Dog" type="xs:string"/>
    <xs:element name="Bird" type="xs:string"/>
  </xs:choice>
</xs:complexType>

3. Ejemplo de <xs:all>: En este ejemplo, se define un tipo complejo «Address» que requiere que todos los elementos hijos («Street», «City» y «Country») estén presentes en cualquier orden.

<xs:complexType name="Address">
  <xs:all>
    <xs:element name="Street" type="xs:string"/>
    <xs:element name="City" type="xs:string"/>
    <xs:element name="Country" type="xs:string"/>
  </xs:all>
</xs:complexType>

4. Ejemplo <xs:attribute>: En este caso, se agrega el atributo «Age» al tipo complejo «Person» con un tipo de dato «xs:integer».

<xs:complexType name="Person">
  <xs:sequence>
    <xs:element name="FirstName" type="xs:string"/>
    <xs:element name="LastName" type="xs:string"/>
  </xs:sequence>
  <xs:attribute name="Age" type="xs:integer"/>
</xs:complexType>

6. Tutorial: Validación de un documento XML con XSD

La validación de un documento XML con XSD (XML Schema) implica asegurarse de que el documento cumple con las reglas y restricciones especificadas en el esquema XSD. Esto garantiza la integridad y consistencia de los datos en el documento XML.

6.1. Pasos a seguir

Para validar un documento XML con XSD, se deben seguir los siguientes pasos:

• Crear el archivo XSD: Crear un archivo XSD que defina la estructura, los tipos de datos y las restricciones del documento XML.
• Cargar los documentos en una herramienta de validación: Cargar los documentos en una herramienta y ejecutar la validación. De este modo, la herramienta verificará si el documento XML cumple con las reglas definidas en el esquema XSD. Si el documento no cumple con alguna regla, se generará un informe de errores que indicará las discrepancias encontradas.

6.2. Herramientas para validar documentos XML con XSD

Utiliza una herramienta o método para validar el documento XML con XSD:

1. Editor de código y algún complemento que permita la validación de XML con DTD como, por ejemplo, Visual Studio Code y la extensión XML de Red Hat.
2. Herramientas online como freeformatter.com/xml-validator-xsd.html.
3. Programa específico como XMLSpy, Oxygen XML Editor o Altova XMLSpy.
4. Herramientas en línea de comandos como xmllint o xmlstarlet. Estas herramientas suelen ofrecer opciones específicas para realizar la validación y mostrar los resultados.

Esperamos que este tutorial te haya sido útil para validar un documento XML con XSD En la siguiente sección te presentamos diferentes ejercicios resueltos para que puedas comprobar tu aprendizaje.

6.3. Ejemplo de validación

A continuación se muestra un ejemplo paso a paso para validar un documento XML con un esquema XSD utilizando la herramienta online comentada en el apartado anterior y también con la herramienta por línea de comandos Xmllint.

1. Paso 1: Crear el archivo XML
   Crea un archivo llamado datos.xml y añade el siguiente contenido:

<root>
  <person>
    <name>John Doe</name>
    <age>30</age>
    <email>john@example.com</email>
  </person>
</root>

2. Paso 2: Crear el archivo XSD
   Crea un archivo llamado esquema.xsd y añade el siguiente contenido:

<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">

  <xs:element name="root">
    <xs:complexType>
      <xs:sequence>
        <xs:element name="person" minOccurs="1" maxOccurs="unbounded">
          <xs:complexType>
            <xs:sequence>
              <xs:element name="name" type="xs:string"/>
              <xs:element name="age" type="xs:integer"/>
              <xs:element name="email" type="xs:string"/>
            </xs:sequence>
          </xs:complexType>
        </xs:element>
      </xs:sequence>
    </xs:complexType>
  </xs:element>

</xs:schema>

3. Paso 3: Validar el documento XML con el XSD con herramienta online
   Abre la herramienta online y sube los documentos para verificar la validación.
4. Paso 4: Validar el documento XML con el XSD con Xmllint
   Abre una terminal y ejecuta el siguiente comando:

xmllint --schema esquema.xsd datos.xml --noout

7. Ejercicios resueltos XSD

Con este conjunto de ejercicios prácticos resueltos podrás poner en práctica tus habilidades en XSD y comprobar si un archivo XML cumple las reglas definidas en XML Schema.

7.1. Tutorial XSD. Ejercicio resuelto: Catálogo de libros

Dado el siguiente archivo XML, crea un archivo XSD (XML Schema) que defina la estructura y restricciones del documento XML. A continuación, utiliza una herramienta de validación de XML con XSD para verificar si el archivo XML cumple con las reglas definidas en el XSD.

Archivo XML (documento.xml):

<?xml version="1.0" encoding="UTF-8"?>
<libreria>
  <libro>
    <titulo>El Gran Gatsby</titulo>
    <autor>F. Scott Fitzgerald</autor>
    <anio>1925</anio>
    <genero>Ficción</genero>
  </libro>
  <libro>
    <titulo>1984</titulo>
    <autor>George Orwell</autor>
    <anio>1949</anio>
    <genero>Distopía</genero>
  </libro>
</libreria>

Solución:

<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <xs:element name="libreria">
    <xs:complexType>
      <xs:sequence>
        <xs:element name="libro" maxOccurs="unbounded">
          <xs:complexType>
            <xs:sequence>
              <xs:element name="titulo" type="xs:string"/>
              <xs:element name="autor" type="xs:string"/>
              <xs:element name="anio" type="xs:integer"/>
              <xs:element name="genero" type="xs:string"/>
            </xs:sequence>
          </xs:complexType>
        </xs:element>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
</xs:schema>

Puedes utilizar una herramienta como xmllint para realizar la validación. Para ello, guarda el archivo XSD como «libreria.xsd» y el archivo XML como «documento.xml» en la misma carpeta. A continuación, ejecuta el siguiente comando en la línea de comandos:

xmllint --schema libreria.xsd documento.xml

Si el archivo XML cumple con las reglas definidas en el XSD, no se mostrará ningún mensaje de error. En caso contrario, se mostrarán mensajes de error indicando las violaciones al esquema definido.

Además, también puedes utilizar otras herramientas de validación de XML con XSD, como XMLSpy, Oxygen XML Editor o las funcionalidades integradas en tu entorno de desarrollo preferido.

7.2. Tutorial XSD. Ejercicio resuelto: Lista de estudiantes

Se te ha proporcionado un archivo XML llamado «datos.xml» que contiene información sobre estudiantes de una universidad. Tu tarea es crear un archivo XSD (XML Schema) que defina la estructura y las restricciones del documento XML. A continuación, valida el archivo XML utilizando el XSD para asegurarte de que cumple con las reglas especificadas.

Archivo XML (datos.xml):

<?xml version="1.0" encoding="UTF-8"?>
<universidad>
  <estudiante>
    <nombre>Juan Pérez</nombre>
    <edad>20</edad>
    <carrera>Ingeniería Informática</carrera>
  </estudiante>
  <estudiante>
    <nombre>María López</nombre>
    <edad>22</edad>
    <carrera>Arquitectura</carrera>
  </estudiante>
</universidad>

Solución:

<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <xs:element name="universidad">
    <xs:complexType>
      <xs:sequence>
        <xs:element name="estudiante" maxOccurs="unbounded">
          <xs:complexType>
            <xs:sequence>
              <xs:element name="nombre" type="xs:string"/>
              <xs:element name="edad" type="xs:integer"/>
              <xs:element name="carrera" type="xs:string"/>
            </xs:sequence>
          </xs:complexType>
        </xs:element>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
</xs:schema>

7.3. Tutorial XSD. Ejercicio resuelto: Productos de tienda online

Enunciado:

Se te ha proporcionado un archivo XML llamado «productos.xml» que contiene información sobre productos de una tienda en línea. Tu tarea es crear un archivo XSD (XML Schema) que defina la estructura y las restricciones del documento XML. A continuación, valida el archivo XML utilizando el XSD para asegurarte de que cumple con las reglas especificadas.

Archivo XML (productos.xml):

<?xml version="1.0" encoding="UTF-8"?>
<tienda>
  <producto>
    <nombre>Teléfono móvil</nombre>
    <precio>299.99</precio>
    <cantidad>10</cantidad>
  </producto>
  <producto>
    <nombre>Ordenador portátil</nombre>
    <precio>899.99</precio>
    <cantidad>5</cantidad>
  </producto>
</tienda>

Solución:

<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <xs:element name="tienda">
    <xs:complexType>
      <xs:sequence>
        <xs:element name="producto" maxOccurs="unbounded">
          <xs:complexType>
            <xs:sequence>
              <xs:element name="nombre" type="xs:string"/>
              <xs:element name="precio" type="xs:decimal"/>
              <xs:element name="cantidad" type="xs:positiveInteger"/>
            </xs:sequence>
          </xs:complexType>
        </xs:element>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
</xs:schema>

Esperamos que este tutorial te haya sido útil para validar un documento comprobar si un archivo XML cumple las reglas definidas en XML Schema. Te recordamos que este tutorial se incluye dentro de una serie de tutoriales en los que exploramos diversos aspectos del lenguaje XML y sus tecnologías asociadas. ¡Continua tu aprendizaje con los tutoriales de XPath o XSD y explora el fascinante mundo de XML!