XML-Schema. XML-Schema. XML-Schema. XML-Schema. Ventajas de XML-Schema con respecto a las DTD s:

XML-Schema

„

Es una tecnología creada inicialmente por Microsoft

basándose en los trabajos y recomendaciones del W3C:

zXML-Data: vocabulario XML para describir la estructura de los documentos

zDCD (Document Content Description) basada en RDF (Resource Description Framework vocabulario XML para representar metadatos) permite describir estructuras de documentos.

„

La especificación actual es XML Schema 1.0

„

El W3C está ya trabajando en XML Schema 1.1

XML-Schema

Ventajas de XML-Schema con respecto a las DTD’s:

„

Usa sintaxis XML

„

Permite definir tipos de datos (int, float, boolean, date, ...)

„

Presenta un modelo de datos abierto (usa conceptos de

la OO)

„

Soporta la integración de los espacios de nombres

„

Permite expresar conjuntos (elementos que ocurren en

cualquier orden)

„

Permite construir tipos complejos

XML-Schema

Ejemplo. Derivar un Schema de una instancia de documento XML

<?xml version=“1.0”?> <library>

<book id= “b0334455” available = “true”> <isbn> 089567654</isbn>

<title lang= “es”> El último encuentro </title> <author id=“NM”>

<name> Sándor Márai </name> <born> 13-4-1900 </born> <dead> 16-6-1989 </dead> </author>

<character id=“CH1”> <name> El general </name> <born> 13-12-1924</born>

<qualification> severo, triste </qualification> </character>

<character> … </character> </book>

</library>

XML-Schema

Ejemplo. Derivar un Schema de una instancia de

documento XML

Elementos:

library, book, author, born, character, dead, isbn, name, qualification, title

XML-Schema

Tipos de elementos:

• Vacío: sin contenido

• Simple: contenido de tipo texto

• Complejo: contenido formado por otros elementos

• Mixto: contenido formado por otros elementos y texto

XML-Schema

Ejemplo.

Derivar un Schema de una instancia de

documento XML

Modelos de contenido simple:

<title lang= “es”> El último encuentro</title> <name> Sándor Márai </name>

<born> 13-4-1900 </born>

Modelos de contenido complejo: <library>

<book id= “b0334455” available = “true”> … </book> </library>

<character id=“CH1”>

<name> El general </name> <born> 13-12-1924</born>

<qualification> severo, triste </qualification> </character>

XML-Schema

Tipos de elementos para XML-Schema:

• Tipo simple: modelo de contenido simple y sin atributos

• Tipo complejo: cualquier otro modelo

Los atributos son siempre de tipo simple

XML-Schema

Ejemplo.

Derivar un Schema de una instancia de documento XML

Tipo simple:

<name> Sándor Márai </name> <born> 13-4-1900 </born>

Tipo complejo: <library>

<book id= “b0334455” available = “true”> … </book> </library>

<character id=“CH1”>

<name> El general </name> <born> 13-12-1924</born>

<qualification> severo, triste </qualification> </character>

XML-Schema

Elementos de XML-Schema:

• schema

• datatype

• elementType

• element

• group

• attributeType

• attribute

• description

XML-Schema

Elementos de XML-Schema:

schema

Š Es el elemento raíz del schema

<?xml version="1.0"?>

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

<?xml version="1.0"?>

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

Define el espacio de nombres en el que están definidos

los elementos y tipos de datos de XML-Schema

XML-Schema

Ejemplo. Derivar un Schema de una

instancia de documento XML

Š

Comenzamos definiendo los elementos

de tipo simple

Ejemplo:

<name> Sándor Márai </name>

utilizamos el elemento element del XML

XML-Schema

Ejemplo. Derivar un Schema de una instancia de documento XML

Š La definición de todos los elementos simples y atributos quedaría: <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">

<xs:element name=“name” type=“xs:string”/> <xs:element name=“qualification” type=“xs:string”/> <xs:element name=“born” type=“xs:date”/>

<xs:element name=“dead” type=“xs:date”/> <xs:element name=“isbn” type=“xs:string”/> <xs:attribute name=“id” type=“xs:ID”/>

