Consulta y transformación XML

AMPLIACIÓN DE BASES DE DATOS

Universidad de Las Palmas de Gran Canaria

Curso 2010/2011

Alumno:

Carmelo Cascone

-1 -
 Indice

1. Introducción .................................................................................4

2. XPath ...........................................................................................5

2.1. Tipos de nodos.............................................................................................6

2.2. Location Path ..............................................................................................8

Nodo contexto..............................................................................................8

Axis, Node Test, Predicate ..........................................................................9

Funciones de XPath ...................................................................................13

Ejemplos.....................................................................................................14

3. XSLT ..........................................................................................16

3.1. Estructura de hojas de estilo......................................................................18

Elementos de selección ...............................................................................19

Elementos de comparación .........................................................................22

Transformación de XML a XML................................................................24

4. XQuery .......................................................................................25

4.1. Características de XQuery .........................................................................26

4.2. Consultas XQuery ......................................................................................27

For..............................................................................................................27

Return........................................................................................................28

Where y Order By .....................................................................................28

Let..............................................................................................................29

Expresiones condicionales ..........................................................................30

Cuantificadores existenciales ......................................................................31

-2 -
-3 -
1. Introducción

XML (Extensible Markup Language) incluye tecnologías que permiten tanto con-
sultar como transformar los documentos XML, entre estas tecnologías destacan:

‣ XPath: es un lenguaje declarativo empleado para referenciar a determinadas

partes de los documentos XML. Las expresiones XPath se utilizan para locali-
zar un conjunto de nodos en un determinado documento.

‣ XSLT: lenguaje de transformación XML.

‣ XQuery: lenguaje de consulta para los datos almacenados en documentos

XML. Su principal función es obtener información de las bases de datos XML
(esto incluye las bases de datos relacionales que almacenan datos XML o que
presentan una vista XML de los datos almacenados).

Diversas tecnologías XML, como XSLT y XQuery, utilizan XPath como elemento
de soporte.

-4 -
2. XPath

Todo el procesamiento realizado con un fichero XML está basado en la posibilidad

de direccionar o acceder a cada una de las partes que lo componen, de modo que
podamos tratar cada uno de los elementos de forma diferenciada. XPath (XML
Path Language), es un lenguaje declarativo empleado para referenciar a determi-
nadas partes de los documentos XML. Las expresiones XPath se utilizan para lo-
calizar un conjunto de nodos en un determinado documento XML. Es importante
conocer los conceptos básicos de XPath ya que algunas tecnologías como XSLT y
XQuery (que veremos a continuación) lo usan.

Una expresión XPath identifica un conjunto de nodos en un documento XML. Es-

te conjunto de nodos puede contener 0 o más nodos. Una expresión es un trayecto
de búsqueda compuesto por uno o varios pasos de búsqueda separados por el ca-
rácter “/”.

XPath usa una notación con barras inclinadas (/) similar al terminal de UNIX.
Esto es para que XPath se pueda utilizar Uniformed Resource Identifiers (URIs),
tales como URLs. De aquí viene el nombre de XPath: el uso de una notación de
caminos como en las URLs.

Las expresiones XPath pueden incluir predicados. Los predicados contienen expre-
siones booleanas, las cuales comprueban cada nodo en el contexto del conjunto de
nodos. Si cumple la condición, el nodo es mantenido en el conjunto como nodo
identificado, en otro caso el nodo es descartado. Los predicados son usados en re-
ducciones del conjunto resultado. Las expresiones XPath pueden referenciar atri-
butos de los elementos XML.

XPath también proporciona funciones, las cuales pueden resultar muy útiles.

-5 -
2.1. Tipos de nodos

Un nodo es cada uno de los componentes de un documento XML. XPath muestra

o considera lógicamente un documento XML como un árbol de nodos. Los nodos
pueden ser de diferentes tipos, existiendo siete tipos:

‣ Root: es la propia entidad documento que contiene al resto de nodos.

‣ Element: existe un nodo de tipo elemento por cada elemento del documento
fuente XML.

‣ Attribute: son los definidos como atributos en el documento XML. Los nodos
atributo siempre pertenecen a algún elemento, nunca aparecen solos y no con-
tienen a ningún otro nodo.

