From the Publisher

What is this book about?

XPath 2.0 Programmer's Reference is the only authoritative reference on XPath, a sub-language within XSLT that determines which part of an XML document the XSLT transforms. Written for professional programmers who use XML every day but find the W3C XPath specifications tough to slog through, this book explains in everyday language what every construct in the language does and how to use it. It also offers background material on the design thinking behind the language, gentle criticism of the language specification when appropriate, and a diverse range of interesting examples in various application areas.

Product Details

• Table of Contents
• Read a Sample Chapter

Table of Contents

Read a Sample Chapter

XPath 2.0 Programmer's Reference

John Wiley & Sons

Chapter One

One of the most notable innovations in XPath 2.0 is the ability to construct and manipulate sequences. This chapter is devoted to an explanation of the constructs in the language that help achieve this.

Sequences can consist either of nodes, or of atomic values, or of a mixture of the two. Sequences containing nodes only are a generalization of the node-sets offered by XPath 1.0. In the previous chapter we looked at the operators for manipulating node-sets, in particular, path expressions, and the operators «union», «intersect», and «except».

In this chapter we look at constructs that can manipulate any sequence, whether it contains nodes, atomic values, or both. Specifically, the chapter covers the following constructs:

Sequence concatenation operator: «,»

Numeric range operator: «to»

Filter expressions: «a[b]»

Mapping expressions: «for»

Quantified expressions: «some» and «every»

First, some general remarks about sequences.

Sequences (unlike nodes) do not have any concept of identity. Given two values that are both sequences, you can ask (in various ways) whether they have the same contents, but you cannot ask whether they are the same sequence.

Sequences are immutable. This is part of what it means for a language to be free of side effects. You can write expressions that take sequences as input and produce new sequences as output, but you can never modify an existing sequence in place.

Sequences cannot be nested. If you want to construct trees, build them as XML trees using nodes rather than atomic values.

A single item is a sequence of length one, so any operation that applies to sequences also applies to single items.

Sequences do not have any kind of type label that is separate from the type labels attached to the items in the sequence. As we will see in Chapter 9, you can ask whether a sequence is an instance of a particular sequence type, but the question can be answered simply by looking at the number of items in the sequence, and at the type labels attached to each item. It follows that there is no such thing as (for example) an "empty sequence of integers" as distinct from an "empty sequence of strings". If the sequence has no items in it, then it also carries no type label. This has some real practical consequences, for example, the sum() function, when applied to an expression that can only ever return a sequence of xs:duration values, will return the integer 0 (not the zero-length duration) when the sequence is empty, because there is no way at runtime of knowing that if the sequence hadn't been empty, its items would have been durations.

Functions and operators that attach position numbers to the items in a sequence always identify the first item as number 1 (one), not zero. (Although programming with a base of zero tends to be more convenient, Joe Public has not yet been educated into thinking of the first paragraph in a chapter as paragraph zero, and the numbering convention was chosen with this in mind.)

This chapter covers the language constructs that handle general sequences, but there are also a number of useful functions available for manipulating sequences, and these are described in Chapter 10. Relevant functions include: count(), deep-equal(), distinct-values(), empty(), exists(), index-of(), insert-before(), remove(), subsequence(), and unordered().

The Comma Operator

The comma operator can be used to construct a sequence by concatenating items or sequences. We already saw the syntax in Chapter 5, because it appears right at the top level of the XPath grammar:

Expression Syntax

Expr ExprSingle («,» ExprSingle) *

ExprSingle ForExpr | QuantifiedExpr | IfExpr | OrExpr

Although the production rule ExprSingle lists four specific kinds of expression that can appear as an operand of the «,» operator, these actually cover any XPath expression whatsoever, provided it does not contain a top-level «,».

Because the «,» symbol also has other uses in XPath (for example, it is used to separate the arguments in a function call, and also to separate clauses in «for», «some», and «every» expressions, which we will meet later in this chapter), there are many places in the grammar where use of a general Expr is restricted, and only an ExprSingle is allowed. In fact, the only places where a general Expr (one that contains a top-level comma) is allowed are:

As the top-level XPath expression Within a parenthesized expression

Within the parentheses of an «if» expression

Within square brackets as a predicate

Neither of the last two is particularly useful, so in practice the rule is: if you want to use the comma operator to construct a list, then it must either be at the outermost level of the XPath expression, or it must be written in parentheses.

For example, the max() function expects a single argument, which is a sequence. If you want to find the maximum of three values $a, $b, and $c, you can write:

max(($a, $b, $c))

The outer parentheses are part of the function call syntax; the inner parentheses are needed because the expression «max($a, $b, $c)» would be a function call with three parameters rather than one, which would be an error.

XPath does not use the JavaScript convention whereby a function call with three separate parameters is the same as a function call whose single parameter is a sequence containing three items.

The operands of the «,» operator can be any two sequences. Of course, a single item is itself a sequence, so the operands can also be single items. Either of the sequences can be empty, in which case the result of the expression is the value of the other operand.

The comma operator is often used to construct a list, as in:

if ($status = ('current', 'pending', 'deleted', 'closed')) then ...

which tests whether the variable $status has one of the given four values (recall from Chapter 6 that the «=» operator compares each item in the sequence on the left with each item in the sequence on the right, and returns true if any of these pairs match). In this construct, you probably aren't thinking of «,» as being a binary operator that combines two operands to produce a result, but that's technically what it is. The expression «A,B,C,D» technically means «(((A,B),C),D)», but since list concatenation is associative, you don't need to think of it this way.

The order of the items in the two sequences is retained in the result. This is true even if the operands are nodes: there is no sorting into document order. This means that in XSLT, for example, you can use a construct such as:

to process the selected elements in a specified order, regardless of the order in which they appear in the source document. This example is not necessarily processing exactly three elements: there might, for example, be five authors and no abstract. Since the path expression «author» selects the five authors in document order, they will be processed in this order, but they will be processed after the