XQuery from the Experts: A Guide to the W3C XML Query Language

XQuery: A Guided Tour

Sample Data: A Bibliography

Listing 1.1  Bibliography Data for Use Case "XMP"

<bib>
    <book year="1994">
        <title>TCP/IP Illustrated</title>
        <author>
            <last>Stevens</last>
            <first>W.</first>
        </author>
        <publisher>Addison-Wesley</publisher>
        <price>65.95</price>
    </book>

    <book year="1992">
        <title>Advanced Programming in the UNIX Environment</title>
        <author>
            <last>Stevens</last>
            <first>W.</first>
        </author>
        <publisher>Addison-Wesley</publisher>
        <price>65.95</price>
    </book>

    <book year="2000">
        <title>Data on the Web</title>
        <author>
            <last>Abiteboul</last>
            <first>Serge</first>
        </author>
        <author>
            <last>Buneman</last>
            <first>Peter</first>
        </author>
        <author>
            <last>Suciu</last>
            <first>Dan</first>
        </author>
        <publisher>Morgan Kaufmann Publishers</publisher>
        <price>65.95</price>
    </book>

    <book year="1999">
        <title>The Economics of Technology and Content for Digital TV</title>
        <editor>
            <last>Gerbarg</last>
            <first>Darcy</first>
            <affiliation>CITI</affiliation>
        </editor>
        <publisher>Kluwer Academic Publishers</publisher>
        <price>129.95</price>
    </book>
</bib>

Listing 1.2  DTD for the Bibliography Data

