|
|
Basic Search Advanced Search |
|
||||||||||||
 |
https://perfectxml.com/XQuery.asp
If our sample data is in a file named books.xml, then the following query returns the entire document: Locating Nodes: Path ExpressionsIn XQuery, path expressions are used to locate nodes in XML data. XQuery’s path expressions are derived from XPath 1.0 and are identical to the path expressions of XPath 2.0. The functionality of path expressions is closely related to the underlying data model. We start with a few examples that convey the intuition behind path expressions, then define how they operate in terms of the data model.The most commonly used operators in path expressions locate nodes by identifying their location in the hierarchy of the tree. A path expression consists of a series of one or more steps, separated by a slash, /, or double slash, //. Every step evaluates to a sequence of nodes. For instance, consider the following expression: Such paths start with the root node of a document, but how this node is identified is implementation-defined. For each / in a path expression, XQuery evaluates the expression on the left-hand side and returns the resulting nodes in document order; if the result contains anything that is not a node, a type error is raised. After that, XQuery evaluates the expression on the right-hand side of the / once for each left-hand node, merging the results to produce a sequence of nodes in document order; if the result contains anything that is not a node, a type error is raised. When the right-hand expression is evaluated, the left-hand node for which it is being evaluated is known as the context node. The step expressions that may occur on the right-hand side of a / are the following:
Up to now, we have not defined the // operator in terms of the data model. The formal definition of this operator is somewhat complex; intuitively, the // operator is used to give access to all attributes and all descendants of the nodes in the left-hand expression, in document order. The expression doc("books.xml")//bib matches the bib element at the root of our sample document, doc("books.xml")//book matches all the book elements in the document, and doc("books.xml")//@year matches all the year attributes in the document. The // is formally defined using full axis notation: // is equivalent to /descendant-orself:: node()/. For each node from the left-hand expression, the // operator takes the node itself, each attribute node, and each descendant node as a context node, then evaluates the right-hand expression. For instance, consider the following expression: In the examples we have shown so far, NameTest uses simple strings to represent names. NameTest also supports namespaces, which distinguish names from different vocabularies. Suppose we modify our sample data so that it represents titles with the title element from the Dublin Core, a standard set of elements for bibliographical data [DC]. The namespace URI for the Dublin Core is http://purl.org/dc/elements/1.1/. Here is an XML document containing one simple book, in which the title element is taken from Dublin Core: Wildcards allow queries to select elements or attributes without specifying their entire names. For instance, a query might want to return all the elements of a given book, without specifying each possible element by name. In XQuery, this can be done with the following query: Creating Nodes: Element, Attribute, and Document ConstructorsIn the last section, we learned how to locate nodes in XML documents. Now we will learn how to create nodes. Elements, attributes, text nodes, processing instructions, and comments can all be created using the same syntax as XML. For instance, here is an element constructor that creates a book:Combining and Restructuring NodesQueries in XQuery often combine information from one or more sources and restructure it to create a new result. This section focuses on the expressions and functions most commonly used for combining and restructuring XML data.FLWOR ExpressionsFLWOR expressions, pronounced “flower expressions,” are one of the most powerful and common expressions in XQuery. They are similar to the SELECT-FROM-WHERE statements in SQL. However, a FLWOR expression is not defined in terms of tables, rows, and columns; instead, a FLWOR expression binds variables to values in for and let clauses, and uses these variable bindings to create new results. A combination of variable bindings created by the for and let clauses of a FLWOR expression is called a tuple.For instance, here is a simple FLWOR expression that returns the title and price of each book that was published in the year 2000:
The for and let ClausesEvery clause in a FLWOR expression is defined in terms of tuples, and the for and let clauses create the tuples. Therefore, every FLWOR expression must have at least one for or let clause. It is extremely important to understand how tuples are generated in FLWOR expressions, so we will start with a series of artificial queries that show this in detail for various combinations of for clauses and let clauses.We have already shown an example that binds one variable in a for clause. The following query creates an element named tuple in its return clause to show the tuples generated by such a query: A let clause binds a variable to the entire result of an expression. If there are no for clauses in the FLWOR expression, then a single tuple is created, containing the variable bindings from the let clauses. The following query is like the previous query, but it uses a let clause rather than a for:
<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>If more than one variable is bound in the for clauses of a FLWORexpression, then the tuples contain all possible combinations of the items to which these variables are bound. For instance, the following query shows all combinations that include 1, 2, or 3 combined with 4, 5, or 6:
The ability to create tuples that reflect combinations becomes particularly interesting when combined with where clauses to perform joins. The following sections illustrate this in depth. But first we must introduce the where and return clauses. The where ClauseA where clause eliminates tuples that do not satisfy a particular condition. A return clause is only evaluated for tuples that survive the where clause. The following query returns only books whose prices are less than $50.00:The order by ClauseThe order by clause sorts the tuples before the return clause is evaluated in order to change the order of results. For instance, the following query lists the titles of books in alphabetical order:
<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>The order by clause may specify conditions based on data that is not used in the return clause, so there is no need for an expression to return data in order to use it to sort. Here is an example that returns the titles of books, sorted by the name of the first author:
Two books in our data are written by the same author, and we may want to ensure that the original order of these two books is maintained. We can do this by specifying a stable sort, which maintains the relative order of two items if the comparison expressions consider them equal. The following query specifies a stable sort, and requires empty sequences to be sorted as least: Collations may also be specified in an order by clause. The following query sorts titles using a U.S. English collation: The return ClauseWe have already seen that a for clause or a let clause may be bound to any expression, and a where clause may contain any Boolean expression. Similary, any XQuery expression may occur in a return clause. Element constructors are an extremely common expression in return clauses; for instance, the following query uses an element constructor to create 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>Element constructors can be used in a return clause to change the hierarchy of data. For instance, we might want to represent an author’s name as a string in a single element, which we can do with the following query:
The Positional Variable atThe for clause supports positional variables, which identify the position of a given item in the expression that generated it. For instance, the following query returns the titles of books, with an attribute that numbers the books:
TABLE 1.2 Table from an XHTMLWeb Page
The XHTML source for this table is shown in Listing 1.2.
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>Note the use of a computed element constructor that uses the column header to determine the name of the element. Listing 1.8 shows the portion of the output this query generates for the partial data shown in Table 1.2.
<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>
|
| Value Comparison Operator | General Comparison Operator |
| eq | = |
| ne | != |
| lt | < |
| le | <= |
| gt | > |
| ge | >= |
for $b in doc("books.xml")//book
where xs:decimal($b/price) gt 100.00
return $b/titlefor $b in doc("books.xml")//book
where $b/author/last eq "Stevens"
return $b/titlefor $b in doc("books.xml")//book
where $b/author/last = "Stevens"
return $b/titlefor $b in doc("books.xml")//book
where $b/price = 100.00
return $b/title
for $b in doc("books.xml")//book
where $b/author/first = "Serge"
and $b/author/last = "Suciu"
return $bListing 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>Since this book does have an author whose first name is “Serge” and an author whose last name is “Suciu,” the result of the query is correct, but it is surprising. The following query expresses what the author of the previous query probably intended:
for $b in doc("books.xml")//book,
$a in $b/author
where $a/first="Serge"
and $a/last="Suciu"
return $blet $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 $blet $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 $bfor $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>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>Note that price is the name of an element, but max() is defined for atomic values, not for elements. In XQuery, if the type of a function argument is an atomic type, then the following conversion rules are applied. If the argument is a node, its typed value is extracted, resulting in a sequence of values. If any value in the argument sequence is untyped, XQuery attempts to convert it to the required type and raises an error if it fails. A value is accepted if it has the expected type.
Other familiar functions in XQuery include numeric functions like round(), floor(), and ceiling(); string functions like concat(), string-length(), starts-with(), ends-with(), substring(), upper-case(), lower-case(); and casts for the various simple types. These are all covered in [XQ-FO], which defines the standard function library for XQuery; they need no further coverage here since they are straightforward.
XQuery also has a number of functions that are not found in most other languages. We have already covered distinct-values(), the input functions doc() and collection(). Two other frequently used functions are not() and empty(). The not() function is used in Boolean conditions; for instance, the following returns books where no author’s last name is Stevens:
for $b in doc("books.xml")//book
where not(some $a in $b/author satisfies $a/last="Stevens")
return $bfor $b in doc("books.xml")//book
where not(empty($b/author))
return $bfor $b in doc("books.xml")//book
where exists($b/author)
return $bstring((doc("books.xml")//author)[1])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/titledefine 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>If two functions call each other, they are mutually recursive. Mutually recursive functions are allowed in XQuery.
Variable DefinitionsA query can define a variable in the prolog. Such a variable is available at any point after it is declared. For instance, if access to the titles of books is used several times in a query, it can be provided in a variable definition:
define variable $titles { doc(“books.xml”)//title }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>
}Functions and variable definitions in library modules are namespacequalified. Any module can import another module using a module import, which specifies the URI of the module to be imported. It may also specify the location where the module can be found:
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>define function outtie($v as xs:integer) as xs:integer external
define variable $v as xs:integer externaldefine 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 shows the output of that query.
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 TypesOn several occasions, we have mentioned that XQuery can work with untyped data, strongly typed data, or mixtures of the two. If a document is governed by a DTD or has no schema at all, then documents contain very little type information, and queries rely on a set of rules to infer an appropriate type when they encounter values at run-time. For instance, the following query computes the average price of a book in our bibliography data:
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
}In XQuery, a type error is raised when the type of an expression does not match the type required by the context in which it appears. For instance, given the previous function definition, the function call in the following expression raises a type error, since an element named book can never be a valid author element:
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
}When an element is created, it is immediately validated if there is a schema definition for its name. For instance, the following query raises an error because the schema definition says that a book must have a price:
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
}An XQuery implementation that supports static typing can detect this error, because it has the definition for an author element, the function parameter is identified as such, and the schema says that an author element does not have a firt element. In an implementation that has schema import but not static typing, this function would actually have to call the function before the error would be raised.
However, in the following path expression, only the names of elements are stated:
doc("books.xml")/bib/bookListing 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 TypesThe preceding examples include several queries in which the names of types use a notation that can describe the types that arise in XML documents. Now we need to learn that syntax in some detail. Values in XQuery, in general, are sequences, so the types used to describe them are called sequence types. Some types are built in and may be used in any query without importing a schema into the query. Other types are defined in W3C XML Schemas and must be imported into a query before they can be used.
Built-in TypesIf a query has not imported a W3C XML Schema, it still understands the structure of XML documents, including types like document, element, attribute, node, text node, processing instruction, comment, ID, IDREF, IDREFS, etc. In addition to these, it understands the built-in W3C XML Schema simple types.
Table 1.4 lists the built-in types that can be used as sequence types.
In the notation for sequence types, occurrence indicators may be used to indicate the number of items in a sequence. The character ? indicates zero or one items, * indicates zero or more items, and + indicates one or more items. Here are some examples of sequence types with occurrence indicators:
element()+ One or more elements
xs:integer? Zero or one integers
document-node()* Zero or more document nodes
| Sequence Type Declaration | What It Matches |
| element() | Any element node |
| attribute() | Any attribute node |
| document-node() | Any document node |
| node() | Any node |
| text() | Any text node |
| processing-instruction() | Any processing instruction node |
| processing-instruction("xmlstylesheet") | Any processing instruction node whose target is xml-stylesheet |
| comment() | Any comment node |
| empty() | An empty sequence |
| item() | Any node or atomic value |
| QName | An instance of a specific XML Schema built-in type, identified by the name of the type; e.g., xs:string, xs:boolean, xs:decimal, xs:float, xs:double, xs:anyType, xs:anySimpleType |
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>Here is an example of a bibliography element that conforms to this new definition:
<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><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: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"/>
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.Now let us explore the sequence type notation used to refer to constructs imported from the above schema. The basic form of an element test has two parameters: the name of the element and the name of the type:
element(creator, person)element(creator)element(book/price)element(type(person)/last)attribute(@price, currency)attribute(book/@isbn)element(n, person nillable)| Sequence Type Declaration | What It Matches |
| element(creator, person) | An element named creator of type person |
| element(creator) | Any element named creator of type xs:string—the type declared for creator in the schema. |
| element(*, person) | Any element of type person. |
| element(book/price) | An element named price of type currency—the type declared for price elements inside a book element. |
| element(type(person)/last) | An element named last of type xs:string—the type declared for last elements inside the person type. |
| attribute(@price, currency) | An attribute named price of type currency. |
| attribute(book/@isbn) | An attribute named isbn of type isbn—the type declared for isbn attributes in a book element. |
| attribute(@*, currency) | Any attribute of type currency. |
| bib:currency | A value of the user-defined type currency" |
<n xsi:nil=”true” />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>When the typed value of the price element is extracted, its type is bib:currency. The function parameter expects a value of type xs:decimal, but the schema imported into the query says that the currency type is derived from xs:decimal, so it is accepted as a decimal.
In general, the typed value of an element is a sequence. If any value in the argument sequence is untyped, XQuery attempts to convert it to the required type and raises a type error if it fails. For instance, we can call the revised discount-price() function as follows:
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
}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")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>Since the schema for a bibliography allows a book to have editors but no authors, this query will raise an error if such a book is encountered. If a programmer simply assumed all books have authors, using a typed variable might identify an error in a query.
The instance of OperatorThe instance of operator tests an item for a given type. For instance, the following expression tests the variable $a to see if it is an element node:
$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:integerimport schema namespace bib="urn:examples:xmp:bib"
bib:isbn("012345678X") instance of xs:stringListing 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 )The case clause tests to see if $x has a certain type; if it does, the case clause creates a variable of that type and evaluates the associated return clause. The error function is a standard XQuery function that raises an error and aborts execution of the query. Here is the output of the query in Listing 1.31:
<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 ExpressionThe treat as expression asserts that a value has a particular type, and raises an error if it does not. It is similar to a cast, except that it does not change the type of its argument, it merely examines it. Treat as and instance of could be used together to write the function shown in Listing 1.33, which has the same functionality as the function in Listing 1.32.
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!")
}In general, typeswitch is preferable for this kind of code, and it also provides better type information for processors that do static typing.
Implicit Validation and Element ConstructorsWe have already discussed the fact that validation of the elements constructed in a query is automatic if the declaration of an element is global and is found in a schema that has been imported into the query. Elements that do not correspond to a global element definition are not validated. In other words, element construction uses XML Schema’s lax validation mode. The query in Listing 1.34 creates a fully validated book element, with all the associated type information.
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>Because element constructors validate implicitly, errors are caught early, and the types of elements may be used appropriately throughout the expressions of a query. If the element constructor in Listing 1.34 had omitted a required element or misspelled the name of an element, an error would be raised.
Relational programmers are used to writing queries that return tables with only some columns from the original tables that were queried. These tables often have the same names as the original tables, but a different structure. Thus, a relational programmer is likely to write a query like the following:
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>
}The validate expression can also be used to specify a validation context for locally declared elements or attributes. For instance, the price element is locally declared:
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>| Contact Us | | Site Guide | About PerfectXML | Advertise | | Privacy |