‣ Text: los datos de tipo carácter en el documento XML se consideran como no-
dos de texto. Dentro de cada nodo de texto se agruparán el mayor número de
caracteres posibles, por lo que un nodo de texto jamás tendrá un following o
preceding sibling de tipo nodo de texto.

‣ Processing Instruction: existe un nodo de este tipo por cada instrucción de

procesamiento que aparezca en el documento XML.

‣ Comment: un nodo por cada comentario del documento XML

‣ Namespace: existe un nodo de este tipo por cada declaración de espacio de

nombres que aparece en el documento XML. Mención especial tiene lo que es
considerado como nodo contexto, aunque no se trata de un tipo. Este indica o
referencia al nodo actual, desde el que parte la búsqueda. Define el punto de
comienzo para la evaluación de la ruta de localización (location path).

Ejemplo: Arbol de nodos

<?xml version="1.0" ecoding="ISO-8859-1"?>

<bookstore>
<book>
<title lang="en">Harry Potter</title>
<author>J K. Rowling</author>
<year>2005</year>
<price>29.99</price>

-6 -
 </book>
</bookstore>

ERRNVWRUH

ERRN

WLWOH
ODQJHQ

DXWKRU

\HDU

SULFH

-7 -
2.2. Location Path

Un location path es la más importante de los tipos de expresiones que se pueden

especificar en notación XPath. La sintaxis de un location path es simliar a la usa-
da a la hora de describir los directorios que forman una unidad de disco en Unix o
Linux. Sin embargo, solo la sintaxis es lo similar al sistema de archivos. El signifi-
cado de las expresiones es totalmente diferente.

Ejemplo de URI en UNIX:

‣ /usr/home/docs/

Esta instrucción UNIX hace referencia a un único directorio: docs el cual cuelga de el
conjunto de directorios /usr/home.

Ejemplo de expresión XPath:

‣ /bookstore/book/author

Esta expresión XPath referencia a todos los elementos author que cuelguen directamente de
cualquier elemento book que cuelgue del nodo bookstore.

Hay que tener en cuenta que una expresión en XPath no devuelve los elementos
que cumplen con el patrón que representa dicha expresión, pero devuelve una re-
ferencia a dichos elementos; es decir, una expresión XPath nos devuelve una lista
de apuntadores a los elementos que encajan en el patrón. Dicha lista puede estar
vacía o contener uno o más nodos.

2.2.1. Nodo contexto

Un location path siempre tiene un punto de partida llamado nodo contexto. Para
entendir de manera mas sencilla el concepto se puede imaginar como el directorio
actual al cual nos referimos en un sistema de ficheros. Por ejemplo, en Unix, da-
mos una orden ls obtendremos los ficheros que existen en el directorio actual,
mientras que si decimos ls/usr/bin obtendremos una lista de los ficheros exis-

-8 -
tentes en el directorio /usr/bin con independencia del directorio en que estemos
colocados al dar la orden.

En los location path ocurre lo mismo. A menos que se indique un camino explíci-
to, se entenderá que el location path parte del nodo que en cada momento se esté
procesando.

Ejemplo:

‣ /bookstore/book/author

Partiendo de la raíz bookstore, que es el nodo contexto de inicio de esta expre-

sión, nos situamos en LOS nodos book que tras esta ejecución son el nuevo nodo
contexto.

2.2.2. Axis, Node Test, Predicate

El location path puede ser formado por tres partes:

AXIS :: NODE_TEST [PREDICATE]

Componiendo cada uno de estos elementos, come en el ejemplo abajo, es posible

referenciar elementos de manera mas completa.

Ejemplo:

‣ /bookstore/child::book/author[position() = 2]

Axis
El axis es la parte del location path que nos permite definir la relaccion de paren-
tesco entre el nodo contexto actual y el nuevo node-set que se quiere selecionar,
por ejemplo es posible definir relaciones como “los padres de.. los hijos de.. los
atributos de.. etc..”).

-9 -
 $;,6