<!ELEMENT bib (book* )>
<!ELEMENT book (title, (author+ | editor+ ), publisher, price )>
<!ATTLIST book year CDATA #REQUIRED >
<!ELEMENT author (last, first )>
<!ELEMENT editor (last, first, affiliation )>
<!ELEMENT title (#PCDATA )>
<!ELEMENT last (#PCDATA )>
<!ELEMENT first (#PCDATA )>
<!ELEMENT affiliation (#PCDATA )>
<!ELEMENT publisher (#PCDATA )>
<!ELEMENT price (#PCDATA )>

Data Model

<!— document order —>
<book year="1994">
    <title>TCP/IP Illustrated</title>
    <author><last>Stevens</last><first>W.</first></author>
</book>

Literals and Comments

(: Thanks, Jeni! :)

<!— document order —>

1          (: An integer :)
-2         (: An integer :)
+2         (: An integer :)
1.23       (: A decimal  :)
-1.23      (: A decimal  :)
1.2e5      (: A double   :)
-1.2E5     (: A double   :)

"a string"
'a string'
"This is a string, isn't it?"
'This is a "string"'

"a "" or a ' delimits a string literal"
'a " or a '' delimits a string literal'

'<bold>A sample element.</bold>'

Input Functions

1. doc() returns an entire document, identifying the document by a Universal Resource Identifier (URI). To be more precise, it returns the document node.
   
   
2. collection() returns a collection, which is any sequence of nodes that is associated with a URI. This is often used to identify a database to be used in a query.
   
   

doc("books.xml")

Locating Nodes: Path Expressions

doc("books.xml")/bib/book

doc("books.xml")//book

doc("books.xml")/bib/book/author[last="Stevens"]

doc("books.xml")/bib/book/author[1]

(doc("books.xml")/bib/book/author)[1]

• A NameTest, which selects element or attribute nodes based on their names. A simple string is interpreted as an element name; we have already seen the NameTest bib, which evaluates to the bib elements that are children of the context node. If the name is prefixed by the @ character (pronounced "at"), then the NameTest evaluates to the attributes of the context node that have the specified name. For instance, doc("books.xml")/bib/book/@year returns the year attribute of each book. NameTest supports both namespaces and wildcards, which are discussed later in this section.
  
  
• A KindTest, which selects processing instructions, comments, text nodes, or any node based on the type of the node. The KindTest used to select a given kind of node looks like a function with the same name as the type of the node: processing-instruction(), comment(), text(), and node().
  
  
• An expression that uses an explicit "axis" together with a NameTest or KindTest to choose nodes with a specific structural relationship to the context node. If the NameTest book selects book elements, then child::book selects book elements that are children of the context node; descendant::book selects book elements that are descendants of the context node; attribute::book selects book attributes of the context node; self::book selects the context node if it is a book element, descendant-or-self::book selects the context node or any of its descendants if they are book elements, and parent::book selects the parent of the context node if it is a book element. Explicit axes are not frequently used in XQuery.
  
  
• A PrimaryExpression, which may be a literal, a function call, a variable name, or a parenthetical expression. These are discussed in the next section of this tutorial.

doc("books.xml")/bib/book[1]

doc("books.xml")/bib//author[1]

<book year="1994" xmlns:dcx="http://purl.org/dc/elements/1.1/">
    <dcx:title>TCP/IP Illustrated</dcx:title>
    <author><last>Stevens</last><first>W.</first></author>
</book>

declare namespace dc="http://purl.org/dc/elements/1.1/"
doc("books.xml")//dc:title

doc("books.xml")//book[1]/*

Creating Nodes: Element, Attribute, and Document Constructors

<book year="1977">
    <title>Harold and the Purple Crayon</title>
    <author><last>Johnson</last><first>Crockett</first></author>
    <publisher>HarperCollins Juvenile Books</publisher>
    <price>14.95</price>
</book>

document {
<?xml-stylesheet type="text/xsl" href="c:\temp\double-slash.xslt"?>,
<!—I love this book! —>,
<book year="1977">
    <title>Harold and the Purple Crayon</title>
    <author><last>Johnson</last><first>Crockett</first></author>
    <publisher>HarperCollins Juvenile Books</publisher>
    <price>14.95</price>
</book>
}

<example>
    <p> Here is a query. </p>
    <eg> doc("books.xml")//book[1]/title </eg>
    <p> Here is the result of the above query.</p>
    <eg>{ doc("books.xml")//book[1]/title }</eg>
</example>

<example>
    <p> Here is a query. </p>
    <eg> doc("books.xml")//book[1]/title </eg>
    <p> Here is the result of the above query.</p>
    <eg><title>TCP/IP Illustrated</title></eg>
</example>

<titles count="{ count(doc('books.xml')//title) }">
  {
      doc("books.xml")//title
  }
</titles>

<titles count = "4">
    <title>TCP/IP Illustrated</title>
    <title>Advanced Programming in the Unix Environment</title>
    <title>Data on the Web</title>
    <title>The Economics of Technology and Content for Digital TV</title>
</titles>

<book year="1994" xmlns:dcx="http://purl.org/dc/elements/1.1/">
    <dcx:title>TCP/IP Illustrated</dcx:title>
    <author><last>Stevens</last><first>W.</first></author>
</book>

element title {
    "Harold and the Purple Crayon"
}

element book
{
    attribute year { 1977 },
    element author
    {
        element first { "Crockett" },
        element last { "Johnson" }
    },
    element publisher {"HarperCollins Juvenile Books"},
    element price { 14.95 }
}

element { translate-element-name("publisher", "German") }
        { "HarperCollins Juvenile Books" }

<Verlag>HarperCollins Juvenile Books</Verlag>

declare xmlspace = preserve
<author>
    <last>Stevens</last>
    <first>W.</first>
</author>

<author>
    <last>Stevens</last>
    <first>W.</first>
</author>

<author><last>Stevens</last><first>W.</first></author>

Combining and Restructuring Nodes

FLWOR Expressions

for $b in doc("books.xml")//book
where $b/@year = "2000"
return $b/title

<title>Data on the Web</title>

• for clauses: associate one or more variables to expressions, creating a tuple stream in which each tuple binds a given variable to one of the items to which its associated expression evaluates
  
  
• let clauses: bind variables to the entire result of an expression, adding these bindings to the tuples generated by a for clause, or creating a single tuple to contain these bindings if there is no for clause
  
  
• where clauses: filter tuples, retaining only those tuples that satisfy a condition
  
  
• order by clauses: sort the tuples in a tuple stream
  
  
• return clauses: build the result of the FLWOR expression for a given tuple

The for and let Clauses

for $i in (1, 2, 3)
return
<tuple><i>{ $i }</i></tuple>

<tuple><i>1</i></tuple>
<tuple><i>2</i></tuple>
<tuple><i>3</i></tuple>

let $i := (1, 2, 3)
return
<tuple><i>{ $i }</i></tuple>

<tuple><i>1 2 3</i></tuple>

for $i in (1, 2, 3)
let $j := (1, 2, 3)
return
<tuple><i>{ $i }</i><j>{ $j }</j></tuple>

<tuple><i>1</i><j>1 2 3</j></tuple>
<tuple><i>2</i><j>1 2 3</j></tuple>
<tuple><i>3</i><j>1 2 3</j></tuple>

for $b in doc("books.xml")//book
let $c := $b/author
return <book>{ $b/title, <count>{ count($c) }</count>}</book>

Listing 1.3   Query Results

<book>
    <title>TCP/IP Illustrated</title>
    <count>1</count>
</book>
<book>
    <title>Advanced Programming in the UNIX Environment</title>
    <count>1</count>
</book>
<book>
    <title>Data on the Web</title>
    <count>3</count>
</book>
<book>
    <title>The Economics of Technology and Content for Digital TV</title>
    <count>0</count>
</book>

for $i in (1, 2, 3),
    $j in (4, 5, 6)
return
    <tuple><i>{ $i }</i><j>{ $j }</j></tuple>

<tuple><i>1</i><j>4</j></tuple>
<tuple><i>1</i><j>5</j></tuple>
<tuple><i>1</i><j>6</j></tuple>
<tuple><i>2</i><j>4</j></tuple>
<tuple><i>2</i><j>5</j></tuple>
<tuple><i>2</i><j>6</j></tuple>
<tuple><i>3</i><j>4</j></tuple>
<tuple><i>3</i><j>5</j></tuple>
<tuple><i>3</i><j>6</j></tuple>

The where Clause

for $b in doc("books.xml")//book
where $b/price < 50.00
return $b/title

<title>Data on the Web</title>

for $b in doc("books.xml")//book
let $c := $b//author
where count($c) > 2
return $b/title

<title>Data on the Web</title>

The order by Clause

for $t in doc("books.xml")//title
order by $t
return $t

<title>Advanced Programming in the Unix Environment</title>
<title>Data on the Web</title>
<title>TCP/IP Illustrated</title>
<title>The Economics of Technology and Content for Digital TV</title>

for $a in doc("books.xml")//author
order by $a/last descending, $a/first descending
return $a

Listing 1.4 Results of Query for Authors Sorted by Last Name

<author>
    <last>Suciu</last>
    <first>Dan</first>
</author>
<author>
    <last>Stevens</last>
    <first>W.</first>
</author>
<author>
    <last>Stevens</last>
    <first>W.</first>
</author>
<author>
    <last>Buneman</last>
    <first>Peter</first>
</author>
<author>
    <last>Abiteboul</last>
    <first>Serge</first>
</author>

let $b := doc("books.xml")//book
for $t in distinct-values($b/title)
let $a1 := $b[title=$t]/author[1]
order by $a1/last, $a1/first
return $b/title

<title>The Economics of Technology and Content for Digital TV</title>
<title>Data on the Web</title>
<title>Advanced Programming in the UNIX Environment</title>
<title>TCP/IP Illustrated</title>

let $b := doc("books.xml")//book
for $t in distinct-values($b/title)
let $a1 := $b[title=$t]/author[1]
stable order by $a1/last empty least, $a1/first empty least
return $b/title

for $t in doc("books.xml")//title
order by $t collation "http://www.example.com/collations/eng-us"
return $t

default collation = "http://www.example.com/collations/eng-us"
for $t in doc("books.xml")//title
order by $t
return $t

let $authors := for $a in doc("books.xml")//author
               order by $a/last, $a/first
               return $a
return $authors/last

for $a in doc("books.xml")//author
order by $a/last, $a/first
return $a/last

The return Clause

for $b in doc("books.xml")//book
return
<quote>{ $b/title, $b/price }</quote>

Listing 1.5 Results of Query for Price Quotes

<quote>
    <title>TCP/IP Illustrated</title>
    <price>65.95</price>
</quote>
<quote>
    <title>Advanced Programming in the UNIX Environment</title>
    <price>65.95</price>
</quote>
<quote>
    <title>Data on the Web</title>
    <price>39.95</price>
</quote>
<quote>
    <title>The Economics of Technology and Content for Digital TV</title>
    <price>129.95</price>
</quote>

for $a in doc("books.xml")//author
return
<author>{ string($a/first), " ", string($a/last) }</author>

<author>W. Stevens</author>
<author>W. Stevens</author>
<author>Serge Abiteboul</author>
<author>Peter Buneman</author>
<author>Dan Suciu</author>

for $a in doc("books.xml")//author
return
<author>
<name>{ $a/first, $a/last }</name>
</author>

<author>
<name>
<first>Serge</first>
<last>Abiteboul</last>
</name>
</author>

The Positional Variable at

for $t at $i in doc("books.xml")//title
return <title pos="{$i}">{string($t)}</title>

<title pos="1">TCP/IP Illustrated</title>
<title pos="2">Advanced Programming in the Unix Environment</title>
<title pos="3">Data on the Web</title>
<title pos="4">The Economics of Technology and Content for Digital TV</title>

<table border="1" ID="Table2">
    <thead>
        <tr>
            <td>Title</td>
            <td>Publisher</td>
            <td>Price</td>
            <td>Year</td>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td>TCP/IP Illustrated</td>
            <td>Addison-Wesley</td>
            <td>65.95</td>
            <td>1994</td>
        </tr>
        <tr>
            <td>Advanced Programming in the UNIX Environment</td>
            <td>Addison-Wesley</td>
            <td>65.95</td>
            <td>1992</td>
        </tr>
        <!— Additional rows omitted to save space —>
    </tbody>
</table>

Listing 1.7 Query to Generate Names of Elements from Column Headers

let $t := doc("bib.xhtml")//table[1]
for $r in $t/tbody/tr
return
<book>
{
    for $c at $i in $r/td
    return element{ lower-case(data($t/thead/tr/td[$i])) }
                  { string( $c) }
}
</book>

Listing 1.8 Output Generated by the Query of Listing 1.7

<book>
    <title>TCP/IP Illustrated</title>
    <publisher>Addison-Wesley</publisher>
    <price>65.95</price>
    <year>1994</year>
</book>
<book>
    <title>Advanced Programming in the Unix Environment</title>
    <publisher>Addison-Wesley</publisher>
    <price>65.95</price>
    <year>1992</year>
</book>

Eliminating Duplicate Subtrees with distinct-values() and FLWOR Expressions

doc("books.xml")//author/last

<last>Stevens</last>
<last>Stevens</last>
<last>Abiteboul</last>
<last>Buneman</last>
<last>Suciu</last>

distinct-values(doc("books.xml")//author/last)

Stevens Abiteboul Buneman Suciu

for $l in distinct-values(doc("books.xml")//author/last)
return <last>{ $l }</last>

<last>Stevens</last>
<last>Abiteboul</last>
<last>Buneman</last>
<last>Suciu</last>

doc("books.xml")//author

Listing 1.9 Output of the Query for Authors

<authors>
    <author>
        <last>Stevens</last>
        <first>W.</first>
    </author>
    <author>
        <last>Stevens</last>
        <first>W.</first>
    </author>
    <author>
        <last>Abiteboul</last>
        <first>Serge</first>
    </author>
    <author>
        <last>Buneman</last>
        <first>Peter</first>
    </author>
    <author>
        <last>Suciu</last>
        <first>Dan</first>
    </author>
</authors>

let $a := doc("books.xml")//author
for $l in distinct-values($a/last),
    $f in distinct-values($a[last=$l]/first)
return
    <author>
        <last>{ $l }</last>
        <first>{ $f }</first>
    </author>

Listing 1.10 Output of Query to Avoid Duplicate Author Names

<authors>
    <author>
        <last>Stevens</last>
        <first>W.</first>
    </author>
    <author>
        <last>Abiteboul</last>
        <first>Serge</first>
    </author>
    <author>
        <last>Buneman</last>
        <first>Peter</first>
    </author>
    <author>
        <last>Suciu</last>
        <first>Dan</first>
    </author>
</authors>

Joins: Combining Data Sources with for and where Clauses

<reviews>
    <entry>
    <title>TCP/IP Illustrated</title>
    <rating>5</rating>
    <remarks>Excellent technical content. Not much plot.</remarks>
</entry>
</reviews>

for $t in doc("books.xml")//title,
    $e in doc("reviews.xml")//entry
    where $t = $e/title
    return <review>{ $t, $e/remarks }</review>

<review>
    <title>TCP/IP Illustrated</title>
    <remarks>Excellent technical content. Not much plot.</remarks>
</review>

for $t in doc("books.xml")//title
for $e in doc("reviews.xml")//entry
 where $t = $e/title
 return <review>{ $t, $e/remarks }</review>

Listing 1.11 Query to Return Titles with or without Reviews

for $t in doc("books.xml")//title
return
    <review>
    { $t }
    {
        for $e in doc("reviews.xml")//entry
        where $e/title = $t
        return $e/remarks
     }
</review>

Inverting Hierarchies

Listing 1.12 Query to List Titles by Publisher

<listings>
  {
     for $p in distinct-values(doc("books.xml")//publisher)
     order by $p
     return
         <result>
         { $p }
         {
              for $b in doc("books.xml")/bib/book
              where $b/publisher = $p
              order by $b/title
              return $b/title
         }
         </result>
  }
</listings>

<listings>
    <result>
        <publisher>Addison-Wesley</publisher>
        <title>Advanced Programming in the Unix Environment</title>
        <title>TCP/IP Illustrated</title>
    </result>
    <result>
        <publisher>Kluwer Academic Publishers</publisher>
        <title>The Economics of Technology and Content for Digital TV</title>
    </result>
    <result>
        <publisher>Morgan Kaufmann Publishers</publisher>
        <title>Data on the Web</title>
    </result>
</listings>

Quantifiers

for $b in doc("books.xml")//book
where some $a in $b/author
      satisfies ($a/last="Stevens" and $a/first="W.")
return $b/title

<title>TCP/IP Illustrated</title>
<title>Advanced Programming in the Unix Environment</title>

for $b in doc("books.xml")//book
where every $a in $b/author
satisfies ($a/last="Stevens" and $a/first="W.")
return $b/title

<title>TCP/IP Illustrated</title>
<title>Advanced Programming in the Unix Environment</title>
<title>The Economics of Technology and Content for Digital TV</title>

Listing 1.13 Query to List Books by Author

<author-list>
{
    let $a := doc("books.xml")//author
    for $l in distinct-values($a/last),
        $f in distinct-values($a[last=$l]/first)
    order by $l, $f
    return
        <author>
        <name>{ $l, ", ", $f }</name>
        {
            for $b in doc("books.xml")/bib/book
            where some $ba in $b/author satisfies
                ($ba/last=$l and $ba/first=$f)
            order by $b/title
            return $b/title
        }
    </author>
}
</author-list>

Listing 1.14 Results of Query to List Books by Author

<author-list>
    <author>
        <name>Stevens, W.</name>
        <title>Advanced Programming in the Unix Environment</title>
        <title>TCP/IP Illustrated</title>
    </author>
    <author>
        <name>Abiteboul, Serge</name>
        <title>Data on the Web</title>
    </author>
    <author>
        <name>Buneman, Peter</name>
        <title>Data on the Web</title>
    </author>
    <author>
        <name>Suciu, Dan</name>
        <title>Data on the Web</title>
    </author>
</author-list>

Conditional Expressions

Listing 1.15 Query to List Author’s Names with “et al.”

for $b in doc("books.xml")//book
    return
    <book>
        { $b/title }
        {
            for $a at $i in $b/author
            where $i <= 2
            return <author>{string($a/last), ", ",
                string($a/first)}</author>
        }
        {
            if (count($b/author) > 2)
                then <author>et al.</author>
            else ()
        }
    </book>

Listing 1.16  Result of Query from Listing 1.15   

<book>
    <title>TCP/IP Illustrated</title>
    <author>Stevens, W.</author>
</book>
<book>
    <title>Advanced Programming in the Unix Environment</title>
    <author>Stevens, W.</author>
</book>
<book>
    <title>Data on the Web</title>
    <author>Abiteboul, Serge</author>
    <author>Buneman, Peter</author>
    <author>et al.</author>
</book>
<book>
    <title>The Economics of Technology and Content for Digital TV</title>
</book>

Operators

doc("books.xml")/bib/book/author[last='Stevens']

data( <e xsi:type="xs:integer">4</e> )

avg( 1, <e>2</e>, <e xsi:type="xs:integer">3</e> )

Arithmetic Operators

2 + <int>{ 2 }</int>

2 + ()

let $p := doc("books.xml")//price
return $p[1] + $p[2]

Comparison Operators

for $b in doc("books.xml")//book
where $b/title eq "Data on the Web"
return $b/price

for $b in doc("books.xml")//book
where xs:decimal($b/price) gt 100.00
return $b/title

for $b in doc("books.xml")//book
where $b/author/last eq "Stevens"
return $b/title

for $b in doc("books.xml")//book
where $b/author/last = "Stevens"
return $b/title

for $b in doc("books.xml")//book
where $b/price = 100.00
return $b/title

• If the other atomic value has a numeric type, the required type is xs:double.
  
  
• If the other atomic value is also untyped, the required type is xs:string.
  
  
• Otherwise, the required type is the dynamic type of the other atomic value. If the cast to the required type fails, a dynamic error is raised.

for $b in doc("books.xml")//book
where $b/author/first = "Serge"
and $b/author/last = "Suciu"
return $b

Listing 1.17 Surprising Results

<book year = "2000">
    <title>Data on the Web</title>
    <author>
        <last>Abiteboul</last>
        <first>Serge</first>
    </author>
    <author>
        <last>Buneman</last>
        <first>Peter</first>
    </author>
    <author>
        <last>Suciu</last>
        <first>Dan</first>
    </author>
    <publisher>Morgan Kaufmann Publishers</publisher>
    <price>39.95</price>
</book>

for $b in doc("books.xml")//book,
$a in $b/author
where $a/first="Serge"
and $a/last="Suciu"
return $b

let $a := ( <first>Jonathan</first>, <last>Robie</last> ),
    $b := ( <first>Jonathan</first>, <last>Marsh</last> ),
    $c := ( <first>Rodney</first>, <last>Marsh</last> )
    return
        <out>
            <equals>{ $a = $b }</equals>
            <equals>{ $b = $c }</equals>
            <equals>{ $a = $c }</equals>
        </out>

<out>
    <equals>True</equals>
    <equals>True</equals>
    <equals>False</equals>
</out>

let $b1 := for $b in doc("books.xml")//book
    order by count($b/author) + count($b/editor)
    return $b

let $b2 := for $b in doc("books.xml")//book
    order by $b/price
    return $b

return $b1[last()] is $b2[last()]

for $b in doc("books.xml")//book
    let $a := ($b/author)[1],
    $sa := ($b/author)[last="Abiteboul"]
    where $a << $sa
    return $b

Sequence Operators

let $l := distinct-values(doc("books.xml")//(author | editor)/last)
order by $l
return <last>{ $l }</last>

<last>Abiteboul</last>
<last>Buneman</last>
<last>Gerbarg</last>
<last>Stevens</last>
<last>Suciu</last>

for $b in doc("books.xml")//book
let $a1 := ($b/author union $b/editor)[1]
order by $a1/last, $a1/first
return $b

for $b in doc("books.xml")//book
where $b/title = "TCP/IP Illustrated"
return
<book>
{ $b/@* }
{ $b/* except $b/price }
</book>

<book year = "1994">
    <title>TCP/IP Illustrated</title>
    <author>
        <last>Stevens</last>
        <first>W.</first>
    </author>
    <publisher>Addison-Wesley</publisher>
</book>

Built-in Functions

let $b := doc("books.xml")//book
let $avg := average( $b//price )
return $b[price > $avg]

Listing 1.18 Result of Query for Books More Expensive Than Average

<book year = "1999">
    <title>The Economics of Technology and Content for Digital TV</title>
    <editor>
        <last>Gerbarg</last>
        <first>Darcy</first>
        <affiliation>CITI</affiliation>
    </editor>
    <publisher>Kluwer Academic Publishers</publisher>
    <price>129.95</price>
</book>

for $b in doc("books.xml")//book
where not(some $a in $b/author satisfies $a/last="Stevens")
return $b

for $b in doc("books.xml")//book
where not(empty($b/author))
return $b

for $b in doc("books.xml")//book
where exists($b/author)
return $b

string((doc("books.xml")//author)[1])

User-Defined Functions

for $b in doc("books.xml")/bib/book
where some $ba in $b/author satisfies
($ba/last=$l and $ba/first=$f)
order by $b/title
return $b/title

define function books-by-author($last, $first)
as element()*
{
for $b in doc("books.xml")/bib/book
where some $ba in $b/author satisfies
($ba/last=$last and $ba/first=$first)
order by $b/title
return $b/title
}

Listing 1.19 Query to Create a Table of Contents

define function toc($book-or-section as element())
as element()*
{
    for $section in $book-or-section/section
    return
        <section>
        { $section/@* , $section/title , toc($section) }
        </section>
}
<toc>
{
    for $s in doc("xquery-book.xml")/book
    return toc($s)
}
</toc>

Variable Definitions

define variable $titles { doc(“books.xml”)//title }

Library Modules

Listing 1.20 Module Declaration for a Library Module

module "http://example.com/xquery/library/book"
define function toc($book-or-section as element()) as element()*
{
    for $section in $book-or-section/section
    return
        <section>
          { $section/@* , $section/title , toc($section) }
        </section>
}

import module "http://example.com/xquery/library/book" 
         at "file:///c:/xquery/lib/book.xq"

import module namespace b = "http://example.com/xquery/library/book"
at "file:///c:/xquery/lib/book.xq"
<toc>
{
    for $s in doc("xquery-book.xml")/book
    return b:toc($s)
}
</toc>

External Functions and Variables

define function outtie($v as xs:integer) as xs:integer external

define variable $v as xs:integer external

Types in XQuery

• XML may be strongly typed and governed by a W3C XML Schema, and a strongly typed query language with static typing can prevent many errors for this kind of data.
  
  
• XML may be governed by another schema language, such as DTDs or RELAX-NG.
  
  
• XML may have an ad hoc structure and no schema, and the whole reason for performing a query may be to discover the structure found in a document. For this kind of data, the query language should be able to process whatever data exists, with no preconceived notions of what should be there.
  
  
• XML may be used as a view of another system, such as a relational database. These systems are typically strongly typed, but do not use W3C XML Schema as the basis for their type system. Fortunately, standard mappings are emerging for some systems, such as SQL’s mappings from relational schemas to W3C XML Schema. These are defined in the SQL/XML proposal, which provides standard XML extensions to SQL [SQLXML].
  
  
• XML data sources may have very complex structure, and expressions in XQuery must be well defined in terms of all the structures to which the operands can evaluate.

Introduction to XQuery Types

define function reverse($items)
{
   let $count := count($items)
   for $i in 0 to $count
   return $items[$count - $i]
}
reverse( 1 to 5)

define function is-document-element($e as element())
as xs:boolean
{
   if ($e/.. instance of document-node())
   then true()
   else false()
}

Listing 1.21 Query to Create the First Ten Fibonacci Numbers

define function fibo($n as xs:integer)
{
    if ($n = 0)
        then 0
    else if ($n = 1)
        then 1
    else (fibo($n - 1) + fibo($n - 2))
}

let $seq := 1 to 10
for $n in $seq
return <fibo n="{$n}">{ fibo($n) }</fibo>

Listing 1.22 Results of the Query in Listing 1.21

<fibo n = "1">1</fibo>
<fibo n = "2">1</fibo>
<fibo n = "3">2</fibo>
<fibo n = "4">3</fibo>
<fibo n = "5">5</fibo>
<fibo n = "6">8</fibo>
<fibo n = "7">13</fibo>
<fibo n = "8">21</fibo>
<fibo n = "9">34</fibo>
<fibo n = "10">55</fibo>

Schemas and Types

avg( doc("books.xml")/bib/book/price )

define function books-by-author($author)
{
    for $b in doc("books.xml")/bib/book
        where some $ba in $b/author satisfies
            ($ba/last=$author/last and $ba/first=$author/first)
    order by $b/title
    return $b/title
}

Listing 1.23 Schema Import and Type Checking

import schema "urn:examples:xmp:bib" at "c:/dev/schemas/eg/bib.xsd"
default element namespace = "urn:examples:xmp:bib"
define function books-by-author($a as element(b:author))
as element(b:title)*
{
    for $b in doc("books.xml")/bib/book
        where some $ba in $b/author satisfies
            ($ba/last=$a/last and $ba/first=$a/first)
    order by $b/title
    return $b/title
}

for $b in doc("books.xml")/bib/book
return books-by-author($b)

Listing 1.24 Assigning a Namespace Prefix in Schema Imports

import schema namespace b = "urn:examples:xmp:bib"
at "c:/dev/schemas/eg/bib.xsd"
define function books-by-author($a as element(b:author))
as element(b:title)*
{
    for $b in doc("books.xml")/b:bib/b:book
        where some $ba in $b/b:author satisfies
                ($ba/b:last=$l and $ba/b:first=$f)
    order by $b/b:title
    return $b/b:title
}

import schema "urn:examples:xmp:bib" at "c:/dev/schemas/eg/bib.xsd"
    default element namespace = "urn:examples:xmp:bib"
    <book year="1994">
        <title>Catamaran Racing from Start to Finish</title>
        <author><last>Berman</last><first>Phil</first></author>
        <publisher>W.W. Norton & Company</publisher>
    </book>

Listing 1.25 Query with a Spelling Error

import schema "urn:examples:xmp:bib" at "c:/dev/schemas/eg/bib.xsd"
default element namespace = "urn:examples:xmp:bib"
define function books-by-author($a as element(author))
as element(title)*
{
    for $b in doc("books.xml")/bib/book
        where some $ba in $b/author satisfies
        ($ba/last=$a/last and $ba/first=$a/firt)
    order by $b/title
    return $b/title
}

doc("books.xml")/bib/book

Listing 1.26 Type Tests in Path Expressions

import schema "urn:examples:xmp:bib" at "c:/dev/schemas/eg/bib.xsd"
default element namespace = "urn:examples:xmp:bib"
define function books-by-author($a as element(author))
as element(title)*
{
    for $b in doc("books.xml")/bib/element(book)
        where some $ba in $b/author satisfies
            ($ba/last=$a/last and $ba/first=$a/first)
    order by $b/title
    return $b/title
}

Sequence Types

Built-in Types

element()+            One or more elements
xs:integer?           Zero or one integers
document-node()*      Zero or more document nodes

Types from Imported Schemas

Listing 1.27 An Imported Schema for Bibliographies

<?xml version="1.0"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:bib="urn:examples:xmp:bib"
    targetNamespace="urn:examples:xmp:bib"
    elementFormDefault="qualified">

    <xs:element name="bib">
        <xs:complexType>
            <xs:sequence>
                <xs:element ref="bib:book" minOccurs="0" maxOccurs="unbounded" />
            </xs:sequence>
        </xs:complexType>
    </xs:element>
    
    <xs:element name="book">
        <xs:complexType>
            <xs:sequence>
                <xs:element name="title" type="xs:string"/>
                <xs:element ref="bib:creator" minOccurs="1" maxOccurs="unbounded"/>
                <xs:element name="publisher" type="xs:string"/>
                <xs:element name="price" type="currency"/>
                <xs:element name="year" type="xs:gYear"/>
            </xs:sequence>
            <xs:attribute name="isbn" type="bib:isbn"/>
        </xs:complexType>
    </xs:element>
    
    <xs:element name="creator" type="person" abstract="true" />
    <xs:element name="author" type="person" substitutionGroup="bib:creator"/>
    <xs:element name="editor" type="personWithAffiliation" substitutionGroup="bib:creator"/>
    
    <xs:complexType name="person">
        <xs:sequence>
            <xs:element name="last" type="xs:string"/>
            <xs:element name="first" type="xs:string"/>
        </xs:sequence>
    </xs:complexType>
    
    <xs:complexType name="personWithAffiliation">
        <xs:complexContent>
            <xs:extension base="person">
                <xs:sequence>
                    <xs:element name="affiliation" type="xs:string"/>
                </xs:sequence>
            </xs:extension>
        </xs:complexContent>
    </xs:complexType>

    <xs:simpleType name="isbn">
        <xs:restriction base="xs:string">
            <xs:pattern value="[0-9]{9}[0-9X]"/>
        </xs:restriction>
    </xs:simpleType>

    <xs:simpleType name="currency">
        <xs:restriction base="xs:decimal">
            <xs:pattern value="\d+.\d{2}"/>
        </xs:restriction>
    </xs:simpleType>
</xs:schema>

<bib xmlns="urn:examples:xmp:bib">
    <book isbn="0201563177">
    <title>Advanced Programming in the Unix Environment</title>
    <author><last>Stevens</last><first>W.</first></author>
    <publisher>Addison-Wesley</publisher>
    <price>65.95</price>
    <year>1992</year>
    </book>
</bib>

• All elements and types in this schema are in the namespace urn:examples:xmp:bib (for local elements, this was accomplished by using the elementFormDefault attribute at the top level of the schema). All attributes are in the null namespace.
  
  
• The following declaration says that the isbn type is a user-defined type derived from the string type by restriction and consists of nine digits followed either by a digit or by the character x:

  <xs:simpleType name="isbn">
      <xs:restriction base="xs:string">
          <xs:pattern value="[0-9]{9}[0-9X]"/>
      </xs:restriction>
  </xs:simpleType>

  
  
  
• The following declaration says that the “currency” type is derived from the decimal type by restriction, and must contain two places past the decimal point:

  <xs:simpleType name="currency">
      <xs:restriction base="xs:decimal">
          <xs:pattern value="\d+.\d{2}"/>
      </xs:restriction>
  </xs:simpleType>

  
  
  
• The following declarations say that creator is an abstract element that can never actually be created, and the author and editor elements are in the substitution group of creator:

  <xs:element name="creator" type="person" abstract="true" />
  <xs:element name="author" type="person" substitutionGroup="bib:creator"/>
  <xs:element name="editor" type="personWithAffiliation" substitutionGroup="bib:creator"/>
  

  
  
  
• The content model for a book specifies a creator, but since creator is an abstract element, it can never be created—it will always match an author or an editor; see Listing 1.28.

  Listing 1.28 Content Model for the Book Element

  ---

  <xs:element name="book">
      <xs:complexType>
          <xs:sequence>
              <xs:element name="title" type="xs:string"/>
              <xs:element ref="bib:creator" minOccurs="1" maxOccurs="unbounded"/>
              <xs:element name="publisher" type="xs:string"/>
              <xs:element name="price" type="currency"/>
              <xs:element name="year" type="xs:gYear"/>
          </xs:sequence>
          <xs:attribute name="isbn" type="bib:isbn"/>
      </xs:complexType>
  </xs:element>
  

  


• The following elements are globally declared: bib, book, creator, author, editor. The type of the bib and book elements is “anonymous,” which means that the schema does not give these types explicit names.


• All of the named types in this schema are global; in fact, in XML Schema, all named types are global.

element(creator, person)

element(creator)

element(book/price)

element(type(person)/last)

attribute(@price, currency)

attribute(book/@isbn)

element(n, person nillable)

<n xsi:nil=”true” />

Working with Types

Function Signatures

import schema namespace bib="urn:examples:xmp:bib"
define function discount-price($b as element(bib:book))
   as xs:decimal
   {
     0.80 * $b//bib:price
   }

for $b in doc("books.xml")//bib:book
    where $b/bib:title = "Data on the Web"
    return
        <result>
        {
                $b/bib:title,
                <price>{ discount-price($b/bib:price) }</price>
        }
        </result>

Listing 1.29Atomization 

import schema namespace bib="urn:examples:xmp:bib"
define function discount-price($p as xs:decimal)
      as xs:decimal
    {
       0.80 * $p//bib:price
    }
    for $b in doc("books.xml")//bib:book
        where $b/bib:title = "Data on the Web"
    return
        <result>
        {
            $b/bib:title,
                <price>{ discount-price($b/bib:price) }</price>
        }
    </result>

let $w := <foo>12.34</foo>
return discount-price($w)

import schema namespace bib="urn:examples:xmp:bib"
define function discount-price($p as element(bib:book/bib:price))
as xs:decimal
{
    0.80 * $p
}

import schema namespace bib="urn:examples:xmp:bib"

define function discount-price($p as element(bib:price, bib:currency))
   as xs:decimal
{
   0.80 * $p
}

define function decimate($p as element(bib:price, bib:currency))
as xs:decimal
{
    $p
}

Casting and Typed Value Construction

xs:date("2000-01-01")

xs:string( 12345 )

import schema namespace bib="urn:examples:xmp:bib"
bib:isbn("012345678X")

import schema namespace bib="urn:examples:xmp:bib"
bib:isbn("012345678Y")

Typed Variables

Listing 1.30 Declaring the Type of a Variable

import schema namespace bib="urn:examples:xmp:bib"

for $b in doc("books.xml")//bib:book
let $authors as element(bib:author)+ := $b//bib:author
return
    <result>
    {
        $b/bib:title,
        $authors
    }    
    </result>

The instance of Operator

$a instance of element()

<foo/> instance of element()

3.14 instance of xs:decimal

"foo" instance of xs:string

(1, 2, 3) instance of xs:integer*

() instance of xs:integer?

(1, 2, 3) instance of xs:integer+

3.14 instance of xdt:untypedAtomic

"3.14" instance of xs:decimal

3.14 instance of xs:integer

import schema namespace bib="urn:examples:xmp:bib"
bib:isbn("012345678X") instance of xs:string

The typeswitch Expression

Listing 1.31 Function Using the typeswitch Expression

define function wrapper($x as xs:anySimpleType)
as element()
    {
    typeswitch ($x)
        case $i as xs:integer
            return <wrap xsi:type="xs:integer">{ $i }</wrap>
        case $d as xs:decimal
            return <wrap xsi:type="xs:decimal">{ $d }</wrap>
        default
            return error("unknown type!")
    }
wrapper( 1 )

<wrap xsi:type="xs:integer">1</wrap>

Listing 1.32 Using typeswitch to Implement Simple Polymorphism

import schema namespace bib="urn:examples:xmp:bib"
define function pay-creator(
    $c as element(bib:creator),
    $p as xs:decimal)
{
    typeswitch ($c)
    case $a as element(bib:author)
        return pay-author($a, $p)
    case $e as element(bib:editor)
        return pay-editor($e, $p)
    default
        return error("unknown creator element!")
}

The treat as Expression

Listing 1.33 Using treat as and instance of to Implement Simple Polymorphism

import schema namespace bib="urn:examples:xmp:bib"

define function pay-creator(
    $c as element(bib:creator),
    $p as xs:decimal)
{
    if ($c instance of element(bib:author))
        then pay-author($a, $p)
    else if ($c instance of element(bib:editor))
        then pay-editor($e, $p)
    else error("unknown creator element!")
}

Implicit Validation and Element Constructors

Listing 1.34 Query That Creates a Fully Validated Book Element

import schema namespace bib="urn:examples:xmp:bib"
<bib:book isbn="0201633469">
    <bib:title>TCP/IP Illustrated</bib:title>
    <bib:author>
        <bib:last>Stevens</bib:last>
        <bib:first>W.</bib:first>
    </bib:author>
    <bib:publisher>Addison-Wesley</bib:publisher>
    <bib:price>65.95</bib:price>
    <bib:year>1994</bib:year>
</bib:book>

import schema namespace bib="urn:examples:xmp:bib"
for $b in doc("books.xml")//bib:book
return
    <bib:book>
    {
        $b/bib:title,
        $b//element(bib:creator)
    }
    </bib:book>

Listing 1.35 Using validate to Disable Validation

import schema namespace bib="urn:examples:xmp:bib"

for $b in doc("books.xml")//bib:book
return
    validate skip
    {
        <bib:book>
        {
            $b/bib:title,
            $b//element(bib:creator)
        }    
        </bib:book>
    }

import schema namespace bib="urn:examples:xmp:bib"
validate context bib:book
{
    <bib:price>49.99</bib:price>
}

import schema namespace bib="urn:examples:xmp:bib"
<bib:mug>49.99</bib:mug>

import schema namespace bib="urn:examples:xmp:bib"
<bib:mug xsi:type="xs:decimal">49.99</bib:mug>

import schema namespace bib="urn:examples:xmp:bib"
<bib:price>49.99</bib:price>

import schema namespace bib="urn:examples:xmp:bib"
validation strict
<bib:price>49.99</bib:price>

Summary