Java Expert

XQuery was devised primarily as a query language for data stored in XML form. So its main role is to get information out of XML databases.

Here's an XQuery that simply retrieves and displays the whole document:

doc('http://www.stylusstudio.com/examples/videos.xml')

The file contains a number of sections. One of them is an <actors> element, which we can select like this:

.//actors

This produces the result:

<actors>
<actor id="00000015">Anderson, Jeff</actor>
<actor id="00000030">Bishop, Kevin</actor>
<actor id="0000000f">Bonet, Lisa</actor>
...etc...
</actors>

A little more complex:

.//actors/actor[ends-with(., 'Lisa')]

gives the output:

<actor id="0000000f">Bonet, Lisa</actor>
<actor id="0000001b">Spoonhauer, Lisa</actor>

This XPath expression has two parts: a path .//actors/actor that indicates which elements we are interested in, and a predicate [endswith(., 'Lisa')] that indicates a test that the nodes must satisfy.

Let's suppose we want to find the titles of all the videos featuring an actor whose first name is Lisa:

//video[actorRef=//actors/actor[ends-with(., 'Lisa')]/@id]/title

XQuery FLWOR Expressions

XQuery allows you to write join queries in a similar way to the familiar SQL approach. Its equivalent of SQL's SELECT expression is called the FLWOR expression, named after its five clauses: for, let, where, order by, return.

Here's the previous example, rewritten this time as a FLWOR expression (and ordered by release date):

let $doc := .
for $v in $doc//video,
$a in $doc//actors/actor
where ends-with($a, 'Lisa')
and $v/actorRef = $a/@id
order by $v/year
return $v/title

If you've got a real database, the form of the queries won't need to change all that much from these examples. Instead of using the doc() function (or simply ".") to select a document, you're likely to call the collection() function to open a database, or a specific collection of documents within a database.

Examples by Michael Kay/Stylusstudio.

This primer is based on Michael Kay's "XSLT 2.0 and XPath 2.0, Programmer's Reference, 4th Edition". Some software engineering experience is assumed, otherwise you might need to brush up on XML and/or regular expressions. I will not go into how things were done with XSLT 1, I leave that for the masochists out there :)

So what is this all about? An XSLT processor parses a source document into a source tree, then applies a stylesheet to perform (complex) manipulations on the tree nodes, and produces a result document by serializing the result tree. To select the data (nodes) to be processed, XPath expressions are used.

Let's start with this: Once a value has been given to a variable, it cannot be changed! No big thing for all you 'functional programming' adepts, but everyone else will have to get used to a lot of recursion. Without assignment statements, we can do things in any order, because the result of one statement can no longer depend on what state the system was left in by the previous statement.

Before we dive in, we need to know a little about the seven kinds of nodes in the tree.

-Document		: One for each document, no parent, always the root of a tree.
-Element		: A part bounded by start and end tags, or empty such as <TAG/>.
-Text			: A sequence of consecutive characters.
-Attribute		: The name and value of an attribute written within an element start tag (except namespaces).
-Comment		: A comment written between <!-- and -->
-Processing instruction	: An instruction written between <? and ?> 
-Namespace		: A namespace declaration