12'2
5HODFLyQHQWUH 18(92
&217(;72
ORVGRV 12'(6(7
$&78$/

En XPath es posible especificar 13 tipos de axis (elencados en la tablas abajo) que

permiten de referenciar uno, varios o ningún nodo. Tambièn hay una forma abre-
viada para los axis principales que se adapta al estándar URI, por ejemplo la re-
lación de tipo ::child se puede indicar simplemente utilizando la barra /.

Ejemplo:

‣ /bookstore/child::book = /bookstore/child

Tabla de los axis disponibles en XPath

AXIS Descripción

::self Selecciona al propio nodo contexto, por tanto siempre se

forma abreviata . seleccionará un único nodo.

::attribute Selecciona un atributo del nodo contexto. Como solo los no-
dos de tipo elemento pueden tener atributos, si el nodo de
contexto no es de tipo elemento, el conjunto de nodos resul-
forma abreviata @ tante estará vacío.

::child Selecciona un nodo hijo o descendiente inmediato del nodo

contexto. No se consideran los atributos como hijos de los
elementos a los que pertenecen. Por tanto sólo tiene sentido
forma abreviata / para nodos de tipo elemento.

::descendant Selecciona todos los nodos descendientes, en cualquier nivel

de la jerarquía, del nodo actual. Sólo tienen descendientes el
forma abreviata // nodo raíz y los de tipo elemento.

::parent Selecciona todos los nodo padres del nodo contexto.

forma abreviata ./

::descendant-or‐self Selecciona todos los descendientes del nodo de contexto in-

cluyendo a él mismo.

- 10 -
 ::ancestor Selecciona todos los elementos hasta la raíz incluida, situa-
dos por encima del nodo contexto.

::ancestor‐or-self Todos los ascendientes incluido el nodo actual.

::preceding Selecciona todos los nodos elementos con el mismo nombre y

“completos” anteriores, es decir, al mismo nivel y con el
mismo nombre, pero situados antes que el nodo de contexto.

::preceding-sibling Selecciona todos los nodos anteriores hijos del mismo padre
que el nodo de contexto. (hermano anterior)

::following Selecciona todos los nodos con el mismo nombre que apare-
cen “por completo”, es decir, con sus descendientes, después
del nodo de contexto. (siguiente)

::following-sibling Selecciona todos los nodos siguientes hijos del mismo padre
que el nodo de contexto. (hermano siguiente)

::namespace Selecciona todos los espacios de nombres que tengan efecto

sobre el nodo de contexto actual.

Node Test

Los node test son algo así como funciones que nos van a ayudar a restringir lo que
nos devuelve una expresión XPath. Se utilizan para definir la tipología, o direc-
tamente el nombre, del nodo que queremos seleccionar, a partir de todos los no-
dos disponibles por el axis especificado. Por ejemplo: “todos los nodos de tipo tex-
to que son hijos de..” o “todos los nodos de tipo <author> que descendiendan
de..”).

Tabla de los node test disponibles en XPath

Node Test Descripción

* Selecciona todos los nodos de tipo prinicpal

(elemento, atributo o espacio de nombres), pero
no nodos de texto, comentarios, etc..

node() Cualquier nodo, de cualquier tipo.

test() Selecciona todos los nodos de tipo texto

- 11 -
 comment() Cualquier nodo de tipo comentario

processing-instruction() Selecciona todos los nodos de tipo de instrucción

de proceso, independientemente de su destino.

processing-instruction(destino) Cualquier nodo de tipo de instrucción de proceso

relativo al destino especificado.

processing-instruction(cursor) Cualquier nodo de tipo de instrucción de proceso

con el destino cursor.

Ejemplos de utilizo axis/node test

‣ child::book

Selecciona todos los nodos book que son hijos del nodo actual.

‣ attribute::lang

Selecciona el atributo lang del nodo actual.

‣ child::*

Selecciona todos los hijos del nodo actual.

‣ attribute::*

Selecciona todos los atributos del nodo actual.

‣ child::text()

Selecciona todos los nodos de tipo texto que son hijos del nodo actual.

‣ child::node()

Selecciona todos los nodos hijos del nodo actual.

‣ descendant::book

Selecciona todos los nodos book descendientes del nodo actual.

‣ ancestor::book

Selecciona todos los nodos book ancestros del nodo actual.

‣ ancestor-or-self::book

Selecciona todos los nodos book ancestros del nodo actual, y el actual si es también un
nodo book.

‣ child::*/child::price

Selecciona todos los nodos nietos de tipo price del nodo actual.

- 12 -
Predicate

Básicamente, un predicado permite restringir el conjunto de nodos seleccionados

por un axis y un node test a cuellos que cumplen cierta condición. Dicha condi-
ción es una expresión XPath y se específica entre corchetes. Esta condición hace
uso de operaciones con números, comparaciones de valores usando operadores re-
lacionales y comprobaciones de igualdad.

Ejemplo:

‣ /bookstore/book/title[@lang = "en"]

‣ /bookstore/book/title[not @lang = "it"]

‣ /bookstore/book[position() = 2]

‣ /bookstore/book[not position() = last()]

2.2.3. Funciones de XPath

XPath ofrece operaciones con números, comparaciones de valores usando operado-
res relacionales y comprobaciones de igualdad. Soporta los operadores: +, -, *,
div, mod. Para comparación de valores se usan los siguiente operadores: =, !=, <,
>, >=, <=, and, or.

Aparte de estos operadores, XPath, define funciones estándar para realizar opera-
ciones en nodos, cadenas (strings), valores numéricos y valores boléanos. Los
nombres y la sintaxis de esta funciones son muy parecidos a otros lenguajes de
programación

Es importante notar como en este caso el resultado de la evaluación de la expre-

sión no es un node-set, pero puede ser un valor numérico, una cadena o un valor
booleano.

- 13 -
2.2.4. Ejemplos
En este ejemplos se hace referencia a un documento XML que describe una libre-
ría, con al interior diversos tipos de elementos tales como libros, vídeos y música
así como es mostrado en la figura abajo.

bookstore.xml

<bookstore>
<book>
<title lang="es">...</title>
<aututhor>…</author>
…
</book>
…
<movie>
<title>…</title>
<director>…</director>
…
</movie>
…
<music>
<title>...</title>
<artist>...</artist>
<genre>...</genre>
…
</music>
…
</bookstore>

Ejemplos de expresiones XPath:

‣ /bookstore/child::book/child::title

Es igual a /bookstore/book/title, y selecciona todos los titulos de todos los libros.

‣ /bookstore/book[@available]

Selecciona todos los libros con atributo available declarado.

‣ /bookstore/*/title[@lang = 'it']

Selecciona todos los titles en italiano de todos los elementos.

‣ //genre/..

Selecciona todos los nodos que tengan algun hijo de tipo genre.

- 14 -
‣ //music[position() = last()]/node()

Selecciona todos los nodos del ultimo elemento music en el documento .

‣ /bookstore/*[title[@lang='es']][@available]/..

Selecciona todos los elementos (book, movie o music) que tengan un hijo de tipo title
con atributo lang = es y que tengan el atributo available declarado.

‣ count(/bookstore/*)

Devuelve el numero total de elementos de tipo book, movie, music.

‣ sum(//movie[director[text() = 'Woody Allen']]/price)

Devuelve la suma total del precio de todas las peliculas de Woody Allen.

‣ substring("xml is great", 1, 3)

Devuelve la cadena "xml"

- 15 -
3. XSLT

XSLT (eXtensible Stylesheet Language Transformations) es un estándar de la or-

ganización W3C que presenta una forma de transformar documentos XML en
otros, incluyendo formatos que no son XML. Las hojas de estilo XSLT realizan la
transformación del documento utilizando una o varias reglas de plantilla. Estas
reglas de plantilla unidas al documento fuente a transformar alimentan un proce-
sador de XSLT, el que realiza las transformaciones deseadas poniendo el resultado
en un archivo de salida. Se puede utilizar XSLT para transformar documentos
XML en otros documentos XML, o también en otros formatos como HTML,
WML, o en cualquier formato compatible. Actualmente, XSLT es muy usado en
la edición web, generando páginas HTML o XHTML.

'RFXPHQWR
;0/

'RFXPHQWR
3URFHVDGRU;6/ +70/

7HPSODWH
;6/

La función principal de XSLT es la posibilidad de separar contenido y presenta-

ción en un documento XML, aumentando así la productividad. En estos ultimo
años XML se ha convertido en un medio popular para representar los datos. Una
necesidad para hacer uso de los datos alojados en los documentos XML es la ca-
pacidad de acceso y manipulación de los datos.

- 16 -
Una hoja de estilos XSLT se compone de templates, reglas que ajustan especifica-
ciones a las partes de un documento XML y permiten la transformación del su
contenido. Ofrece una gran variedad de opciones para extraer datos de un docu-
mento XML y sobre la manipulación de los mismos.

- 17 -
3.1. Estructura de hojas de estilo

Una hoja de estilos XSLT es un documento XML, que debe estar bien formado.
Se guardan como archivo independiente con extensión .xsl. Una vez escrita la hoja
de estilos XSLT usando elementos definidos en el espacio de nombres XSLT, es
possible referenciar esa hoja de estilos en el documento XML a trasformar utili-
zando la etiqueta xml-stylesheet.

Ejemplo de declaración de una hoja de estilo en un documento XML:

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

<?xml-stylesheet type="text/xsl" href="cdcatalog.xsl"?>
<catalog>
<cd>
<title>Empire Burlesque</title>
<artist>Bob Dylan</artist>
<country>USA</country>
<company>Columbia</company>
…

La hoja de estilos es un documento XML, por este motivo debe comenzar con una
declaración XML <?xml version=“1.0”?>. El elemento raíz de la hoja de estilo
XSLT es el elemento stylsheet. Este elemento contendrá a todos los demás, y debe
ir precedido por el alias XSL correspondiente al espacio de nombres para hojas de
estilo XSLT. Los nombres de los elementos a utilizar en la hoja de estilos, proce-
den de un mismo espacio de nombre, y por lo tanto deben escribirse precedidos
por el correspondiente alias.

Ejemplo de elemento raiz de un documento xsl

<xsl:stylesheet version="1.0"
<xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
…
</xsl:stylesheet>

- 18 -
3.1.1. Elementos de selección

xsl:template

El elemento template indica qué instancias de los elementos del documento XML
se van a transformar y cómo se deben transformar cada una de ellas. El atributo
match indica el juntos de nodos XML que se quiere transformar (patrón). En el
mismo documento XSL puede haber diferentes template asociados al mismo o di-
ferente patrón XPath. Diferentes template producen diferentes salidas.

Ejemplo:

<xsl:template match="/">
<html>
<head>
<title>Ejemplo Muy Simple</title>
</head>
<body>
<center><h2>Patrón ajustado con el NODO RAÍZ</h2></center>
</body>
</html>
</xsl:template>

Aplicando esta hoja de estilos a un documento XML, la regla se aplicará a todas las
instancias del elemento raíz, es decir una sola vez.

El procesador XSL trabaja con el documento XML y la hoja de estilos XSL. Ini-
cialmente busca un patrón que coincida con una regla template (la búsqueda es
jerárquica). Como al documento XML es accedido elemento por elemento, el atri-
buto match (patrón) de cada template es comparado con cada elemento. El proce-
sador de XSL accede al documento XML de arriba a abajo, de modo que el proce-
so de correspondencia es secuencial. Una vez determinado el template correcto,
produce la salida tras ejecutar el cuerpo del template. Finalmente comprueba si
hay más templates que coincidan con el patrón o ha de finalizar.

Ejemplo de utilizo de un template:

<xsl:template match="/bookstore">   
<html>

- 19 -
 <head><title>Book Store</title></head>
<body>
<center><h2>Hello this is a Book Store</h2></center>
<b>Lista de los libros:</b>
<ul>
<xsl:apply-templates select="book"/>
</ul>     
</body>
</html>
</xsl:template>

<xsl:template match="book">  
<xsl:for-each select="."> 
<li><xsl:value-of select="title" /></li>
</xsl:for-each>
</xsl:template>

Ejemplo de salida:

Hello this is a Book Store

Lista de libros:
• Harry Potter
• La Divina Commedia
• Pregúntale al polvo
• Crítica de la razón pura

xsl:output

Este elemento define el tipo de salida asociada a la hoja de estilos. Una misma
hoja puede tener múltiples elementos de este tipo. Generalmente es declarado in-
mediatamente después del elemento xsl:stylesheet.

- 20 -
Sintaxis:

<xsl:output
method = "xml"|"html"|"text"
version = nmtoken
encoding = "cadena de codificación" />

Ejemplo:

<xsl:output method="xml" version="1.0"

encoding="UTF-8" indent="yes"/>

xsl:include & xsl:import

Permite reutilizar hojas de estilo. Permite insertar varias hojas de estilo en una
hoja dada. Estos elementos pueden hacer posible la reutilización de templates de-
finidos en otras hojas de estilo. La inclusión de múltiples hojas puede provocar
errores de duplicidad. Una hoja de estilos se identifica por su URI.

Ejemplo:

<xsl:import href="products.xslt" />

<xsl:include href="products.xslt" />

xsl:value-of
Nos permite trabajar con los contenidos de los nodos. Nos devuelve la primera
instancia resultado de la consulta que encaje con el patrón.

Ejemplo:

<xsl:value‐of select="book/title/@lang"/>

- 21 -
xsl:for-each

Con este elemento es possible iterar a través del conjunto de nodos seleccionados.
Tiene un atributo select que selecciona los nodos a través de la expresión XPath.
Una vez los nodos son seleccionado la declaración interior del elemento
xsl:for-each se ejecuta para cada nodo.

Ejemplo:

<xsl:template match="book">
<xsl:for-each select="author">
<xsl:value-of select="." />
</xsl:for-each>
</xsl:template>

xsl:sort
Permite ordenar los resultados obtenidos al procesar el junto de nodos obtenido a
través de un xsl:foreach.

Ejemplo:

<xsl:for-each select="book">
<xsl:sort select="author" />
<xsl:value-of select="title"/>
</xsl:for-each>

3.1.2. Elementos de comparación

xsl:if
Este elemento chequea condiciones y es similar a un la declaración “if” de otros
lenguajes de programación. Especifica la condición que se quiere comprobar en el
atributo test. Si la evaluación es verdadera entonces el cuerpo del elemento es eje-
cutada.

- 22 -
Ejemplo:

<xsl:for-each select="book">
<xsl:if test="author = 'J K Rowling'" />
<xsl:value-of select="title"/>
</xsl:if>
</xsl:for-each>

xsl:choose, xsl:when & xsl:otherwise

A diferencia de otros lenguajes de programación, XSLT no tiene un “if-elseif” pa-

ra construir múltiples condiciones. En este caso el elemento xsl:choose que es símil
a las declaraciones switch-case-default en otro lenguaje de programación. Con este
elemento se puede comprobar múltiples condiciones. Cada condición es compro-
bada con el elemento xsl:when. Para comprobar múltiples condiciones, se incluyen
varios elementos xsl:when. Un elemento xsl:choose puede también tener un ele-
mento xsl:otherwise, cuando ninguna expresión en los elementos xsl:when evalua-
da es verdadera el cuerpo del elemento xsl:otherwise será ejecutado.

Ejemplo:

<xsl:for-each select="book">
<xsl:choose>
<xsl:when test="title/@lang = 'it'" />
Titulo Italiano: <xsl:value-of select="title"/>
</xsl:when>
<xsl:when test="title/@lang = 'es'" />
Titulo Español: <xsl:value-of select="title"/>
</xsl:when>
<xsl:otherwise />
<xsl:value-of select="title"/>
</xsl:otherwise>
</xsl:choose>
</xsl:for-each>

- 23 -
3.1.3. Transformación de XML a XML
El lenguaje XSL incluye también elementos particulares para trasformar docu-
mentos xml en otros documentos XML. Esto tipo de transformación son muy úti-
les porque permiten de crear nuevos documentos XML que incluyen datos de
otros documentos cambiando el formato y adaptarlos para aplicaciones específicas.

Ejemplo:

<xsl:element name="title">
<xsl:attribute name="lang">en</xsl:attribute>
<xsl:text>Harry Potter</xsl:text>
</xsl:element>

Salida:

<title lang='en'>Harry Potter</title>

- 24 -
4. XQuery

XQuery es un lenguaje de consulta diseñado para consultar colecciones de datos

XML. XQuery para XML es como SQL para bases de datos, pero mucho más ver-
sátil. El XQuery 1.0 fue desarrollado por el grupo de trabajo de Consulta XML
del W3C.

XQuery proporciona los medios para extraer y manipular información de docu-

mentos XML, o de cualquier fuente de datos que pueda ser representada mediante
XML. XQuery utiliza expresiones XPath para acceder a determinadas partes del
documento XML. Añade además unas expresiones similares a las usadas en SQL,
conocidas como expresiones FLWOR. Las expresiones FLWOR toman su nombre
de los 5 tipos de sentencias de las que pueden estar compuestas: for, let, where,
order by y return.

También incluye la posibilidad de construir nuevos documentos XML a partir de

los resultados de la consulta. Se puede usar una sintaxis similar a XML si la es-
tructura (elementos y atributos) es conocida con antelación, o usar expresiones de
construcción dinámica de nodos en caso contrario. Todos estos constructores se
definen como expresiones dentro del lenguaje, y se pueden anidar arbitrariamente.

XQuery 1.0 no incluye capacidad de actualizar los documentos XML. Tampoco

puede realizar búsquedas textuales. Estas dos capacidades están siendo objeto de
desarrollo para su posible incorporación en la siguiente versión del lenguaje.

- 25 -
4.1. Características de XQuery

El grupo de trabajo de XQuery del W3C ha definido un conjunto de requerimien-

tos técnicos para este lenguaje muy símil a los de SQL. Los más importantes se
detallan a continuación:
‣ XQuery debe ser un lenguaje declarativo. Al igual que SQL hay que indicar
que se quiere, no la manera de obtenerlo.
‣ XQuery debe ser independiente del protocolo de acceso a la colección de da-
tos. Una consulta en XQuery debe funcionar igual al consultar un archivo lo-
cal que al consultar un servidor de bases de datos que al consultar un archivo
XML en un servidor web.
‣ Las consultas y los resultados deben respetar el modelo de datos XML.
‣ Debe ser capaz de soportar XML‐Schemas y DTDs y también debe ser capaz
de trabajar sin ninguno de ellos.
‣ XQuery debe poder trabajar con independencia de la estructura del docu-
mento, esto es, sin necesidad de conocerla.
‣ XQuery debe soportar tipos simples, como enteros y cadenas, y tipos comple-
jos, como un nodo compuesto por varios nodos hijos.
‣ Las consultas deben soportar cuantificadores universales y existenciales.
‣ Las consultas deben soportar operaciones sobre jerarquías de nodos y secuen-
cias de nodos.
‣ Debe ser posible en una consulta combinar información de múltiples fuentes.
‣ Las consultas deben ser capaces de manipular los datos independientemente
del origen de estos.
‣ Mediante XQuery debe ser posible definir consultas que transformen las es-
tructuras de información originales y debe ser posible crear nuevas estructu-
ras de datos.
‣ El lenguaje de consulta debe ser independiente de la sintaxis, esto es, debe
ser posible que existan varias sintaxis distintas para expresar una misma con-
sulta en XQuery.

- 26 -
4.2. Consultas XQuery

Una consulta en XQuery es una expresión que lee una secuencia de datos en XML
y devuelve como resultado otra secuencia de datos en XML. Un detalle importan-
te es que, a diferencia de lo que sucede en SQL, en XQuery las expresiones y los
valores que devuelven son dependientes del contexto. Aunque XQuery y SQL
puedan considerarse similares, el modelo de datos sobre el que se sustenta XQuery
es muy distinto del modelo de datos relacional sobre el que sustenta SQL, ya que
XML incluye conceptos como jerarquía y orden de los datos que no están presen-
tes en el modelo relacional.

A continuación se examinan las expresiones necesarias para ejecutar una consulta

XQuery.

4.2.1. For
La cláusula for es la sentencia principal de una consulta XQuery. Es utilizada pa-
ra vincular una o más variables a expresiones escritas en XPath, creando un flujo
de tuplas en el que cada tupla está vinculada a una de las variable.

Ejemplo de consulta:

for $x in doc("books.xml")/bookstore/book
return $x/title

Salida:

<title lang="en">Harry Potter</title>

<title lang="it">La Divina Commedia</title>
<title lang="en">Learning XML</title>
<title lang="en">XQuery Kick Start</title>

En el ejemplo anterior de cláusula for, la variable $x toma como valor cada uno
de los nodos book que contenga el archivo “books.xml”. Cada uno de esos nodos
book, será una tupla vinculada a la variable $x.

- 27 -
4.2.2. Return
La cláusula return es utilizada para construir el resultado de la consulta. La sali-
da se obtendrá en formato XML y con la estructura que se indique dentro de esta
cláusula.

Ejemplo de consulta:

for $x in doc("books.xml")/bookstore/book/title
return
<book>
{$x}
</book>

Salida:

<book>
<title lang="en">Harry Potter</title>
</book>
<book>
<title lang="it">La Divina Commedia</title>
</book>
…

Es importante notar come en este caso el comportamiento de la cláusula return se

adapta al contexto de la consulta. En este caso el argumento de la clausula for es
la variable $x, la cual toma como valor todos los nodos te tipo title. La return se
ejecuta por cada valor (tupla) contenido en la variable. Se entiende como la sen-
tencia return es estrictamente relacionada con la sentencia for de una forma “por
cada valor en la variable $x retorna..”.

4.2.3. Where y Order By

La cláusula where es utilizada para filtrar todas las tuplas eliminando todos los
valores que no cumplan las condiciones dadas, mientra order by permite de orde-
nar las tuplas según el criterio dado.

- 28 -
Ejemplo:

for $x in doc("books.xml")/bookstore/book
where $x/price > 30
order by $x/title
return $x/title

Salida:

<title lang="en">Harry Potter</title>

<title lang="en">XQuery Kick Start</title>

4.2.4. Let
La clausula let es utilizada para vincular una variable al resultado completo de
una expresión XPath. A diferencia de una for, cuando se utiliza una let todas las
tuplas resultantes de la expresión XPath son asociadas la variable.

Ejemplo de consulta:

let $p := doc("books.xml")/bookstore/book
return
<books>{$p/title}</books>

Salida:

<books>
<title lang="en">Harry Potter</title>
<title lang="it">La Divina Commedia</title>
<title lang="en">Learning XML</title>
<title lang="en">XQuery Kick Start</title>
</books>

En este caso la return es repetida solo una vez, a demostración que utilizando una
let lo que se almacena en la variable es todo el resultado de la expresión XPath.

A seguir un ejemplo mas complejo que describe como utilizar una for y una let en
la misma consulta, produciendo un resultado símil a una join en SQL.

- 29 -
Ejemplo:

let $books := doc("books.xml"),

$otherbooks := doc("other_books.xml")

for $b in $books/bookstore/book,
$ob in $otherbooks/bookstore/book

where $b/isbn = $ob/isbn

and $b/price > $ob/price

return
<book>
{$b/title, $b/price}
</book>

Salida:

<book>
  <title lang="en">Harry Potter</title>
  <price>29.90</price>
</book>
<book>
  <title lang="it">La Divina Commedia</title>
  <price>30.95</price>
</book>

4.2.5. Expresiones condicionales

XQuery también soporta expresiones condicionales del tipo if-then-else con la
misma semántica que en los lenguajes de programación más habituales (C, Java).
If-then-else en la cláusula return condiciona la estructura XML del resultado. A
diferencia de la mayoría de los lenguajes, la cláusula else es obligatoria y debe
aparecer siempre en la expresión condicional. El motivo de esto es que toda expre-
sión en XQuery debe devolver un valor. Si no existe ningún valor a devolver al no
cumplirse la cláusula if, devolvemos una secuencia vacía con else().

- 30 -
Ejemplo:

for $b in doc("books.xml")/bookstore/book
return
  if ($b/@lang="it") then
     <italian>{data($b/title)}</italian>
  else
     <english>{data($b/title)}</english>

Salida:

<english>Harry Potter</english>
<italian>La Divina Commedia</italian>
<english>Learning XML</english>
<english>XQuery Kick Start</english>

4.2.6. Cuantificadores existenciales

En la cláusula where, XQuery soporta dos cuantificadores existenciales llamados

“some” y “every”, de tal manera que nos permite definir consultas que devuelva
algún elemento que satisfaga la condición (some) o consultas que devuelvan los
elementos en los que todos sus nodos satisfagan la condición (every).

‣ Some: “alguno” de los nodos seleccionados cumple la condición.

‣ Every: “todos” los nodos seleccionados cumplen la condición.

Ejemplo: movies.xml

<movie>
  <title>La Dolce Vita</title>
  <actors>
    <name>Marcello Mastroianni</name>
    <name>Anita Ekberg</name>
    <name>Alain Curry</name>
    ...
  <actors>
</movie>
<movie>
  <title>Otto e mezzo</title>

- 31 -
   <actors>
    <name>Marcello Mastroianni</name>
    <name>Claudia Cardinale</name>
    <name>Sandra Milo</name>
    ...
  <actors>
</movie>

Consulta:

<actor>
<name>Marcello Mastroianni</name>
<movie>
{
for $m in doc("movies.xml")/moviestore/movie

where some $a in $m/actors/name

  satisfies ($a="Marcello Mastroianni")

return
  $b/title
}
</movie>
</actor>

Salida:

<actor>
<name>Marcello Mastroianni</name>
<movies>
  <title>La Dolce Vita</title>
  <title>Otto e Mezzo</title>
</movies>
</actor>

- 32 -