<xs:attribute name=“available” type=“xs:boolean”/> <xs:attribute name=“lang” type=“xs:language”/> …/…

XML-Schema

Ejemplo. Derivar un Schema de una instancia de documento XML

Š Vamos a definir un elemento de tipo complejo:

<title lang= “es”> El último encuentro </title>

<xs:element name=“title”> <xs:complexType> <xs:simpleContent> <xs:extension base=“xs:string”> <xs:attribute ref=“lang”/> </xs:extension> </xs:simpleContent> </xs:complexType> </xs:element>

XML-Schema

Ejemplo. Derivar un Schema de una instancia de documento XML

Š Vamos a definir otro elemento de tipo complejo: <library>

<xs:element name=“library”> <xs:complexType>

<xs:sequence>

<xs:element ref=“book” maxOccurs=“unbounded”/> </xs:sequence>

</xs:complexType>

</xs:element> Sin límite: 1..n

XML-Schema

Ejemplo. Derivar un Schema de una instancia de documento XML

Š Vamos a definir otro elemento de tipo complejo: <author> <xs:element name=“author”> <xs:complexType> <xs:sequence> <xs:element ref=“name”/> <xs:element ref=“born”/>

<xs:element ref=“dead” minOccurs=“0”/> </xs:sequence> <xs:attribute ref=“id”/> </xs:complexType> </xs:element> Opcional, puede ocurrir 0 veces

XML-Schema

Elementos de XML-Schema:

Š Los atributos maxOccurs y minOccurs: permiten definir el número máximo y mínimo de ocurrencias

Š Su valor por defecto es 1 (el elemento debe aparecer 1 vez) Š El valor “unbounded” con maxOccurs indica que el número

máximo de ocurrencias es ilimitado

<?xml version=“1.0”?>

<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"> <xs:element name=“name” type=“xs:string”/>

<xs:element name=“qualification” type=“xs:string”/> <xs:element name=“born” type=“xs:date”/>

<xs:element name=“dead” type=“xs:date”/> <xs:element name=“isbn” type=“xs:string”/> <xs:attribute name=“id” type=“xs:ID”/>

<xs:attribute name=“available” type=“xs:boolean”/> <xs:attribute name=“lang” type=“xs:language”/> <xs:element name=“title”> <xs:complexType> <xs:simpleContent> <xs:extension base=“xs:string”> <xs:attribute ref=“lang”/> </xs:extension> </xs:simpleContent> </xs:complexType> </xs:element> <xs:element name=“library”> <xs:complexType> <xs:sequence>

<xs:element ref=“book” maxOccurs=“unbounded”/> </xs:sequence> </xs:complexType> </xs:element> <xs:element name=“author”> <xs:complexType> <xs:sequence> <xs:element ref=“name”/> <xs:element ref=“born”/>

<xs:element ref=“dead” minOccurs=“0”/> </xs:sequence> <xs:attribute ref=“id”/> </xs:complexType> </xs:element> <xs:element name=“book”> <xs:complexType> <xs:sequence> <xs:element ref=“isbn”/> <xs:element ref=“title”/>

<xs:element ref=“author” minOccurs=“0” maxOccurs=“unbounded”/> <xs:element ref=“character” minOccurs=“0” maxOccurs=“unbounded”/> </xs:sequence> <xs:attribute ref=“id”/> <xs:attribute ref=“available”/> </xs:complexType> </xs:element> <xs:element name=“character”> <xs:complexType> <xs:sequence> <xs:element ref=“name”/> <xs:element ref=“born”/> <xs:element ref=“qualification”/> </xs:sequence> <xs:attribute ref=“id”/> </xs:complexType> </xs:element> </xs:schema>

XML-Schema

Š

En el esquema ejemplo cada componente (elemento o

atributo) se define directamente dentro del elemento

documento xs:schema

Š Los componentes definidos así se denominan “globales”

„Se pueden referenciar en cualquier parte del esquema y en otros esquemas que lo importen

XML-Schema

Definiciones locales de elementos y atributos

Definición de <library>: <xs:element name=“library”>

<xs:complexType> <xs:sequence>

<xs:element ref=“book” maxOccurs=“unbounded”/> </xs:sequence>

