PDF de programación - XQuery

Departamento de Lenguajes y Sistemas Informáticos
Escuela Técnica Superior de Ingeniería

Avda Reina Mercedes, s/n. 41012 SEVILLA

Fax : 95 455 71 39. Tlf: 95 455 71 39. E-mail: [email protected]

Informática

Universidad de Sevilla

XQuery

J. J. Gutiérrez, M. J. Escalona, M. Mejías, J. Torres, D.Villadiego



Universidad de Sevilla

Lenguajes y Sistemas Informáticos

España

{javierj, escalona, risoto, torres}@lsi.us.es

Sevilla, Febrero de 2005

1



HOJA DE CONTROL DE MODIFICACIONES



Número Fecha
0

Descripción

06 – 2.004 Desarrollo Inicial

Correcciones del proceso de
evaluación



1

03 – 2005



Autores
Los autores

Los autores



2

Índice.

1. Introducción............................................................................................4
1.1. ¿Por qué necesitamos XQuery?. ......................................................................... 5
2. Definición de XQuery. ...........................................................................7
2.1. Requerimientos técnicos de XQuery. ................................................................. 7
2.2. Colección de datos de ejemplo. .......................................................................... 8
3. Consultas en XQuery............................................................................11
3.1. Reglas generales................................................................................................ 14
3.2. Diferencias entre las cláusulas for y let. ........................................................... 15
3.3. Funciones de entrada. ....................................................................................... 17
3.4. Expresiones condicionales................................................................................ 17
3.5. Cuantificadores existenciales:........................................................................... 19
3.6. Operadores y funciones principales.................................................................. 20
3.7. Comentarios...................................................................................................... 23
3.8. XQueryX........................................................................................................... 24
3.9. Ejemplos de consultas....................................................................................... 25
4. XQuery y Java. .....................................................................................31
4.1. XQEngine. ........................................................................................................ 31
4.2. Ejecutando consultas con XQEngine................................................................ 31
4.3. Embebiendo XQEngine en una aplicación Java. .............................................. 35
4.4. Otros motores XQuery open-source. ................................................................ 37
4.5. Otras herramientas relacionadas con XQuery................................................... 37
5. Conclusiones.........................................................................................39
6. Referencias y enlaces. ..........................................................................40
Apéndice I. Parses SAX y DOM..............................................................41
SAX. ........................................................................................................................ 41
DOM. ....................................................................................................................... 41
Apéndice II. XML Binding ......................................................................42
Apéndice III. Xpath..................................................................................44
Apéndice IV. Conjunto de documentos que describen XQuery y XPath.47

3



1. Introducción.


Extensible Markup Language[1] (más conocido como XML) es un formato para
almacenar datos extremadamente versátil, utilizado para representar una gran cantidad
distinta de información como, por ejemplo, páginas web (XHTML), mensajes web entre
aplicaciones (SOAP), libros y artículos, datos de negocio, representación de bases de
datos relacionales, interfaces de usuario (XUL), transacciones financieras y bancarias,
partidas de ajedrez, recetas de cocina, trazas del sistema, gráficos vectoriales (SVG),
sindicación de contenidos (RSS), archivos de configuración, documentos de texto
(OpenOffice.org) y manuscritos en griego clásico.

Un conjunto de datos expresados en XML es una cadena de texto donde cada
uno de los datos está delimitado por etiquetas de la forma <T> ... </T> o se incluye
como atributo de una etiqueta de la forma <T A=”...”> ... </T>. Mediante esta
representación es posible expresar también la semántica de cada uno de los datos.

A continuación se muestra un conjunto de datos en XML que contiene
información sobre un libro titulado “TCP/IP Illustrated”, escrito por “Stevens, W.”,
editado por “Addison-Wesley” y cuyo precio es 69.95.


<bib>
<libro>
<titulo>TCP/IP Illustrated</titulo>
<autor>



<editorial>Addison-Wesley</editorial>
<precio> 65.95</precio>
</libro>
</bib>



<apellido>Stevens</apellido>
<nombre>W.</nombre>



