Using XQuery, we can select information from XML documents. We can also construct XML structure dynamically which can have results of expressions. We can implement business logic of our application completely because we can perform every kind of computations in its expressions. I think it is also not complete yet because we cannot update or delete information from an XML document using XQuery.

Let’s take a detail look on the syntax of XQuery.

XQuery is an expression driven language. Its version 1.0 is an extension of XPath Version 2.0. Any expression that is syntactically valid and executes successfully in both XPath 2.0 and XQuery 1.0 will return the same result in both languages.

XQuery expression(s) is covered by two braces ( {} ) for example:

{ XQuery expression(s) }

XQuery processor evaluates only the expression which is covered by braces. It considers an expression as a string and does not evalute it if it exists out side of the braces.

<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>39.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>

Following section section introduces each of the basic kinds of XQuery expression.

Primary expressions are the basic primitives of the language. They include literals, variables, function calls, comments, and the use of parentheses to control precedence of operators. Following section take a detail look on each type:

A literal is a direct syntactic representation of an atomic value i.e. it doesn’t contain another value. XQuery supports two kinds of literals: string literals and numeric literals.

Here are some examples of literal expressions:

A variable evaluates to the value to which its name is bound in the evaluation context. Variables can be bound by clauses in for expressions and quantified expressions, and

by function calls. For example

for $var in document (bib.xml)/bib/book return

In the query, result containing book nodes tree is bound to $var variable. Dollar sign ($) is the part of XQuery syntax and is used to represent a varibale.

Parentheses may be used to enforce a particular evaluation order in expressions that contain multiple operators. For example, the expression (2 + 4) * 5 evaluates to thirty, since the parenthesized expression (2 + 4) is evaluated first and its result is multiplied by five. Without parentheses, the expression 2 + 4 * 5 evaluates to twenty-two, because the multiplication operator has higher precedence than the addition operator.

Function call is same like other languages e.g. C++ and Java. A funcation call consists of a function’s signature (function name, and argument list). For example

three-argument-function(1, 2, 3)

XQuery comments can be used to provide informative explanation. For example

{-- This expression calculates prices of books --}

Comments may be used before and after major tokens within expressions and within element content. XQuery ignores the comments and doesn’t evaluate them.

For example:

/bib/book

Above listed expression will return all nodes containing book elements.

/bib/book[@year=2000]/title

Second expression will return titile element as a node of the book element which was released in year 2000.

Arithmetic expressions can be used for calculations like addition, subtraction and multiplication in XQuery.

Here is an example of arithmetic expressions:

let $book := document(bib.xml)/bib/book

return

<result>

{ $book[@year=1992]/price - $book[@year=2000]/price}

</result>

The result is as follows:

<result>

26.0

</result>

Comparison expressions allow two values to be compared. The result of a comparison is always true or false. XQuery contains following type of comparisons:

Value comparisons can be made through following operators: eq, ne, lt, le, gt, ge. The names of the operators are abbreviated. Complete names are as follows:

For example:

Result of the following query is false:

{ 1 eq 2 }

Result of the following query is true:

{ 1 ne 2}

Result is of the following query is true if book contains author named Stevens as his last name:

{ $book/author/last eq Stevens }

General comparison are made thorugh operators: =, !=, <, <=, >, >=. Here is an example of a general comparison:

{ $book/author/last = Stevens }

Result is true if book contains author named Stevens as his last name.

To compaire nodes, XQuery provides two operators is and isnot. For example:

{ $book[@year=2000]/price is $book[@year=1999]/price}

The result of query is false because both are different nodes.

To check order or occurance of an element node, We can use << and >> operators of XQuerry. For example:

{$book/author << $book/price}

The result of the query is true because author element accures before price element in book element.

A logical expression is either an and-expression or an or-expression. Logical expressions are used to validate more than one conditions. Result of logical expression is always true or false.

Here are some examples of logical expressions:

{ 1 eq 1 and 2 eq 2 }

Operator ‘and’ returns true if Its all operands (conditions) reutrn true. Result of above listed expression will be true because both operands (conditions) return true.

{ 1 eq 1 or 2 eq 3}

Operator ‘or’ returns true either one operand (condition) returns true. Result of above listed expression will be true because first operand returns true.

XQuery provides constructors that can create XML structures at run time within a query. There are constructors for elements, attributes, CDATA sections, processing instructions, and comments. The constructed XML structures have to obey XML rules i.e. they should be well-formed XML. Now take a detail look on each of the constructure:

Elements containing every kind of structure (like attributes, text, and further child elemtns etc) can be created in query. For Example:

<book year=2002>

<title> Web Service using Java </title>

<author> Qurban Ali </author>

<publisher> Gill publications </publisher>

<price> 40 </price>

</book>

You can also add expressions in elements to insert values at run time. For Example:

<book year=2002>

--------------------

<price> {20 + 20 } </price>

</book>

XQuery processor will only evalute the expression covered by braces and remaining content will be considered as a simple string. You can place another expression in place of attribute value which return a dynamic value at run time.

We can also use namespaces in element constructor as we declare in XML documents. For Example:

<book xmlns:book=http://www.abc.com year=2002>

<book:title> Web Service using Java </book:title>

<book:author> Qurban Ali </book:author>

<book:publisher> Gill publications </book:publisher>

<book:price> 40 </book:price>

</book>

The result of an attribute constructor is new attribute node. For example:

<book year={2002}>

-----------------------

</book>

The value of year attribute is: 2002.

The syntax for a CDATA section constructor, a processing instruction constructor, or an XML comment constructor is the same as the syntax of the equivalent XML construct.

<?format role=output ?>

<!-- Tags are ignored in the following section -->

<![CDATA[ <Books qty=3/> ]]

A special form of constructor called a computed constructor can be used to create an element or attribute with a computed name or to create a document node.

An alternative way to create nodes is by using a computed constructor. A computed constructor begins with a keyword that identifies the type of node to be created: element, attribute, or document. The keyword element or attribute is followed by the name of the node to be created (document nodes have no name). We create book element throgh computed constrcuture which we have already been created throgh element constructure. For example:

element book

{

attribute year{2002},

element title {Web Service using Java},

element author {Qurban Ali},

element publisher {Gill publications},

element price {50}

}

The result will be same as we have seen in previous example of element constructure.

Creation of document node through computed constructure is usefull when we want to create a new document containing elements of another XML document. For example:

document {

<BookTitileList>

document (bib.xml)/book/title

</BookTitileList>

}

The resulting XML document will contain all titiles of books retrieved from bib.xml. BookTitileList element will be root node of resulting document.

XQuery provides a FLWR expression for iteration and for binding variables to results returned by expressions at run time. The name FLWR, pronounced flower, stands for the keywords for, let, where, and return. It is equivlent to Select statement of SQL.

Although for and let both bind variables, the manner in which variables are bound is quite different. In a let clause, each variable is bound directly to the result of an expression, as a whole. Consider the following query:

let $author := distinct-values(document(bib.xml)/bib/book/author)

return

<result> { $author } </result>

All author nodes returned by expression are bound to $author variable. The method distinct-values is a built-in function which is used to remove repeating nodes from result. XQuery processor will insert whole result at once in result element. The result of this query is as follows:

<result>

<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>

</result>

Now consider a similar query which contains a for clause instead of a let clause:

for $author in distinct-values(document(/XQuery/docs/XMP/bib.xml)/bib/book/author)

return

<result> { $author } </result>

The result of the query is as follows:

<result>

<author>

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

</author>

</result>

<result>

<author>

<last>Abiteboul</last><first>Serge</first>

</author>

</result>

<result>

<author>

<last>Buneman</last><first>Peter</first>

</author>

</result><result>

<author>

<last>Suciu</last><first>Dan</first>

</author>

</result>

Now we can see difference between both results generated by both keywords. For keyword iterates resulting nodes one by one. We can get one node at a time from the tree of resulting nodes to return. Number of iterations are equal to number of resulting nodes. A FLWR Expression may contain multiple for clauses.

XQuery provides ‘where’ keyword. It can be used with both keywords let and for. It is used to put the condition in query so that we can extract only our desired specific nodes as a result. For example:

<result>

{

for $books in document (bib.xml)/bib/book

where $books/author/last eq Abiteboul

return

$books/title

}

</result>

The result of the query is as follows:

<result>

<title>Data on the Web</title>

</result>

XQuery supports a conditional expression based on the keywords if, then, and else. The expression following the if keyword is called the test expression, and the expressions following the then and else keywords are called the then-expression and else-expression, respectively.

If test expression returns true then then-expression will execute and will return value and if test expression returns false then else-expression will execute and will return value.

For example:

let $book := document(bib.xml)//bib/book

return

<result>

{ if ($book/author/last eq Stevens)

then $book[@year=1992 or @year=1994]/title

else ()

}

</result>

The result of the query is as follows:

<result>

<title>TCP/IP Illustrated</title>

<title>Advanced Programming in the Unix environment</title>

</result>

Quantified expressions are used to check the existance of nodes in an XML document through some and every keywords. These expressions always return true or false as a result.

The keyword every returns true if all resulting nodes of an expression satisfies given requirement. Following expression is true if every book element has a year attribute (regardless of the values of these attributes):

In the following query, result will be true because every book element has year attribute:

let $bib := document(bib.xml)//bib

return

<result> { every $bib in $bib satisfies $bib/book/@year} </result>

But the some keyword returns ture if at least single node satisfies given requirement from whole resulting nodes tree. Following expression is true either signle book element has an editor element:

In the following query, restult will be true because one book element contains editor element:

let $bib := document(bib.xml)//bib

return

<result> { some $bib in $bib satisfies $bib/book/editor } </result>

A query consists of a Query Prolog, followed by a Query Body.

The Query Prolog is a series of declarations and definitions that create the environment for query processing. The Query Prolog may contain namespace declarations, schema imports, an xmlspace declaration, a default collation, and some function definitions. Query body contains queries which are used to get results through expressions and/or to produce dynamic XML strucutures.

Namespace is one of the key features of XML. It is used to identify elements uniquely so that ambiguirty can be resolved which is created by same elements of diverse sources. XQuery also supports namespces but syntax of namespace declaration is little different than XML. The following query illustrates a namespace declaration:

declare namespace book=www.abc.com

<book:price>200</book:price>

The namespace declaration is in scope throughout the query in which it is declared, unless it is overridden by a namespace declaration attribute in an element constructor.

A Schema Import imports the element and attribute declarations and type definitions from a schema. A notation is provided to allow a schema to be imported, and a namespace prefix to be bound to the target namespace of the schema, in a single step.

This notation is illustrated by the following example:

import schema namespace book=www.abc.com

at http://www.abc.com/schemas/books.xsd

document (bib.xml)/book:bib

The xmlspace declaration in a Query Prolog controls whether whitespace is preserved by element and attribute constructors during execution of the query. If xmlspace = preserve is specified, whitespace is preserved. If xmlspace = strip is specified or if no xmlspace declaration is present, whitespace is stripped (deleted).

The following example illustrates an xmlspace declaration:

declare xmlspace=preserve

A Query Prolog may declare a default collation, which is the name of the collation to be used by all functions and operators that require a collation if no other collation is specified. For example, the gt operator on strings is defined by a call to the xf:compare function, which takes an optional collation parameter. Since the gt operator does not specify a collation, the xf:compare function implements gt by using the default collation specified in the Query Prolog. The default collation is identified by a literal string containing a URI.

The following example illustrates a declaration of a default collation:

default collation = http://example.org/languages/Icelandic

If a Query Prolog specifies no default collation, the Unicode codepoint collation (http://www.w3.org/2002/08/query-operators/collation/codepoint) is used. If a Query Prolog specifies more than one default collation, or if the value specified for a default collation is not a string literal, a static error is raised.

XQuery contains built in functions but it allows users to define functions of their own. A function definition specifies the name of the function, the names and datatypes of the parameters, and the datatype of the result. These user defined functions can contain business logic of an application.

For example:

define function maxPrice (element $book)

returns string

{

string (max ($book/price))

}

let $book :=document (bib.xml)/bib/book

return

<price>

{

maxPrice ($book)

}

</price>

Methods string and max are built-in functions of XQuery. The result of the above listed query is as follows:

<price> 65.95 </price>

In XQuery 1.0, user-defined functions may not be overloaded. Only one function definition may have a given name. Although it does not allow overloading of user-defined functions, some of the built-in functions in the XQuery core library are overloaded.

XQuery version 1.0 is a working draft, currently published by W3C on 16 Aug 2002. It is a query language for XML documents like SQL is for database tables. It is also expressions driven language and shares the data model of XPath 2.0 but it is more comprehensive and optimized solution than XPath. It contains great features being a query language. It has variety of built-in funcations and operators to perform different tasks. XQuery supports data retrievel and dynamically XML structures creation mechanisms but it doesn’t support updation and deletion mechanisms yet.