</xs:complexType> </xs:element>

Se hace referencia a un elemento book definido en otra parte del schema Se puede reemplazar la referencia a book con la definición de dicho elemento

<xs:element name=“library”> <xs:complexType>

<xs:sequence>

<xs:element name=“book” maxOccurs=“unbounded”/> <xs:complexType> <xs:sequence>

<xs:element ref=“isbn”/> <xs:element ref=“title”/>

<xs:element ref=“author” minOccurs=“0” maxOccurs=“unbounded”/> <xs:element ref=“character” minOccurs=“0”

maxOccurs=“unbounded”/> </xs:sequence> <xs:attribute ref=“id”/> <xs:attribute ref=“available”/> </xs:complexType> </xs:element> </xs:sequence> </xs:complexType> </xs:element>

•

La definición de bookes local a library porque está definido dentro de librar •Puede haber otras definiciones de book en otras partes del schema

•La definición de book no se puede utilizar en cualquier parte del schema •book ya no puede ser el elemento raíz de un documento que use este schema

<?xml version=“1.0”?>

<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"> <xs:element name=“library”>

<xs:complexType> <xs:sequence>

<xs:element name=“book” maxOccurs=“unbounded”/> <xs:complexType>

<xs:sequence>

<xs:element name=“isbn” type=“xs:string”/> <xs:element name=“title”>

<xs:complexType>

<xs:simpleContent>

<xs:extension base=“xs:string”>

<xs:attribute name=“lang” type=“xs:language”/> </xs:extension>

</xs:simpleContent> </xs:complexType>

</xs:element>

<xs:element name=“author” minOccurs=“0”

maxOccurs=“unbounded”> <xs:complexType>

<xs:sequence>

<xs:element name=“name” type=“xs:string”/> <xs:element name=“born” type=“xs:date”/> <xs:element name=“dead” type=“xs:date”/> </xs:sequence>

<xs:attribute name=“id” type=“xs:ID”/> </xs:complexType>

</xs:element>

Se pueden hacer todas las definiciones de elementos y atributos de manera local

<xs:element name=“character” minOccurs=“0” maxOccurs=“unbounded”> <xs:complexType>

<xs:sequence>

<xs:element name=“name” type=“xs:string”/> <xs:element name=“born” type=“xs:date”/>

<xs:element name=“qualification” type=“xs:string”/> </xs:sequence>

<xs:attribute name=“id” type=“xs:ID”/> </xs:complexType>

</xs:element> </xs:sequence>

<xs:attribute name=“id” type=“xs:ID”/>

<xs:attribute name=“available” type=“xs:boolean”/> </xs:complexType> </xs:element> </xs:sequence> </xs:complexType> </xs:element> </xs:schema>

XML-Schema

Este nuevo schema:

Š Permite validar la misma instancia de documento que el anterior Š No es equivalente: es menos reutilizable

„El elemento raíz (global) es el único que puede ser utilizado en otro schema

„Sólo el elemento library puede utilizarse como raíz

Š Sacrifica modularidad en favor de una descripción más acorde con la estructura de los documentos conformes con dicho esquema

XML-Schema

En la practica se pueden combinar los dos estilos

Š Si queremos definir elementos con el mismo nombre pero con

diferentes modelos de contenido en diferentes partes: definiciones locales

Š Si queremos reutilizar elementos ya definidos: definiciones globales:

Š Si se realiza un schema recursivo, en el que un elemento se incluye dentro de un elemento del mimo tipo como hijo (directa o indirectamente):

definiciones globales (uso de referencias)

XML-Schema

Ejemplo. Cambio de instancia

<?xml version=“1.0”?>

<library>

<book id= “b0334455” available =

“true”>

<isbn> 089567654</isbn>

<title lang= “en”> El último

encuentro</title>

<author id=“NM”>

<name> <first> Sándor </first>

<last> Márai </last> </name>

<born> 13-4-1900 </born>

<dead> 16-6-1989 </dead>

XML-Schema

XML-Schema:

Tipos de datos predefinidos

Š W3C XML Schema distingue entre:

„Los datos de la instancia documento (espacio léxico) „El valor de los datos interpretados de acuerdo a su tipo de