</autor>

En XML las etiquetas se estructuran en forma de árbol n-ário. En la figura 1 se

muestra la estructura en árbol del conjunto de datos referidos al libro.



4

<bib>

<libro>

<titulo>

<autor>

<editorial>

<precio>

<apellido>

<nombre>



Figura 1. Representación en forma de árbol de un conjunto de etiquetas XML.

1.1. ¿Por qué necesitamos XQuery?.

Actualmente, XML se ha convertido en una herramienta de uso cotidiano en los
entornos de tratamiento de información y en los entornos de programación. Sin
embargo, a medida que se emplea en un mayor número de proyectos de complejidad y
tamaño crecientes y la cantidad de datos almacenados en XML aumenta, se comprueba
que, las herramientas más habituales para manipular desde un programa un árbol con un
conjunto de datos en XML, los parsers SAX y DOM1, no son prácticas para manejar
grandes y complejas colecciones de datos en XML.

El principal problema a la hora de procesar colecciones de datos en XML a bajo
nivel mediante parsers DOM y SAX es la necesidad de escribir una gran cantidad de
código para realizar el procesamiento. Este código consiste, básicamente, en recorrer un
árbol, para un parser DOM, o detallar una lista de acciones según la etiqueta que se
encuentre para parser SAX.

Posteriormente a los parsers DOM y SAX, ha aparecido una nueva familia de
herramientas conocidas genéricamente como bindings2, que, si bien en ciertos aspectos
son tremendamente útiles y ahorran una gran cantidad de trabajo, no son útiles en todas
las situaciones en las que se puede utilizar XML.

Otra solución existente en la actualidad es el estándar XSLT[3] que permite
definir transformaciones sobre colecciones datos en XML en otros formatos, como
HTML o PDF y las herramientas que le dan soporte. Sin embargo XSLT sólo es
aplicable en los casos en los que desee obtener una representación distinta de los datos,
no cuando se desea localizar una información concreta dentro de dicho conjunto de
datos.

Un ejemplo de un escenario donde no es aplicable ninguna de las herramientas
comentadas hasta ahora (parsers, binding y XSLT) lo encontramos a la hora de
consultar la información en los actuales servidores de bases de datos que ya incorporan

1 Para una descripción del modo de trabajo y características principales de los parsers SAX y DOM
consultar el apéndice I.
2 Para más información sobre la manera de trabajar y un listado de herramientas de binding consultar el
apéndice II.



5

funciones para poder obtener los datos en XML o bases de datos XML nativas (Native
XML Database). El escenario de uso más común se da cuando tenemos que realizar
alguna búsqueda en un documento o conjunto de documentos con gran cantidad de
datos en XML, o bien hemos de trabajar sólo sobre un subconjunto de todos los datos
XML y queremos obtener dicho subconjunto de una forma sencilla, para evitar trabajar
con toda la colección de datos.

Dar solución a este escenario de uso mediante código escrito con la ayuda de un
parser SAX es rápido y sencillo de desarrollar si la consulta y la estructura de la
información no tienen una gran complejidad. A medida que la consulta va ganando en
complejidad, es necesario definir comportamientos más complejos a ejecutar cuando se
encuentre una etiqueta y se necesita un mayor número de almacenamientos temporales
de datos. Otro problema es que el código está fuertemente ligado a la estructura de los
datos en XML, por lo que cualquier cambio en la consulta o en la estructura de los datos
obliga a volver a escribir el código. Además el código resultante es muy poco
parametrizable y reutilizable por lo que para desarrollar una consulta similar habría que
volverla a escribir desde el principio, sin poder aprovechar nada de lo escrito. Dar
solución a este escenario de uso mediante código escrito con la ayuda un parser DOM
añade, a los problemas de reusabilidad, complejidad y fuerte acoplamiento anteriores, la
exigencia de tener cargar los datos en memoria antes de comenzar el recorrido, lo cual
puede resultar imposible para grandes volúmenes de datos.

Las herramientas de bindings favorecen la sencillez en el proceso de carga