XML-Schema

XML-Schema:

Tipos de datos predefinidos

Š Transformaciones de las instancias XML antes de la

validación:

„Espacio de serialización: series de bytes tal cual están almacenadas

„Espacio de análisis: resultado de la primera transformación que llegará a los procesadores de schemas

zConversión de caracteres en Unicode

zNormalización de finales de línea, espacios en blanco

XML-Schema

XML-Schema:

Tipos de datos predefinidos

Š Transformaciones de las instancias XML antes de la

validación:

„Espacio léxico: resultante de un posible procesamiento de espacios en blanco, tabuladores, ... dependiendo del tipo de datos

„Espacio de valores: valor abstracto cuya semántica está definida por el tipo de datos: cadena, número, fecha ...

XML-Schema

XML-Schema:

Tipos de datos predefinidos

Š Cada tipo de datos tiene sus propios espacios

léxicos y de valores

ŠUn valor puede tener múltiples representaciones

léxicas:

el valor “3.14116” de tipo xs:float puede tener diversas representaciones léxicas: “03.14116”, “3.141160”, “.314116E1”

XML-Schema

XML-Schema:

Tipos de datos predefinidos

Ejemplo:

el valor “3.14116” de tipo xs:string es distinto del valor de “03.14116”, “3.141160”, “.314116E1”

Š Esta distinción es importante en operaciones como:

„

Test de igualdad

XML-Schema

XML-Schema:

Tipos de datos predefinidos

Š Cadena

Š Numéricos

Š Fecha y hora

Š Lista

XML-Schema

Tipos de datos: Cadena

Š

xs:string

„Es una cadena de caracteres válidos Unicode e ISO/IEC 10646 „No se realiza ningún tipo de reemplazamiento de espacios en

blanco, se respetan los tabuladores, espacios en blanco y retorno de carro

<title lang= “es”> El último

encuentro</title> El últimoencuentro El valor de: es:

XML-Schema

Tipos de datos:

Cadena

Š xs:normalizedString

„Es una cadena de caracteres válidos Unicode e ISO/IEC 10646 „Se reemplazan los caracteres tabulador (#x9), linefeed (#xA), y

retorno de carro (#xD) por espacio (#x20)

<title lang= “en”> El último encuentro</title>

El último encuentro El valor de: es:

XML-Schema

Tipos de datos: Cadena

Š xs:token

„

Es

xs:normalizedString

en el que se eliminan los

espacios al principio y al final, y varios espacios

contiguos se sustituyen por uno simple

<title lang= “en”> El último encuentro</title>

XML-Schema

Tipos de datos: Cadena

Š xs:language

„

Se deriva de xs:token

„

Se creó para aceptar los códigos de lenguaje

RFC 1766 (en, en-US, fr, ...)

http://www.faqs.org/rfcs/rfc1766.html

XML-Schema

Tipos de datos: Cadena

Š xs:NMTOKEN

„

Se corresponde con NMTOKEN visto en DTDs

„

Se deriva de xs:token

XML-Schema

Tipos de datos: Cadena

Š

xs:Name

„Se deriva de xs:token

„Es similar a xs:NMTOKEN con la restricción de que los valores deben comenzar con una letra o con los caracteres “:” o “_” „No debe utilizarse con nombres que vayan a ser calificados con

un prefijo de un espacio de nombres

XML-Schema

Tipos de datos: Cadena

Š

xs:NCName

„Se deriva de xs:token „ Es un NAME sin “:”

Š

xs:ID

„Se deriva de xs:NCName

XML-Schema

Tipos de datos: Cadena

Š xs:IDREF

„Se deriva de xs:NCName

„Su valor debe emparejarse con un ID definido en el mismo documento

Š

xs:ENTITY

„Se deriva de xs:NCName

„Su valor debe emparejarse con una entidad externa no analizada

XML-Schema

Tipos de datos: Cadena

Š xs:QName

„Soporta espacios de nombres con prefijo „Cada xs:QName contiene una tupla

{nombre de espacio de nombre, nombre local} nombre de espacio de nombre: URI asociada al prefijo

XML-Schema

Tipos de datos: Cadena

Š xs:QName

Ejemplo:

<xs:attribute name=“lang” type=“xs:language”/>

typees un xs:QName con valor

{“http://www.w3.org/2001/XMLSchema”, “languaje”} ya que

http://www.w3.org/2001/XMLSchemafue asignada al prefijo en:

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

XML-Schema

Tipos de datos: Cadena

Š

xs:QName

Ejemplo:

<xs:element ref=“book” maxOccurs=“unbounded”/>

refes un xs:QName con valor {“NULL”, “book”} ya que no se ha definido ningún espacio de nombres por defecto

XML-Schema

Tipos de datos: Cadena

Š

xs:anyURI

„El valor deberá cumplir las limitaciones de XML Ejemplo: el valor del atributo href

href=“http://www.unaweb.com/Français/”

Se convertirá al valor:

http://www.unaweb.com/Fran%e7ais/

XML-Schema

Tipos de datos: Cadena

Š

xs:hexBinary

„Permite codificar contenido binario como una cadena de caracteres traduciendo el valor de cada octeto binario en 2 dígitos hexadecimales

Š xs:base64Binary

„Corresponde a la codificación “base64”

„Agrupa series de 6 bits en un array de 64 caracteres imprimibles

XML-Schema

Tipos de datos: Numéricos

Š xs:decimal

„Representa números decimales arbitrariamente largos „El separador decimal es “.” y puede contener un signo inicial

(“+” o ”-”)

„No permite notación exponencial

„No puede contener caracteres distintos de los dígitos (tampoco espacios)

XML-Schema

Tipos de datos: Numéricos

Š xs:nonPositiveInteger

„Es un subconjunto de xs:integer: (negativos y cero) Š xs:negativeInteger

„Es un subconjunto de xs:nonPositiveInteger:(negativos) Š xs:nonNegativeInteger

„Es un subconjunto de xs:integer: (positivos y cero) Š xs:positiveInteger

XML-Schema

Tipos de datos: Numéricos

Š xs:long

„Enteros que pueden almacenarse en 64 bits

Š xs:int

„Enteros que pueden almacenarse en 32 bits Š xs:short

„Enteros que pueden almacenarse en 16 bits Š xs:byte

„Enteros que pueden almacenarse en 8 bits

XML-Schema

Tipos de datos: Numéricos

Š xs:unsignedLong

„Enteros no negativos que pueden almacenarse en 64 bits Š xs:unsignedInt

„Enteros no negativos que pueden almacenarse en 32 bits Š xs:unsignedShort

„Enteros no negativos que pueden almacenarse en 16 bits Š xs:unsignedByte

„Enteros no negativos que pueden almacenarse en 8 bits

XML-Schema

Tipos de datos: Numéricos

Š xs:float y xs:double

„Representa números en notación científica con potencia enteras de 10 „La diferencia entre ellos es la precisión (32 o 64 bits)

„Pueden contener valores “especiales”:

zINF, -INF, NaN (Not a Number)

XML-Schema

Tipos de datos: Numéricos

Š xs:boolean

XML-Schema

Tipos de datos: Fecha y Hora

Š Estos tipos son un subconjunto del estándar ISO 8601

Š Intenta eliminar la confusión entre los formatos utilizados en diferentes países

Š xs:dateTime

„Define un instante de tiempo concreto

„Formato: YYYY-MM-DDThh:mm:ss

„Ejemplo: 2003-10-21T20:30:13

„Se pueden expresar zona horarias

XML-Schema

Tipos de datos: Fecha y Hora

Š xs:date

„Define un día concreto del calendario Gregoriano

„Ejemplo: 2003-10-21

Š xs:gYearMonth y xs:gYear

„xs:gYearMonth es xs:date sin la parte de día (Ejemplo: 2003-10)

„xs:gYear es xs:gYearMonth sin la parte del mes (Ejemplo: 2003, -2000)

XML-Schema

Tipos de datos: Fecha y Hora

Š xs:time

„Define una hora concreta „Ejemplo: 10:21:23

Š xs:gDay, xs:gMonth y xs:gMonthDay

„xs:gDay es un día del calendario Gregoriano (---DD, ---25)

„xs:gMonthDay es un día de un mes del calendario Gregoriano (--MM-DD, --05-25)

„xs:gMonth es un mes del calendario Gregoriano (--MM, --05)

XML-Schema

Tipos de datos: Fecha y Hora

Š xs:duration

„Expresa una duración en un espacio de 6 dimensiones „Formato: PnYnMnDTnHnMnS

„Ninguno de los elementos es obligatorio ni tiene limitación de rango

XML-Schema

Tipos de datos: Lista

Lista de campos separados por espacios en blanco

Š xs:NMTOKENS

„Lista de xs:NMTOKEN separada por espacios Š xs:IDREFS

„Lista de xs:IDREF separada por espacios Š xs:ENTITIES

„Lista de xs:ENTITY separada por espacios

XML-Schema

Tipos de datos: anySimpleType

Š Acepta cualquier valor

Š Hay que evitarlo excepto cuando lo requieren las reglas

de derivación

XML-Schema

Supongamos que en nuestro ejemplo:

… <title lang= “en”> El último encuentro

</title> …

<qualification> severo, triste </qualification>

…

• Probablemente los espacios en blanco no son significativos y deberían no ser tenidos en cuenta

• En lugar del tipo xs:string les podemos asignar el tipo xs:token • El documento queda descrito de una manera más precisa

<?xml version=“1.0”?>

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

<xs:element name=“name” type=“xs:token”/> <xs:element name=“qualification” type=“xs:token”/>

<xs:element name=“born” type=“xs:date”/> <xs:element name=“dead” type=“xs:date”/>

<xs:element name=“isbn” type=“xs:NMTOKEN”/>

<xs:attribute name=“id” type=“xs:ID”/>

<xs:attribute name=“available” type=“xs:boolean”/> <xs:attribute name=“”> lang” type=“xs:language”/>

<xs:element name=“title> <xs:complexType> <xs:simpleContent> <xs:extension base=“xs:token”> <xs:attribute ref=“lang”/> </xs:extension> </xs:simpleContent> </xs:complexType> </xs:element> <xs:element name=“library”> <xs:complexType> <xs:sequence>

XML-Schema

Creación de nuevos tipos de datos

Š

Se pueden crear nuevos tipos de datos tomando como punto

de partida los tipos de datos existentes

Š A esta creación se la denomina “derivación”

Š Los métodos de derivación para los tipos simples y complejos

son muy diferentes

XML-Schema

Creación de nuevos tipos de datos

Š Existen 3 mecanismos de derivación:

„Por restricción „Por lista „Por Unión

XML-Schema

Creación de nuevos tipos de datos.

Derivación

por restricción

Š Los tipos de datos se crean añadiendo restricciones a los posibles valores Š W3C XML-Schema usa este mecanismo (xs:positiveInteger es una

derivación por restricción de xs:integer) Š Las restricciones se definen mediante facetas

Š Una restricción se añade con el elemento xs:restriction y cada faceta se define utilizando un elemento específico dentro de xs:restriction Š El tipo de dato que se restringe es denominado “base”

XML-Schema

XML-Schema

Creación de nuevos tipos de datos.

Derivación

por restricción. Facetas

Š Se clasifican en 3 categorías:

„Las que definen el procesamiento de espacios en blanco, tabuladores ... (actúan entre el espacio de análisis y el léxico) „Las que trabajan sobre el espacio léxico

„Las que restringen el espacio de valores

XML-Schema

Creación de nuevos tipos de datos.

Derivación por

restricción. Facetas

Š Facetas de cadenas con procesamiento de espacios en blanco:

„Los espacios iniciales y finales se eliminan, se sustituyen tab, line feed y CR por espacios y n espacios consecutivos se sustituyen por 1

„Estos tipos son: xs:ENTITY, xs:ID, xs:IDREF, xs:language, xs:Name, xs:NCName, xs:NMTOKEN, xs:token, xs:anyURI, xs:base64Binary, xs:hexBinary, xs:NOTATION, xs:QName

XML-Schema

Creación de nuevos tipos de datos.

Derivación por

restricción. Facetas

Š Facetas de cadenas con procesamiento de espacios en blanco:

„xs:enumeration: define una lista de posibles valores. Restringe el espacio de valores <xs:simpleType name=“schemaRecomm”> <xs:restriction base=“xs:anyURI”> <xs:enumeration value=“http://www.w3c.org/TR/x1”/> <xs:enumeration value=“http://www.w3c.org/TR/x2”/> <xs:enumeration value=“http://www.w3c.org/TR/x3”/> </xs:restriction> </xs:simpleType>

XML-Schema

Creación de nuevos tipos de datos.

Derivación por

restricción. Facetas

Š Facetas de cadenas con procesamiento de espacios en blanco:

„xs:length: define una longitud fija en nº de caracteres o bytes (xs:hexBinaryy xs:base64Binary)

XML-Schema

Creación de nuevos tipos de datos.

Derivación por

restricción. Facetas

Š Facetas de cadenas con procesamiento de espacios en blanco:

„xs:maxLength: define una longitud máxima en nº de caracteres o bytes (xs:hexBinaryy xs:base64Binary)

zRestringe el espacio de valores

<xs:simpleType name=“binaryImage”> <xs:restriction base=“xs:hexBinary”> <xs:maxLength value=“1024”/> </xs:restriction> </xs:simpleType>

XML-Schema

Creación de nuevos tipos de datos.

Derivación por

restricción. Facetas

Š Facetas de cadenas con procesamiento de espacios en blanco:

„xs:minLength: define una longitud mínima en nº de caracteres o bytes (xs:hexBinaryy xs:base64Binary)

zRestringe el espacio de valores

<xs:simpleType name=“longName”> <xs:restriction base=“xs:NCName”> <xs:minLength value=“6”/> </xs:restriction> </xs:simpleType>

XML-Schema

Creación de nuevos tipos de datos. Derivación por

restricción. Facetas

Š Facetas de cadenas con procesamiento de espacios en blanco:

„xs:pattern: define un patrón que debe emparejarse con la cadena

zRestringe el espacio de valores

<xs:simpleType name=“httpURI”> <xs:restriction base=“xs:anyURI”> <xs:pattern value=“http://.*”/> </xs:restriction> </xs:simpleType>

XML-Schema

Creación de nuevos tipos de datos. Derivación por

restricción. Facetas

ŠFacetas de tipos numéricos reales

(xs:float y xs:double): „xs:enumeration: permite definir una lista de posibles valores

zOpera en el espacio de valores

XML-Schema

Creación de nuevos tipos de datos. Derivación por

restricción. Facetas

ŠFacetas de tipos numéricos reales:

„xs:maxExclusive: define un valor máximo que no se puede alcanzar

„xs:maxInclusive: define un valor máximo que se puede alcanzar

„xs:minExclusive: define un valor mínimo que no se puede alcanzar

„xs:minInclusive: define un valor mínimo que se puede alcanzar

„xs:pattern: define un patrón que debe cumplir el valor léxico del tipo de datos

XML-Schema

Creación de nuevos tipos de datos. Derivación por

restricción. Facetas

Š

Facetas de tipos de fecha y hora:

„ Son las mismas que para los tipos numéricos reales

XML-Schema

Creación de nuevos tipos de datos. Derivación por

restricción. Facetas

Š Facetas de tipos enteros:

„ Las mismas facetas que para los tipos numéricos reales más: „xs:totalDigits: define el valor máximo de dígitos

zActúa sobre el espacio de valores <xs:simpleType name=“integer5Dig”>

<xs:restriction base=“xs:integer”> <xs:totalDigits value=“5”/> </xs:restriction>

</xs:simpleType>

“12345” y “00012345” son valores válidos para el tipo derivado

XML-Schema

Creación de nuevos tipos de datos.

Derivación

por lista

Š Se puede derivar un tipo de datos de lista a partir de un tipo de datos atómico

Š Todos los datos de la lista tienen que ser del mismo tipo

Š IDREFS, ENTITIES y NMTOKENS son listas predefinidas derivadas derivadas de los tipos atómicos utilizando este mecanismo

Š Solo se permiten las siguientes facetas: xs:length (nº de elementos),

XML-Schema

Creación de nuevos tipos de datos.

Derivación

por lista

Š La definición se realiza con el elemento xs:list

Ejemplo:

<xs:simpleType name=“integerList”> <xs:list itemType=“xs:integer”/> </xs:simpleType>

Este tipo de datos se puede utilizar con atributos y elementos para que acepten una lista de enteros separados por espacios, como: “1 –2345 200”

XML-Schema

Creación de nuevos tipos de datos.

Derivación

por lista

Š En la práctica las aplicaciones no pueden acceder directamente a los valores atómicos de estas listas a través de las actuales API´s y expresiones Xpath (se espera que con XPath 2.0 sí se pueda)

XML-Schema

Creación de nuevos tipos de datos.

Derivación

por unión

Š Permite definir nuevos tipos de datos fusionando los espacios léxicos de varios tipos predefinidos o definidos por el usuario

Š El tipo de dato resultante pierde la semántica y facetas de los tipos miembro Š Solo se permiten 2 facetas a un tipo de datos así derivado:

„xs:pattern

„xs:enumeration

Š La definición se realiza a través del elemento xs:union

XML-Schema

Creación de nuevos tipos de datos.

Derivación

por unión

<xs:simpleType name=“integerOrDate”>

XML-Schema

Ejemplo: Creación de nuevos tipos de datos

• Queremos limitar el tamaño de los datos de tipo cadena: 32 y 255 c. <xs:simpleType name=“string255”> <xs:restriction base=“xs:token”> <xs:maxLength value=“255”/> </xs:restriction> </xs:simpleType> <xs:simpleType name=“string32”> <xs:restriction base=“xs:token”> <xs:maxLength value=“32”/> </xs:restriction> </xs:simpleType>

XML-Schema

Ejemplo: Creación de nuevos tipos de datos

• Queremos limitar el nº de caracteres del ISBN a 10 <xs:simpleType name=“isbn”>

<xs:restriction base=“xs:NMTOKEN”> <xs:length value=“10”/> </xs:restriction>

</xs:simpleType>

• Queremos limitar los lenguajes del título (inglés y castellano): <xs:simpleType name=“supportedLanguages”> <xs:restriction base=“xs:language”> <xs:enumeration value=“en”/> <xs:enumeration value=“es”/> </xs:restriction> </xs:simpleType>

XML-Schema

<?xml version=“1.0”?> <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"> <xs:simpleType name=“string255”> <xs:restriction base=“xs:token”> <xs:maxLength value=“255”/> </xs:restriction> </xs:simpleType> <xs:simpleType name=“string32”> <xs:restriction base=“xs:token”> <xs:maxLength value=“32”/> </xs:restriction> </xs:simpleType> <xs:simpleType name=“isbn”> <xs:restriction base=“xs:NMTOKEN”> <xs:length value=“10”/> </xs:restriction> </xs:simpleType> <xs:simpleType name=“supportedLanguages”> <xs:restriction base=“xs:language”> <xs:enumeration value=“en”/> <xs:enumeration value=“es”/> </xs:restriction> </xs:simpleType>

<xs:element name=“name” type=“string32”/>

<xs:element name=“qualification” type=“string255”/>

<xs:element name=“born” type=“xs:date”/> <xs:element name=“dead” type=“xs:date”/>

<xs:element name=“isbn” type=“isbn”/>

• Primero podemos definir globalmente los tipos de datos derivados • Notad que no se hace uso del prefijo

XML-Schema

<xs:attribute name=“id” type=“xs:ID”/>

<xs:attribute name=“available” type=“xs:boolean”/> <xs:attribute name=“”> lang” type=“supportedLanguages”/>

<xs:element name=“title> <xs:complexType> <xs:simpleContent> <xs:extension base=“string255”> <xs:attribute ref=“lang”/> </xs:extension> </xs:simpleContent> </xs:complexType> </xs:element> <xs:element name=“library”> <xs:complexType> <xs:sequence>

<xs:element ref=“book” maxOccurs=“unbounded”/> </xs:sequence>

Lenguajes documentales

Š Bibliografía:

„[1]“XML al descubierto”. M. Morrison et al. Prentice Hall, 2000.

„[2] “XML Schema”. Eric van der Vlist, O’Reilly, 2002.