Status of this Document
This section describes the status of this document at the
time of its publication. Other documents may supersede this
document. A list of current W3C publications and the latest
revision of this technical report can be found in the W3C technical reports index at
http://www.w3.org/TR/.
This is one document in a set of eight documents that are being
progressed to Recommendation together (XQuery 1.1, XQueryX 1.1,
XSLT 2.1, Data Model 1.1, Functions and Operators 1.1, Formal
Semantics 1.1, Serialization 1.1, XPath 2.1).
This is a First
Public Working Draft as described in the Process
Document. It has been developed by the W3C XML Query Working Group, which
is part of the XML
Activity. The Working Group expects to advance this
specification to Recommendation
Status.
This is the first public Working Draft of XQueryX 1.1. The XML
vocabulary defined herein is intended to be fully aligned with that
of [XQuery 1.1] and is intended to be
fully 'upwards compatible' with the vocabulary defined in XML Syntax for XQuery 1.0
(XQueryX). Failures to achieve either goal will be corrected in
future versions of the Working Drafts of this document.
No implementation report currently exists. However, a Test Suite
for XQueryX 1.1 is under development.
This document incorporates changes made against the final
Recommendation of XML Syntax
for XQuery 1.0 (XQueryX) dated 23 January 2007. Changes to this
document since the publication of the Recommendation are detailed
in D Change log.
Please report errors in this document using W3C's public Bugzilla system
(instructions can be found at http://www.w3.org/XML/2005/04/qt-bugzilla).
If access to that system is not feasible, you may send your
comments to the W3C XSLT/XPath/XQuery public comments mailing list,
public-qt-comments@w3.org.
It will be very helpful if you include the string “[XQX11]” in the
subject line of your report, whether made in Bugzilla or in email.
Please use multiple Bugzilla entries (or, if necessary, multiple
email messages) if you have more than one comment to make. Archives
of the comments and responses are available at http://lists.w3.org/Archives/Public/public-qt-comments/.
Publication as a Working Draft does not imply endorsement by the
W3C Membership. This is a draft document and may be updated,
replaced or obsoleted by other documents at any time. It is
inappropriate to cite this document as other than work in
progress.
This document was produced by a group operating under the
5
February 2004 W3C Patent Policy. W3C maintains a public
list of any patent disclosures made in connection with the
deliverables of the group; that page also includes instructions for
disclosing a patent. An individual who has actual knowledge of a
patent which the individual believes contains
Essential Claim(s) must disclose the information in accordance
with
section 6 of the W3C Patent Policy.
1
Introduction
The [XQuery 1.1
Requirements] states that "The XML Query Language MAY
have more than one syntax binding. One query language syntax MUST
be convenient for humans to read and write. One query language
syntax MUST be expressed in XML in a way that reflects the
underlying structure of the query."
XQueryX is an XML representation of an XQuery. It was created by
mapping the productions of the XQuery grammar into XML productions.
The result is not particularly convenient for humans to read and
write, but it is easy for programs to parse, and because XQueryX is
represented in XML, standard XML tools can be used to create,
interpret, or modify queries.
Note:
Because the two syntaxes are merely different grammars that
express the same query semantics, they share all aspects of an
XQuery processing system except for the component that recognizes
and translates the source representation of a query (that is, the
parser). The aspects that are shared include both the static
context and the dynamic context that are defined in [XQuery 1.1] .
There are several environments in which XQueryX may be
useful:
-
Parser Reuse. In heterogeneous environments, a variety
of systems may be used to execute a query. One parser can generate
XQueryX for all of these systems.
-
Queries on Queries. Because XQueryX is represented in
XML, queries can be queried and can be transformed into new
queries. For instance, a query can be performed against a set of
XQueryX queries to determine which queries use FLWOR expressions to
range over a set of invoices.
-
Generating Queries. In some XML-oriented programming
environments, it may be more convenient to build a query in its
XQueryX representation than in the corresponding XQuery
representation, since ordinary XML tools can be used.
-
Embedding Queries in XML. XQueryX can be embedded
directly in an XML document.
This version of XQueryX is fully compatible with [XML Syntax for XQuery 1.0 (XQueryX)]. It differs
from that earlier version of the language by the addition of new
XML Schema definitions and XSLT stylesheet templates. All queries
expressed in the syntax defined by [XML Syntax
for XQuery 1.0 (XQueryX)] continue to be valid, with the same
meaning, when processed by an implementation of this version of
XQueryX.
The most recent versions of the XQueryX XML Schema and the
XQueryX XSLT stylesheet are available at http://www.w3.org/2008/12/XQueryX/xqueryx.xsd
and http://www.w3.org/2008/12/XQueryX/xqueryx.xsl,
respectively.
Note:
The locations at which the current versions of the XML Schema
and XSLT stylesheet are located during development of this
specification will vary with each Working Draft and Candidate
Recommendation of the spec that is published. The namespace target
URI is identical to that used for XQueryX 1.0.
2 Mapping the XQuery
Syntax
XQueryX is an XML representation of the abstract syntax found in
Appendix A of [XQuery 1.1] .
The XQueryX syntax is defined by the XQueryX Schema, which is
specified in 4 An XML Schema for the XQuery
XML Syntax. The XQueryX semantics are defined by a
stylesheet that maps an instance of XQueryX to an instance of
XQuery; see B Transforming XQueryX to
XQuery.
The main data structure in the XQueryX Schema is the set of
types that describe expressions. We have chosen to model
expressions using substitution groups, with an "expr" abstract base
class and a number of intermediate abstract classes.
Consider the following productions from the abstract syntax:
FLWORExpr ::= InitialClause IntermediateClause* ReturnClause
InitialClause ::= ForClause | LetClause | WindowClause
IntermediateClause ::= InitialClause | WhereClause | GroupByClause | OrderByClause | CountClause
ForClause ::= "outer"? "for" "$" VarName TypeDeclaration? PositionalVar? "in" ExprSingle
("," "$" VarName TypeDeclaration? PositionalVar? "in" ExprSingle)*
PositionalVar ::= "at" "$" VarName
LetClause ::= "let" "$" VarName TypeDeclaration? ":=" ExprSingle
("," "$" VarName TypeDeclaration? ":=" ExprSingle)*
WhereClause ::= "where" ExprSingle
Note:
Those productions do not represent the entire FLWOR expression,
so some of the BNF non-terminal names are not resolved in the
example abstract syntax.
The following XQueryX Schema definitions reflect the structure
of those productions from that abstract syntax:
<!-- The base class -->
<xsd:complexType name="expr"/>
<xsd:element name="expr" type="expr" abstract="true"/>
<!-- Simple wrapper class -->
<xsd:complexType name="exprWrapper">
<xsd:sequence>
<xsd:element ref="expr"/>
</xsd:sequence>
</xsd:complexType>
<xsd:complexType name="flworExpr">
<xsd:complexContent>
<xsd:extension base="expr">
<xsd:sequence>
<xsd:choice>
<xsd:element ref="forClause"/>
<xsd:element ref="letClause"/>
<xsd:element ref="windowClause"/>
</xsd:choice>
<xsd:sequence>
<xsd:choice minOccurs="0" maxOccurs="unbounded">
<xsd:element ref="forClause"/>
<xsd:element ref="letClause"/>
<xsd:element ref="windowClause"/>
<xsd:element ref="countClause"/>
<xsd:element ref="whereClause"/>
<xsd:element ref="groupByClause"/>
<xsd:element ref="orderByClause"/>
</xsd:choice>
<xsd:element ref="returnClause"/>
</xsd:sequence>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="flworExpr" type="flworExpr" substitutionGroup="expr"/>
<xsd:complexType name="forClause">
<xsd:sequence>
<xsd:element ref="forClauseItem" minOccurs="1" maxOccurs="unbounded"/>
</xsd:sequence>
<xsd:attribute name="outer" type="xsd:boolean" default="false"/>
</xsd:complexType>
<xsd:element name="forClause" type="forClause"/>
<xsd:complexType name="forClauseItem">
<xsd:sequence>
<xsd:element ref="typedVariableBinding"/>
<xsd:element ref="positionalVariableBinding" minOccurs="0" maxOccurs="1"/>
<xsd:element ref="forLetClauseItemExtensions" minOccurs="0"
maxOccurs="unbounded"/>
<xsd:element name="forExpr" type="exprWrapper"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="forClauseItem" type="forClauseItem"/>
<xsd:element name="forLetClauseItemExtensions" abstract="true"/>
<xsd:complexType name="letClause">
<xsd:sequence>
<xsd:element ref="letClauseItem" maxOccurs="unbounded"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="letClause" type="letClause"/>
<xsd:complexType name="letClauseItem">
<xsd:sequence>
<xsd:choice>
<xsd:sequence>
<xsd:element ref="typedVariableBinding"/>
<xsd:element ref="forLetClauseItemExtensions"
minOccurs="0" maxOccurs="unbounded"/>
</xsd:sequence>
<xsd:element ref="forLetClauseItemExtensions"
minOccurs="0" maxOccurs="unbounded"/>
</xsd:choice>
<xsd:element name="letExpr" type="exprWrapper"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="letClauseItem" type="letClauseItem"/>
<xsd:element name="whereClause" type="exprWrapper"/>
Since XQuery uses the expression production liberally to allow
expressions to be flexibly combined, XQueryX uses the exprWrapper
type in embedded contexts to allow all expression types to
occur.
3 Examples from the XML
Query Use Cases in XML Syntax
Three of following examples are based on the data and queries in
the XMP (Experiences and Exemplars) use case in [XQuery 1.1 Use Cases] , while a
fourth example is based on the data and queries in the NS (Queries
Using Namespaces) use case. For each example, we show the English
description of the query, the XQuery solution given in
[XQuery 1.1 Use
Cases] , an XQueryX solution, and the XQuery that
results from applying the XQueryX-to-XQuery transformation defined
by the stylesheet in B Transforming
XQueryX to XQuery to the XQueryX solution. That produced
XQuery is presented only as a sanity-check — the intent of the
stylesheet is not to create the identical XQuery expression given
in [XQuery 1.1 Use
Cases] , but to produce a valid XQuery
expression with the same semantics. The semantics of the XQueryX
solution are determined by the semantics of the XQuery expression
that results from that transformation. The "correctness" of that
transformation is determined by asking the following the question:
Can some XQueryX processor QX process some XQueryX document D1 to
produce results R1, after which the stylesheet is used to translate
D1 into an XQuery expression E1 that, when processed by some XQuery
processor Q, produces results R2 that are equivalent (under some
meaningful definition of "equivalent") to results R1?
Comparison of the results of the XQueryX-to-XQuery
transformation given in this document with the XQuery solutions in
the [XQuery 1.1 Use
Cases] may be helpful in evaluating the correctness of
the XQueryX solution in each example.
The XQuery Use Cases solution given for each example is provided
only to assist readers of this document in understanding the
XQueryX solution. There is no intent to imply that this document
specifies a "compilation" or "transformation" of XQuery syntax into
XQueryX syntax.
In the following examples, note that path expressions are
expanded to show their structure. Also, note that the prefix syntax
for binary operators like "and" makes the precedence explicit. In
general, humans find it easier to read an XML representation that
does not expand path expressions, but it is less convenient for
programmatic representation and manipulation. XQueryX is designed
as a language that is convenient for production and modification by
software, and not as a convenient syntax for humans to read and
write.
Finally, please note that white space, including new lines, have
been added to some of the XQueryX documents and XQuery expressions
for readability. That additional white space is not produced by the
XQueryX-to-XQuery transformation.
3.1 Example 1
Here is Q1 from the [XQuery
1.1 Use Cases] , use case XMP (Experiences and
Exemplars): "List books published by Addison-Wesley after 1991,
including their year and title."
3.1.1 XQuery
solution in XQuery Use Cases:
<bib>
{
for $b in doc("http://bstore1.example.com/bib.xml")/bib/book
where $b/publisher = "Addison-Wesley" and $b/@year > 1991
return
<book year="{ $b/@year }">
{ $b/title }
</book>
}
</bib>
3.1.2 A
Solution in XQueryX:
<?xml version="1.0"?>
<xqx:module xmlns:xqx="http://www.w3.org/2005/XQueryX"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.w3.org/2005/XQueryX
http://www.w3.org/2005/XQueryX/xqueryx.xsd">
<xqx:mainModule>
<xqx:queryBody>
<xqx:elementConstructor>
<xqx:tagName>bib</xqx:tagName>
<xqx:elementContent>
<xqx:flworExpr>
<xqx:forClause>
<xqx:forClauseItem>
<xqx:typedVariableBinding>
<xqx:varName>b</xqx:varName>
</xqx:typedVariableBinding>
<xqx:forExpr>
<xqx:pathExpr>
<xqx:stepExpr>
<xqx:filterExpr>
<xqx:functionCallExpr>
<xqx:functionName>doc</xqx:functionName>
<xqx:arguments>
<xqx:stringConstantExpr>
<xqx:value>http://bstore1.example.com/bib.xml</xqx:value>
</xqx:stringConstantExpr>
</xqx:arguments>
</xqx:functionCallExpr>
</xqx:filterExpr>
</xqx:stepExpr>
<xqx:stepExpr>
<xqx:xpathAxis>child</xqx:xpathAxis>
<xqx:nameTest>bib</xqx:nameTest>
</xqx:stepExpr>
<xqx:stepExpr>
<xqx:xpathAxis>child</xqx:xpathAxis>
<xqx:nameTest>book</xqx:nameTest>
</xqx:stepExpr>
</xqx:pathExpr>
</xqx:forExpr>
</xqx:forClauseItem>
</xqx:forClause>
<xqx:whereClause>
<xqx:andOp>
<xqx:firstOperand>
<xqx:equalOp>
<xqx:firstOperand>
<xqx:pathExpr>
<xqx:stepExpr>
<xqx:filterExpr>
<xqx:varRef>
<xqx:name>b</xqx:name>
</xqx:varRef>
</xqx:filterExpr>
</xqx:stepExpr>
<xqx:stepExpr>
<xqx:xpathAxis>child</xqx:xpathAxis>
<xqx:nameTest>publisher</xqx:nameTest>
</xqx:stepExpr>
</xqx:pathExpr>
</xqx:firstOperand>
<xqx:secondOperand>
<xqx:stringConstantExpr>
<xqx:value>Addison-Wesley</xqx:value>
</xqx:stringConstantExpr>
</xqx:secondOperand>
</xqx:equalOp>
</xqx:firstOperand>
<xqx:secondOperand>
<xqx:greaterThanOp>
<xqx:firstOperand>
<xqx:pathExpr>
<xqx:stepExpr>
<xqx:filterExpr>
<xqx:varRef>
<xqx:name>b</xqx:name>
</xqx:varRef>
</xqx:filterExpr>
</xqx:stepExpr>
<xqx:stepExpr>
<xqx:xpathAxis>attribute</xqx:xpathAxis>
<xqx:nameTest>year</xqx:nameTest>
</xqx:stepExpr>
</xqx:pathExpr>
</xqx:firstOperand>
<xqx:secondOperand>
<xqx:integerConstantExpr>
<xqx:value>1991</xqx:value>
</xqx:integerConstantExpr>
</xqx:secondOperand>
</xqx:greaterThanOp>
</xqx:secondOperand>
</xqx:andOp>
</xqx:whereClause>
<xqx:returnClause>
<xqx:elementConstructor>
<xqx:tagName>book</xqx:tagName>
<xqx:attributeList>
<xqx:attributeConstructor>
<xqx:attributeName>year</xqx:attributeName>
<xqx:attributeValueExpr>
<xqx:pathExpr>
<xqx:stepExpr>
<xqx:filterExpr>
<xqx:varRef>
<xqx:name>b</xqx:name>
</xqx:varRef>
</xqx:filterExpr>
</xqx:stepExpr>
<xqx:stepExpr>
<xqx:xpathAxis>attribute</xqx:xpathAxis>
<xqx:nameTest>year</xqx:nameTest>
</xqx:stepExpr>
</xqx:pathExpr>
</xqx:attributeValueExpr>
</xqx:attributeConstructor>
</xqx:attributeList>
<xqx:elementContent>
<xqx:pathExpr>
<xqx:stepExpr>
<xqx:filterExpr>
<xqx:varRef>
<xqx:name>b</xqx:name>
</xqx:varRef>
</xqx:filterExpr>
</xqx:stepExpr>
<xqx:stepExpr>
<xqx:xpathAxis>child</xqx:xpathAxis>
<xqx:nameTest>title</xqx:nameTest>
</xqx:stepExpr>
</xqx:pathExpr>
</xqx:elementContent>
</xqx:elementConstructor>
</xqx:returnClause>
</xqx:flworExpr>
</xqx:elementContent>
</xqx:elementConstructor>
</xqx:queryBody>
</xqx:mainModule>
</xqx:module>
3.1.3 Transformation of XQueryX
Solution into XQuery
Application of the stylesheet in B
Transforming XQueryX to XQuery to the XQueryX solution
results in:
<bib>{
for $b in doc("http://bstore1.example.com/bib.xml")/child::bib/child::book
where (($b/child::publisher = "Addison-Wesley") and ($b/attribute::year > 1991))
return <book year="{$b/attribute::year}">{$b/child::title}</book>
}</bib>
3.1.4
Corresponding Grammar Abstract Parse Tree
For comparison, here is the abstract parse tree corresponding to
the XQuery for Example 1, as produced by the XQuery grammar applets
found at http://www.w3.org/2007/01/applets/.
XPath2
QueryList
Module
MainModule
Prolog
QueryBody
Expr
PathExpr
Constructor
DirectConstructor
DirElemConstructor >
LessThanOpOrTagO <
TagQName bib
DirAttributeList
StartTagClose >
DirElemContent
ElementContentChar
DirElemContent
ElementContentChar
DirElemContent
CommonContent
EnclosedExpr
Lbrace {
Expr
FLWORExpr
ForClause
VarName
QName b
PathExpr
FunctionCall
FunctionQName doc
PathExpr
StringLiteral "http://bstore1.example.com/bib.xml"
StepExpr
AbbrevForwardStep
NodeTest
NameTest
QName bib
StepExpr
AbbrevForwardStep
NodeTest
NameTest
QName book
WhereClause
AndExpr and
ComparisonExpr =
PathExpr
VarName
QName b
StepExpr
AbbrevForwardStep
NodeTest
NameTest
QName publisher
PathExpr
StringLiteral "Addison-Wesley"
ComparisonExpr >
PathExpr
VarName
QName b
StepExpr
AbbrevForwardStep @
NodeTest
NameTest
QName year
PathExpr
IntegerLiteral 1991
PathExpr
Constructor
DirectConstructor
DirElemConstructor >
LessThanOpOrTagO <
TagQName book
DirAttributeList
S
TagQName year
ValueIndicator =
DirAttributeValue
OpenQuot "
QuotAttrValueContent
CommonContent
EnclosedExpr
Lbrace {
Expr
PathExpr
VarName
QName b
StepExpr
AbbrevForwardStep @
NodeTest
NameTest
QName year
Rbrace }
CloseQuot "
StartTagClose >
DirElemContent
ElementContentChar
DirElemContent
ElementContentChar
DirElemContent
ElementContentChar
DirElemContent
ElementContentChar
DirElemContent
ElementContentChar
DirElemContent
ElementContentChar
DirElemContent
CommonContent
EnclosedExpr
Lbrace {
Expr
PathExpr
VarName
QName b
StepExpr
AbbrevForwardStep
NodeTest
NameTest
QName title
Rbrace }
DirElemContent
ElementContentChar
DirElemContent
ElementContentChar
DirElemContent
ElementContentChar
DirElemContent
ElementContentChar
DirElemContent </
ElementContentChar
Rbrace }
DirElemContent </
ElementContentChar
3.2 Example 2
Here is Q4 from the [XQuery
1.1 Use Cases] , use case XMP (Experiences and
Exemplars): "For each author in the bibliography, list the author's
name and the titles of all books by that author, grouped inside a
"result" element."
3.2.1 XQuery
solution in XQuery Use Cases:
<results>
{
let $a := doc("http://bstore1.example.com/bib/bib.xml")//author
for $last in distinct-values($a/last),
$first in distinct-values($a[last=$last]/first)
order by $last, $first
return
<result>
<author>
<last>{ $last }</last>
<first>{ $first }</first>
</author>
{
for $b in doc("http://bstore1.example.com/bib.xml")/bib/book
where some $ba in $b/author
satisfies ($ba/last = $last and $ba/first=$first)
return $b/title
}
</result>
}
</results>
3.2.2 A
solution in XQueryX:
<?xml version="1.0"?>
<xqx:module xmlns:xqx="http://www.w3.org/2005/XQueryX"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.w3.org/2005/XQueryX
http://www.w3.org/2005/XQueryX/xqueryx.xsd">
<xqx:mainModule>
<xqx:queryBody>
<xqx:elementConstructor>
<xqx:tagName>results</xqx:tagName>
<xqx:elementContent>
<xqx:flworExpr>
<xqx:letClause>
<xqx:letClauseItem>
<xqx:typedVariableBinding>
<xqx:varName>a</xqx:varName>
</xqx:typedVariableBinding>
<xqx:letExpr>
<xqx:pathExpr>
<xqx:stepExpr>
<xqx:filterExpr>
<xqx:functionCallExpr>
<xqx:functionName>doc</xqx:functionName>
<xqx:arguments>
<xqx:stringConstantExpr>
<xqx:value>http://bstore1.example.com/bib.xml</xqx:value>
</xqx:stringConstantExpr>
</xqx:arguments>
</xqx:functionCallExpr>
</xqx:filterExpr>
</xqx:stepExpr>
<xqx:stepExpr>
<xqx:xpathAxis>descendant-or-self</xqx:xpathAxis>
<xqx:anyKindTest/>
</xqx:stepExpr>
<xqx:stepExpr>
<xqx:xpathAxis>child</xqx:xpathAxis>
<xqx:nameTest>author</xqx:nameTest>
</xqx:stepExpr>
</xqx:pathExpr>
</xqx:letExpr>
</xqx:letClauseItem>
</xqx:letClause>
<xqx:forClause>
<xqx:forClauseItem>
<xqx:typedVariableBinding>
<xqx:varName>last</xqx:varName>
</xqx:typedVariableBinding>
<xqx:forExpr>
<xqx:functionCallExpr>
<xqx:functionName>distinct-values</xqx:functionName>
<xqx:arguments>
<xqx:pathExpr>
<xqx:stepExpr>
<xqx:filterExpr>
<xqx:varRef>
<xqx:name>a</xqx:name>
</xqx:varRef>
</xqx:filterExpr>
</xqx:stepExpr>
<xqx:stepExpr>
<xqx:xpathAxis>child</xqx:xpathAxis>
<xqx:nameTest>last</xqx:nameTest>
</xqx:stepExpr>
</xqx:pathExpr>
</xqx:arguments>
</xqx:functionCallExpr>
</xqx:forExpr>
</xqx:forClauseItem>
<xqx:forClauseItem>
<xqx:typedVariableBinding>
<xqx:varName>first</xqx:varName>
</xqx:typedVariableBinding>
<xqx:forExpr>
<xqx:functionCallExpr>
<xqx:functionName>distinct-values</xqx:functionName>
<xqx:arguments>
<xqx:pathExpr>
<xqx:stepExpr>
<xqx:filterExpr>
<xqx:varRef>
<xqx:name>a</xqx:name>
</xqx:varRef>
</xqx:filterExpr>
<xqx:predicates>
<xqx:equalOp>
<xqx:firstOperand>
<xqx:pathExpr>
<xqx:stepExpr>
<xqx:filterExpr>
<xqx:contextItemExpr/>
</xqx:filterExpr>
</xqx:stepExpr>
<xqx:stepExpr>
<xqx:xpathAxis>child</xqx:xpathAxis>
<xqx:nameTest>last</xqx:nameTest>
</xqx:stepExpr>
</xqx:pathExpr>
</xqx:firstOperand>
<xqx:secondOperand>
<xqx:varRef>
<xqx:name>last</xqx:name>
</xqx:varRef>
</xqx:secondOperand>
</xqx:equalOp>
</xqx:predicates>
</xqx:stepExpr>
<xqx:stepExpr>
<xqx:xpathAxis>child</xqx:xpathAxis>
<xqx:nameTest>first</xqx:nameTest>
</xqx:stepExpr>
</xqx:pathExpr>
</xqx:arguments>
</xqx:functionCallExpr>
</xqx:forExpr>
</xqx:forClauseItem>
</xqx:forClause>
<xqx:orderByClause>
<xqx:orderBySpec>
<xqx:orderByExpr>
<xqx:varRef>
<xqx:name>last</xqx:name>
</xqx:varRef>
</xqx:orderByExpr>
</xqx:orderBySpec>
<xqx:orderBySpec>
<xqx:orderByExpr>
<xqx:varRef>
<xqx:name>first</xqx:name>
</xqx:varRef>
</xqx:orderByExpr>
</xqx:orderBySpec>
</xqx:orderByClause>
<xqx:returnClause>
<xqx:elementConstructor>
<xqx:tagName>result</xqx:tagName>
<xqx:elementContent>
<xqx:elementConstructor>
<xqx:tagName>author</xqx:tagName>
<xqx:elementContent>
<xqx:elementConstructor>
<xqx:tagName>last</xqx:tagName>
<xqx:elementContent>
<xqx:varRef>
<xqx:name>last</xqx:name>
</xqx:varRef>
</xqx:elementContent>
</xqx:elementConstructor>
<xqx:elementConstructor>
<xqx:tagName>first</xqx:tagName>
<xqx:elementContent>
<xqx:varRef>
<xqx:name>first</xqx:name>
</xqx:varRef>
</xqx:elementContent>
</xqx:elementConstructor>
</xqx:elementContent>
</xqx:elementConstructor>
<xqx:flworExpr>
<xqx:forClause>
<xqx:forClauseItem>
<xqx:typedVariableBinding>
<xqx:varName>b</xqx:varName>
</xqx:typedVariableBinding>
<xqx:forExpr>
<xqx:pathExpr>
<xqx:stepExpr>
<xqx:filterExpr>
<xqx:functionCallExpr>
<xqx:functionName>doc</xqx:functionName>
<xqx:arguments>
<xqx:stringConstantExpr>
<xqx:value>http://bstore1.example.com/bib.xml</xqx:value>
</xqx:stringConstantExpr>
</xqx:arguments>
</xqx:functionCallExpr>
</xqx:filterExpr>
</xqx:stepExpr>
<xqx:stepExpr>
<xqx:xpathAxis>child</xqx:xpathAxis>
<xqx:nameTest>bib</xqx:nameTest>
</xqx:stepExpr>
<xqx:stepExpr>
<xqx:xpathAxis>child</xqx:xpathAxis>
<xqx:nameTest>book</xqx:nameTest>
</xqx:stepExpr>
</xqx:pathExpr>
</xqx:forExpr>
</xqx:forClauseItem>
</xqx:forClause>
<xqx:whereClause>
<xqx:quantifiedExpr>
<xqx:quantifier>some</xqx:quantifier>
<xqx:quantifiedExprInClause>
<xqx:typedVariableBinding>
<xqx:varName>ba</xqx:varName>
</xqx:typedVariableBinding>
<xqx:sourceExpr>
<xqx:pathExpr>
<xqx:stepExpr>
<xqx:filterExpr>
<xqx:varRef>
<xqx:name>b</xqx:name>
</xqx:varRef>
</xqx:filterExpr>
</xqx:stepExpr>
<xqx:stepExpr>
<xqx:xpathAxis>child</xqx:xpathAxis>
<xqx:nameTest>author</xqx:nameTest>
</xqx:stepExpr>
</xqx:pathExpr>
</xqx:sourceExpr>
</xqx:quantifiedExprInClause>
<xqx:predicateExpr>
<xqx:andOp>
<xqx:firstOperand>
<xqx:equalOp>
<xqx:firstOperand>
<xqx:pathExpr>
<xqx:stepExpr>
<xqx:filterExpr>
<xqx:varRef>
<xqx:name>ba</xqx:name>
</xqx:varRef>
</xqx:filterExpr>
</xqx:stepExpr>
<xqx:stepExpr>
<xqx:xpathAxis>child</xqx:xpathAxis>
<xqx:nameTest>last</xqx:nameTest>
</xqx:stepExpr>
</xqx:pathExpr>
</xqx:firstOperand>
<xqx:secondOperand>
<xqx:varRef>
<xqx:name>last</xqx:name>
</xqx:varRef>
</xqx:secondOperand>
</xqx:equalOp>
</xqx:firstOperand>
<xqx:secondOperand>
<xqx:equalOp>
<xqx:firstOperand>
<xqx:pathExpr>
<xqx:stepExpr>
<xqx:filterExpr>
<xqx:varRef>
<xqx:name>ba</xqx:name>
</xqx:varRef>
</xqx:filterExpr>
</xqx:stepExpr>
<xqx:stepExpr>
<xqx:xpathAxis>child</xqx:xpathAxis>
<xqx:nameTest>first</xqx:nameTest>
</xqx:stepExpr>
</xqx:pathExpr>
</xqx:firstOperand>
<xqx:secondOperand>
<xqx:varRef>
<xqx:name>first</xqx:name>
</xqx:varRef>
</xqx:secondOperand>
</xqx:equalOp>
</xqx:secondOperand>
</xqx:andOp>
</xqx:predicateExpr>
</xqx:quantifiedExpr>
</xqx:whereClause>
<xqx:returnClause>
<xqx:pathExpr>
<xqx:stepExpr>
<xqx:filterExpr>
<xqx:varRef>
<xqx:name>b</xqx:name>
</xqx:varRef>
</xqx:filterExpr>
</xqx:stepExpr>
<xqx:stepExpr>
<xqx:xpathAxis>child</xqx:xpathAxis>
<xqx:nameTest>title</xqx:nameTest>
</xqx:stepExpr>
</xqx:pathExpr>
</xqx:returnClause>
</xqx:flworExpr>
</xqx:elementContent>
</xqx:elementConstructor>
</xqx:returnClause>
</xqx:flworExpr>
</xqx:elementContent>
</xqx:elementConstructor>
</xqx:queryBody>
</xqx:mainModule>
</xqx:module>
3.2.3 Transformation of XQueryX
Solution into XQuery
Application of the stylesheet in B
Transforming XQueryX to XQuery to the XQueryX solution
results in:
<results>{
let $a:=doc("http://bstore1.example.com/bib.xml")/descendant-or-self::node()/child::author
for $last in distinct-values($a/child::last), $first in distinct-values($a[(./child::last = $last)]/child::first)
order by $last , $first
return <result><author><last>{$last}</last><first>{$first}</first></author>{
for $b in doc("http://bstore1.example.com/bib.xml")/child::bib/child::book
where (some $ba in $b/child::author satisfies (($ba/child::last = $last) and ($ba/child::first = $first)))
return $b/child::title
}</result>
}</results>
3.3 Example 3
Here is Q7 from the [XQuery
1.1 Use Cases] , use case XMP (Experiences and
Exemplars): "List the titles and years of all books published by
Addison-Wesley after 1991, in alphabetic order."
3.3.1 XQuery
solution in XQuery Use Cases:
<bib>
{
for $b in doc("http://bstore1.example.com/bib.xml")//book
where $b/publisher = "Addison-Wesley" and $b/@year > 1991
order by $b/title
return
<book>
{ $b/@year }
{ $b/title }
</book>
}
</bib>
3.3.2 A
solution in XQueryX:
<?xml version="1.0"?>
<xqx:module xmlns:xqx="http://www.w3.org/2005/XQueryX"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.w3.org/2005/XQueryX
http://www.w3.org/2005/XQueryX/xqueryx.xsd">
<xqx:mainModule>
<xqx:queryBody>
<xqx:elementConstructor>
<xqx:tagName>bib</xqx:tagName>
<xqx:elementContent>
<xqx:flworExpr>
<xqx:forClause>
<xqx:forClauseItem>
<xqx:typedVariableBinding>
<xqx:varName>b</xqx:varName>
</xqx:typedVariableBinding>
<xqx:forExpr>
<xqx:pathExpr>
<xqx:stepExpr>
<xqx:filterExpr>
<xqx:functionCallExpr>
<xqx:functionName>doc</xqx:functionName>
<xqx:arguments>
<xqx:stringConstantExpr>
<xqx:value>http://bstore1.example.com/bib.xml</xqx:value>
</xqx:stringConstantExpr>
</xqx:arguments>
</xqx:functionCallExpr>
</xqx:filterExpr>
</xqx:stepExpr>
<xqx:stepExpr>
<xqx:xpathAxis>descendant-or-self</xqx:xpathAxis>
<xqx:anyKindTest/>
</xqx:stepExpr>
<xqx:stepExpr>
<xqx:xpathAxis>child</xqx:xpathAxis>
<xqx:nameTest>book</xqx:nameTest>
</xqx:stepExpr>
</xqx:pathExpr>
</xqx:forExpr>
</xqx:forClauseItem>
</xqx:forClause>
<xqx:whereClause>
<xqx:andOp>
<xqx:firstOperand>
<xqx:equalOp>
<xqx:firstOperand>
<xqx:pathExpr>
<xqx:stepExpr>
<xqx:filterExpr>
<xqx:varRef>
<xqx:name>b</xqx:name>
</xqx:varRef>
</xqx:filterExpr>
</xqx:stepExpr>
<xqx:stepExpr>
<xqx:xpathAxis>child</xqx:xpathAxis>
<xqx:nameTest>publisher</xqx:nameTest>
</xqx:stepExpr>
</xqx:pathExpr>
</xqx:firstOperand>
<xqx:secondOperand>
<xqx:stringConstantExpr>
<xqx:value>Addison-Wesley</xqx:value>
</xqx:stringConstantExpr>
</xqx:secondOperand>
</xqx:equalOp>
</xqx:firstOperand>
<xqx:secondOperand>
<xqx:greaterThanOp>
<xqx:firstOperand>
<xqx:pathExpr>
<xqx:stepExpr>
<xqx:filterExpr>
<xqx:varRef>
<xqx:name>b</xqx:name>
</xqx:varRef>
</xqx:filterExpr>
</xqx:stepExpr>
<xqx:stepExpr>
<xqx:xpathAxis>attribute</xqx:xpathAxis>
<xqx:nameTest>year</xqx:nameTest>
</xqx:stepExpr>
</xqx:pathExpr>
</xqx:firstOperand>
<xqx:secondOperand>
<xqx:integerConstantExpr>
<xqx:value>1991</xqx:value>
</xqx:integerConstantExpr>
</xqx:secondOperand>
</xqx:greaterThanOp>
</xqx:secondOperand>
</xqx:andOp>
</xqx:whereClause>
<xqx:orderByClause>
<xqx:orderBySpec>
<xqx:orderByExpr>
<xqx:pathExpr>
<xqx:stepExpr>
<xqx:filterExpr>
<xqx:varRef>
<xqx:name>b</xqx:name>
</xqx:varRef>
</xqx:filterExpr>
</xqx:stepExpr>
<xqx:stepExpr>
<xqx:xpathAxis>child</xqx:xpathAxis>
<xqx:nameTest>title</xqx:nameTest>
</xqx:stepExpr>
</xqx:pathExpr>
</xqx:orderByExpr>
</xqx:orderBySpec>
</xqx:orderByClause>
<xqx:returnClause>
<xqx:elementConstructor>
<xqx:tagName>book</xqx:tagName>
<xqx:elementContent>
<xqx:pathExpr>
<xqx:stepExpr>
<xqx:filterExpr>
<xqx:varRef>
<xqx:name>b</xqx:name>
</xqx:varRef>
</xqx:filterExpr>
</xqx:stepExpr>
<xqx:stepExpr>
<xqx:xpathAxis>attribute</xqx:xpathAxis>
<xqx:nameTest>year</xqx:nameTest>
</xqx:stepExpr>
</xqx:pathExpr>
<xqx:pathExpr>
<xqx:stepExpr>
<xqx:filterExpr>
<xqx:varRef>
<xqx:name>b</xqx:name>
</xqx:varRef>
</xqx:filterExpr>
</xqx:stepExpr>
<xqx:stepExpr>
<xqx:xpathAxis>child</xqx:xpathAxis>
<xqx:nameTest>title</xqx:nameTest>
</xqx:stepExpr>
</xqx:pathExpr>
</xqx:elementContent>
</xqx:elementConstructor>
</xqx:returnClause>
</xqx:flworExpr>
</xqx:elementContent>
</xqx:elementConstructor>
</xqx:queryBody>
</xqx:mainModule>
</xqx:module>
3.3.3 Transformation of XQueryX
Solution into XQuery
Application of the stylesheet in B
Transforming XQueryX to XQuery to the XQueryX solution
results in:
<bib>{
for $b in doc("http://bstore1.example.com/bib.xml")/descendant-or-self::node()/child::book
where (($b/child::publisher = "Addison-Wesley") and ($b/attribute::year > 1991))
order by $b/child::title
return <book>{$b/attribute::year}{$b/child::title}</book>
}</bib>
3.4 Example 4
Here is Q8 from the [XQuery
1.1 Use Cases] , use case NS (Queries Using Namespaces):
"Select all traders (either seller or high bidder) without negative
comments."
3.4.1 XQuery
solution in XQuery Use Cases:
declare namespace ma = "http://www.example.com/AuctionWatch";
<Q8 xmlns:ma="http://www.example.com/AuctionWatch"
xmlns:eachbay="http://www.example.com/auctioneers#eachbay"
xmlns:xlink="http://www.w3.org/1999/xlink">
{
for $s in doc("auction.xml")//ma:Trading_Partners/(ma:Seller | ma:High_Bidder)
where $s/*:NegativeComments = 0
return $s
}
</Q8>
3.4.2 A
solution in XQueryX:
<?xml version="1.0"?>
<!-- ================================================================================ -->
<!-- Errata applied: -->
<!-- XQX.E2 - Editorial (Bugzilla Bug 4963) -->
<!-- ================================================================================ -->
<xqx:module xmlns:xqx="http://www.w3.org/2005/XQueryX"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.w3.org/2005/XQueryX
http://www.w3.org/2005/XQueryX/xqueryx.xsd">
<xqx:mainModule>
<xqx:prolog>
<xqx:namespaceDecl>
<xqx:prefix>ma</xqx:prefix>
<xqx:uri>http://www.example.com/AuctionWatch</xqx:uri>
</xqx:namespaceDecl>
</xqx:prolog>
<xqx:queryBody>
<xqx:elementConstructor>
<xqx:tagName>Q8</xqx:tagName>
<xqx:attributeList>
<xqx:namespaceDeclaration>
<xqx:prefix>ma</xqx:prefix>
<xqx:uri>http://www.example.com/AuctionWatch</xqx:uri>
</xqx:namespaceDeclaration>
<xqx:namespaceDeclaration>
<xqx:prefix>eachbay</xqx:prefix>
<xqx:uri>http://www.example.com/auctioneers#eachbay</xqx:uri>
</xqx:namespaceDeclaration>
<xqx:namespaceDeclaration>
<xqx:prefix>xlink</xqx:prefix>
<xqx:uri>http://www.w3.org/1999/xlink</xqx:uri>
</xqx:namespaceDeclaration>
</xqx:attributeList>
<xqx:elementContent>
<xqx:flworExpr>
<xqx:forClause>
<xqx:forClauseItem>
<xqx:typedVariableBinding>
<xqx:varName>s</xqx:varName>
</xqx:typedVariableBinding>
<xqx:forExpr>
<xqx:pathExpr>
<xqx:stepExpr>
<xqx:filterExpr>
<xqx:functionCallExpr>
<xqx:functionName xqx:prefix="fn">doc</xqx:functionName>
<xqx:arguments>
<xqx:stringConstantExpr>
<xqx:value>auction.xml</xqx:value>
</xqx:stringConstantExpr>
</xqx:arguments>
</xqx:functionCallExpr>
</xqx:filterExpr>
</xqx:stepExpr>
<xqx:stepExpr>
<xqx:xpathAxis>descendant-or-self</xqx:xpathAxis>
<xqx:anyKindTest/>
</xqx:stepExpr>
<xqx:stepExpr>
<xqx:xpathAxis>child</xqx:xpathAxis>
<xqx:nameTest xqx:prefix="ma">Trading_Partners</xqx:nameTest>
</xqx:stepExpr>
<xqx:stepExpr>
<xqx:filterExpr>
<xqx:sequenceExpr>
<xqx:unionOp>
<xqx:firstOperand>
<xqx:pathExpr>
<xqx:stepExpr>
<xqx:xpathAxis>child</xqx:xpathAxis>
<xqx:nameTest xqx:prefix="ma">Seller</xqx:nameTest>
</xqx:stepExpr>
</xqx:pathExpr>
</xqx:firstOperand>
<xqx:secondOperand>
<xqx:pathExpr>
<xqx:stepExpr>
<xqx:xpathAxis>child</xqx:xpathAxis>
<xqx:nameTest xqx:prefix="ma">High_Bidder</xqx:nameTest>
</xqx:stepExpr>
</xqx:pathExpr>
</xqx:secondOperand>
</xqx:unionOp>
</xqx:sequenceExpr>
</xqx:filterExpr>
</xqx:stepExpr>
</xqx:pathExpr>
</xqx:forExpr>
</xqx:forClauseItem>
</xqx:forClause>
<xqx:whereClause>
<xqx:equalOp>
<xqx:firstOperand>
<xqx:pathExpr>
<xqx:stepExpr>
<xqx:filterExpr>
<xqx:varRef>
<xqx:name>s</xqx:name>
</xqx:varRef>
</xqx:filterExpr>
</xqx:stepExpr>
<xqx:stepExpr>
<xqx:xpathAxis>child</xqx:xpathAxis>
<xqx:Wildcard>
<xqx:star/>
<xqx:NCName>NegativeComments</xqx:NCName>
</xqx:Wildcard>
</xqx:stepExpr>
</xqx:pathExpr>
</xqx:firstOperand>
<xqx:secondOperand>
<xqx:integerConstantExpr>
<xqx:value>0</xqx:value>
</xqx:integerConstantExpr>
</xqx:secondOperand>
</xqx:equalOp>
</xqx:whereClause>
<xqx:returnClause>
<xqx:varRef>
<xqx:name>s</xqx:name>
</xqx:varRef>
</xqx:returnClause>
</xqx:flworExpr>
</xqx:elementContent>
</xqx:elementConstructor>
</xqx:queryBody>
</xqx:mainModule>
</xqx:module>
3.4.3 Transformation of XQueryX
Solution into XQuery
Application of the stylesheet in B
Transforming XQueryX to XQuery to the XQueryX solution
results in:
declare namespace ma="http://www.example.com/AuctionWatch";
<Q8 xmlns:ma="http://www.example.com/AuctionWatch"
xmlns:eachbay="http://www.example.com/auctioneers#eachbay"
xmlns:xlink="http://www.w3.org/1999/xlink">{
for $s in fn:doc("auction.xml")/descendant-or-self::node()/
child::ma:Trading_Partners/
((child::ma:Seller union child::ma:High_Bidder))
where ($s/child::*:NegativeComments = 0)
return $s
}</Q8>
4 An XML Schema for the XQuery
XML Syntax
Here is the XML Schema against which XQueryX documents must be
valid.
<?xml version="1.0"?>
<!-- ================================================================================ -->
<!-- NOTES TO READERS OF THIS SCHEMA: -->
<!-- The default value for both minOccurs and maxOccurs is "1". -->
<!-- The XQueryX schema has been designed to provide the ability to extend definitions -->
<!-- of top-level elements in extensions such as Full-Text and the Update Facility. -->
<!-- The nature of the modification is to define named complex types and redefine -->
<!-- those top-level elements in terms of the named complex types. -->
<!-- ================================================================================ -->
<!-- Changes from Recommendation (edition 1): -->
<!-- * Element defs using anon complex types changed to use named types (bug #4924) -->
<!-- * In Example 4, replaced xqx:parentheziedExpr with xqx:sequenceExpr (bug #4963) -->
<!-- * In XSLT stylesheet, deleted template for xqx:parenthesizedExpr (bug #4963) -->
<!-- * Replaced link to grammar applet with correct link (bug #5323) -->
<!-- * In XSLT stylesheet, corrected template for xqx:namespaceDeclaration (bug #5343) -->
<!-- Changes from Recommendation (edition 2): -->
<!-- * Added support for new Windowing clause in FLWOR expression -->
<!-- * Added support for new Group By Clause in FLWOR expression -->
<!-- * Added support for new Count Clause in FLWOR expression -->
<!-- * Added support for keyword "outer" on for expression -->
<!-- * Modified structure of FLWOR clause per "simplified FLWOR expressions" -->
<!-- * Modified validation syntax per Bugzilla Bug 5472 -->
<!-- * Modified function declaration so that external functions can be nondeterminstic -->
<!-- * Modified variable declaration so external variables can have an initial value -->
<!-- * Added support for new try-catch expression -->
<!-- * Added support for new decimal formatting declaration -->
<!-- * Added support for encoding in the version declaration -->
<!-- * Added support for new context item declaration -->
<!-- * Added support for computed namespace constructor -->
<!-- * -->
<!-- * -->
<!-- ================================================================================ -->
<!-- Errata applied: -->
<!-- XQX.E1 - Editorial (Bugzilla Bug 4924) -->
<!-- ================================================================================ -->
<!-- Modifications: -->
<!-- 2008-07-30 - Add XQuery 1.1 grouping and windowing support -->
<!-- 2008-09-18 - Add XQuery 1.1 count and outer-for support, simplified FLWOR -->
<!-- 2008-09-27 - Add validation type, nondeterministic function declarations, -->
<!-- initial values for external variables, try-catch expression -->
<!-- ================================================================================ -->
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns="http://www.w3.org/2005/XQueryX"
targetNamespace="http://www.w3.org/2005/XQueryX"
elementFormDefault="qualified" attributeFormDefault="qualified">
<!-- A few helper declarations -->
<xsd:complexType name="emptyContent"/>
<xsd:element name="NCName" type="xsd:NCName"/>
<xsd:complexType name="QName">
<xsd:simpleContent>
<xsd:extension base="xsd:NCName">
<xsd:attribute name="prefix" type="xsd:NCName" use="optional"/>
</xsd:extension>
</xsd:simpleContent>
</xsd:complexType>
<!-- The base expression class -->
<xsd:complexType name="expr"/>
<xsd:element name="expr" type="expr" abstract="true"/>
<!-- A list of expressions -->
<xsd:complexType name="exprList">
<xsd:sequence>
<xsd:element ref="expr" minOccurs="0" maxOccurs="unbounded"/>
</xsd:sequence>
</xsd:complexType>
<!-- A type to be used by elements that comprise an optional expr -->
<xsd:complexType name="exprWrapperOptional">
<xsd:sequence>
<xsd:element ref="expr" minOccurs="0"/>
</xsd:sequence>
</xsd:complexType>
<!-- Simple wrapper class -->
<xsd:complexType name="exprWrapper">
<xsd:sequence>
<xsd:element ref="expr"/>
</xsd:sequence>
</xsd:complexType>
<!-- constant expressions. We have 4 different subclasses for this -->
<xsd:complexType name="constantExpr">
<xsd:complexContent>
<xsd:extension base="expr">
<xsd:sequence>
<xsd:element name="value" type="xsd:anyType"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="constantExpr" type="constantExpr" abstract="true"
substitutionGroup="expr"/>
<xsd:complexType name="integerConstantExpr">
<xsd:complexContent>
<xsd:restriction base="constantExpr">
<xsd:sequence>
<xsd:element name="value" type="xsd:integer"/>
</xsd:sequence>
</xsd:restriction>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="integerConstantExpr" type="integerConstantExpr"
substitutionGroup="constantExpr"/>
<xsd:complexType name="decimalConstantExpr">
<xsd:complexContent>
<xsd:restriction base="constantExpr">
<xsd:sequence>
<xsd:element name="value" type="xsd:decimal"/>
</xsd:sequence>
</xsd:restriction>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="decimalConstantExpr" type="decimalConstantExpr"
substitutionGroup="constantExpr"/>
<xsd:complexType name="doubleConstantExpr">
<xsd:complexContent>
<xsd:restriction base="constantExpr">
<xsd:sequence>
<xsd:element name="value" type="xsd:double"/>
</xsd:sequence>
</xsd:restriction>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="doubleConstantExpr" type="doubleConstantExpr"
substitutionGroup="constantExpr"/>
<xsd:complexType name="stringConstantExpr">
<xsd:complexContent>
<xsd:restriction base="constantExpr">
<xsd:sequence>
<xsd:element name="value" type="xsd:string"/>
</xsd:sequence>
</xsd:restriction>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="stringConstantExpr" type="stringConstantExpr"
substitutionGroup="constantExpr"/>
<!-- Variables -->
<xsd:complexType name="varRef">
<xsd:complexContent>
<xsd:extension base="expr">
<xsd:sequence>
<xsd:element name="name" type="QName"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="varRef" type="varRef" substitutionGroup="expr"/>
<!-- root and context-item expressions -->
<!-- rootExpr deleted per Bugzilla Bug #2523 -->
<xsd:complexType name="contextItemExpr">
<xsd:complexContent>
<xsd:extension base="expr"/>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="contextItemExpr" type="contextItemExpr"
substitutionGroup="expr"/>
<!-- Pragmas and extension expressions -->
<xsd:complexType name="pragma">
<xsd:sequence>
<xsd:element name="pragmaName" type="QName"/>
<xsd:element name="pragmaContents" type="xsd:string"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="pragma" type="pragma"/>
<xsd:complexType name="extensionExpr">
<xsd:complexContent>
<xsd:extension base="expr">
<xsd:sequence>
<xsd:element ref="pragma" maxOccurs="unbounded"/>
<xsd:element name="argExpr" type="exprWrapper" minOccurs="0"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="extensionExpr" type="extensionExpr"
substitutionGroup="expr"/>
<!-- Function call expressions -->
<xsd:complexType name="functionCallExpr">
<xsd:complexContent>
<xsd:extension base="expr">
<xsd:sequence>
<xsd:element name="functionName" type="QName"/>
<xsd:element name="arguments" type="exprList" minOccurs="0"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="functionCallExpr" type="functionCallExpr"
substitutionGroup="expr"/>
<!-- Constructor functions -->
<xsd:complexType name="constructorFunctionExpr">
<xsd:complexContent>
<xsd:extension base="expr">
<xsd:sequence>
<xsd:element name="typeName" type="QName"/>
<xsd:element name="argExpr" type="exprWrapper"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="constructorFunctionExpr" type="constructorFunctionExpr"
substitutionGroup="expr"/>
<!-- Sequence expressions -->
<xsd:complexType name="sequenceExpr">
<xsd:complexContent>
<xsd:extension base="expr">
<xsd:sequence>
<xsd:element ref="expr" minOccurs="0" maxOccurs="unbounded"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="sequenceExpr" type="sequenceExpr" substitutionGroup="expr"/>
<xsd:complexType name="rangeSequenceExpr">
<xsd:complexContent>
<xsd:extension base="expr">
<xsd:sequence>
<xsd:element name="startExpr" type="exprWrapper"/>
<xsd:element name="endExpr" type="exprWrapper"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="rangeSequenceExpr" type="rangeSequenceExpr"
substitutionGroup="expr"/>
<!-- Builtin operator expressions -->
<xsd:complexType name="operatorExpr">
<xsd:complexContent>
<xsd:extension base="expr"/>
</xsd:complexContent>
</xsd:complexType>
<xsd:complexType name="unaryOperatorExpr">
<xsd:complexContent>
<xsd:extension base="operatorExpr">
<xsd:sequence>
<xsd:element name="operand" type="exprWrapper"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:complexType name="binaryOperatorExpr">
<xsd:complexContent>
<xsd:extension base="operatorExpr">
<xsd:sequence>
<xsd:element name="firstOperand" type="exprWrapper"/>
<xsd:element name="secondOperand" type="exprWrapper"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="operatorExpr" type="operatorExpr"
abstract="true" substitutionGroup="expr"/>
<xsd:element name="arithmeticOp" type="operatorExpr"
abstract="true" substitutionGroup="operatorExpr"/>
<xsd:element name="addOp" type="binaryOperatorExpr"
substitutionGroup="arithmeticOp"/>
<xsd:element name="subtractOp" type="binaryOperatorExpr"
substitutionGroup="arithmeticOp"/>
<xsd:element name="multiplyOp" type="binaryOperatorExpr"
substitutionGroup="arithmeticOp"/>
<xsd:element name="divOp" type="binaryOperatorExpr"
substitutionGroup="arithmeticOp"/>
<xsd:element name="idivOp" type="binaryOperatorExpr"
substitutionGroup="arithmeticOp"/>
<xsd:element name="modOp" type="binaryOperatorExpr"
substitutionGroup="arithmeticOp"/>
<xsd:element name="unaryMinusOp" type="unaryOperatorExpr"
substitutionGroup="arithmeticOp"/>
<xsd:element name="unaryPlusOp" type="unaryOperatorExpr"
substitutionGroup="arithmeticOp"/>
<xsd:element name="comparisonOp" type="binaryOperatorExpr" abstract="true"
substitutionGroup="operatorExpr"/>
<xsd:element name="valueComparisonOp" type="binaryOperatorExpr" abstract="true"
substitutionGroup="operatorExpr"/>
<xsd:element name="eqOp" type="binaryOperatorExpr"
substitutionGroup="valueComparisonOp"/>
<xsd:element name="neOp" type="binaryOperatorExpr"
substitutionGroup="valueComparisonOp"/>
<xsd:element name="gtOp" type="binaryOperatorExpr"
substitutionGroup="valueComparisonOp"/>
<xsd:element name="geOp" type="binaryOperatorExpr"
substitutionGroup="valueComparisonOp"/>
<xsd:element name="ltOp" type="binaryOperatorExpr"
substitutionGroup="valueComparisonOp"/>
<xsd:element name="leOp" type="binaryOperatorExpr"
substitutionGroup="valueComparisonOp"/>
<xsd:element name="generalComparisonOp" type="binaryOperatorExpr" abstract="true"
substitutionGroup="operatorExpr"/>
<xsd:element name="equalOp" type="binaryOperatorExpr"
substitutionGroup="generalComparisonOp"/>
<xsd:element name="notEqualOp" type="binaryOperatorExpr"
substitutionGroup="generalComparisonOp"/>
<xsd:element name="lessThanOp" type="binaryOperatorExpr"
substitutionGroup="generalComparisonOp"/>
<xsd:element name="lessThanOrEqualOp" type="binaryOperatorExpr"
substitutionGroup="generalComparisonOp"/>
<xsd:element name="greaterThanOp" type="binaryOperatorExpr"
substitutionGroup="generalComparisonOp"/>
<xsd:element name="greaterThanOrEqualOp" type="binaryOperatorExpr"
substitutionGroup="generalComparisonOp"/>
<xsd:element name="nodeComparisonOp" type="binaryOperatorExpr" abstract="true"
substitutionGroup="operatorExpr"/>
<xsd:element name="isOp" type="binaryOperatorExpr"
substitutionGroup="nodeComparisonOp"/>
<xsd:element name="orderComparisonOp" type="binaryOperatorExpr" abstract="true"
substitutionGroup="operatorExpr"/>
<xsd:element name="nodeBeforeOp" type="binaryOperatorExpr"
substitutionGroup="orderComparisonOp"/>
<xsd:element name="nodeAfterOp" type="binaryOperatorExpr"
substitutionGroup="orderComparisonOp"/>
<xsd:element name="logicalOp" type="binaryOperatorExpr" abstract="true"
substitutionGroup="operatorExpr"/>
<xsd:element name="andOp" type="binaryOperatorExpr"
substitutionGroup="logicalOp"/>
<xsd:element name="orOp" type="binaryOperatorExpr"
substitutionGroup="logicalOp"/>
<xsd:element name="setOp" type="binaryOperatorExpr"
abstract="true" substitutionGroup="operatorExpr"/>
<xsd:element name="unionOp" type="binaryOperatorExpr"
substitutionGroup="setOp"/>
<xsd:element name="intersectOp" type="binaryOperatorExpr"
substitutionGroup="setOp"/>
<xsd:element name="exceptOp" type="binaryOperatorExpr"
substitutionGroup="setOp"/>
<!-- Basic typenames -->
<xsd:element name="atomicType" type="QName" substitutionGroup="itemType"/>
<!-- Used in castable expression and cast expression -->
<xsd:complexType name="singleType">
<xsd:sequence>
<xsd:element ref="atomicType"/>
<xsd:element name="optional" type="emptyContent" minOccurs="0"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="singleType" type="singleType"/>
<!-- Item type schema types and elements -->
<xsd:element name="itemType" abstract="true"/>
<xsd:complexType name="emptyItemTypeContent"/>
<xsd:element name="anyItemType" type="emptyItemTypeContent"
substitutionGroup="itemType"/>
<xsd:simpleType name="occurrenceIndicator">
<xsd:restriction base="xsd:string">
<xsd:enumeration value="?"/>
<xsd:enumeration value="*"/>
<xsd:enumeration value="+"/>
</xsd:restriction>
</xsd:simpleType>
<!-- Sequence type -->
<xsd:complexType name="sequenceType">
<xsd:choice>
<xsd:element name="voidSequenceType" type="emptyContent"/>
<xsd:sequence>
<xsd:element ref="itemType"/>
<xsd:element name="occurrenceIndicator" type="occurrenceIndicator"
minOccurs="0"/>
</xsd:sequence>
</xsd:choice>
</xsd:complexType>
<xsd:element name="sequenceType" type="sequenceType"/>
<xsd:element name="typeDeclaration" type="sequenceType"/>
<!-- Represents a "typed" variable (for clause, let clause etc) -->
<xsd:complexType name="typedVariableBinding">
<xsd:sequence>
<xsd:element name="varName" type="QName"/>
<xsd:element ref="typeDeclaration" minOccurs="0"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="typedVariableBinding" type="typedVariableBinding"/>
<!-- Represents an untyped variable for the "at" clause in a for clause -->
<xsd:element name="positionalVariableBinding" type="QName"/>
<xsd:element name="variableBinding" type="QName"/>
<!-- Represents all variable bindings in a for or let clause except typed and -->
<!-- positional variable bindings -->
<xsd:element name="forLetClauseItemExtensions" abstract="true"/>
<!-- Major syntax productions: FLWOR clause components -->
<!-- for clause -->
<xsd:complexType name="forClauseItem">
<xsd:sequence>
<xsd:element ref="typedVariableBinding"/>
<xsd:element ref="positionalVariableBinding" minOccurs="0" maxOccurs="1"/>
<xsd:element ref="forLetClauseItemExtensions" minOccurs="0"
maxOccurs="unbounded"/>
<xsd:element name="forExpr" type="exprWrapper"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="forClauseItem" type="forClauseItem"/>
<xsd:complexType name="forClause">
<xsd:sequence>
<xsd:element ref="forClauseItem" minOccurs="1" maxOccurs="unbounded"/>
</xsd:sequence>
<xsd:attribute name="outer" type="xsd:boolean" default="false"/>
</xsd:complexType>
<xsd:element name="forClause" type="forClause"/>
<!-- let clause -->
<xsd:complexType name="letClauseItem">
<xsd:sequence>
<xsd:choice>
<xsd:sequence>
<xsd:element ref="typedVariableBinding"/>
<xsd:element ref="forLetClauseItemExtensions"
minOccurs="0" maxOccurs="unbounded"/>
</xsd:sequence>
<xsd:element ref="forLetClauseItemExtensions"
minOccurs="0" maxOccurs="unbounded"/>
</xsd:choice>
<xsd:element name="letExpr" type="exprWrapper"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="letClauseItem" type="letClauseItem"/>
<xsd:complexType name="letClause">
<xsd:sequence>
<xsd:element ref="letClauseItem" maxOccurs="unbounded"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="letClause" type="letClause"/>
<!-- This is the windowClause (part of FLWOR expression) -->
<!-- It corresponds to the following XQuery grammar -->
<!-- WindowClause ::= "for" (TumblingWindowClause | SlidingWindowClause) -->
<xsd:complexType name="windowClause">
<xsd:choice>
<xsd:element ref="tumblingWindowClause"/>
<xsd:element ref="slidingWindowClause"/>
</xsd:choice>
</xsd:complexType>
<xsd:element name="windowClause" type="windowClause"/>
<!-- This is the tumblingWindowClause -->
<!-- It corresponds to the following XQuery grammar -->
<!-- TumblingWindowClause ::= "tumbling" "window" "$" VarName TypeDeclaration? -->
<!-- "in" ExprSingle WindowStartCondition WindowEndCondition? -->
<xsd:complexType name="tumblingWindowClause">
<xsd:sequence>
<xsd:element ref="typedVariableBinding"/>
<xsd:element name="bindingSequence" type="exprWrapper"/>
<xsd:element name="windowStartCondition" type="windowStartCondition"/>
<xsd:element name="windowEndCondition" type="windowEndCondition" minOccurs="0"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="tumblingWindowClause" type="tumblingWindowClause"/>
<!-- This is the slidingWindowClause -->
<!-- It corresponds to the following XQuery grammar -->
<!-- SlidingWindowClause ::= "sliding" "window" "$" VarName TypeDeclaration? -->
<!-- "in" ExprSingle WindowStartCondition WindowEndCondition -->
<xsd:complexType name="slidingWindowClause">
<xsd:sequence>
<xsd:element ref="typedVariableBinding"/>
<xsd:element name="bindingSequence" type="exprWrapper"/>
<xsd:element ref="windowStartCondition"/>
<xsd:element ref="windowEndCondition"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="slidingWindowClause" type="slidingWindowClause"/>
<!-- windowStartCondition -->
<!-- Corresponds to the following XQuery grammar -->
<!-- WindowStartCondition ::= "start" WindowVars "when" ExprSingle -->
<xsd:complexType name="windowStartCondition">
<xsd:sequence>
<xsd:element ref="windowVars" minOccurs="0"/>
<xsd:element name="winStartExpr" type="exprWrapper"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="windowStartCondition" type="windowStartCondition"/>
<!-- windowEndCondition -->
<!-- Corresponds to the following XQuery grammar -->
<!-- WindowEndCondition ::= "only"? "end" WindowVars "when" ExprSingle -->
<xsd:complexType name="windowEndCondition">
<xsd:sequence>
<xsd:element ref="windowVars" minOccurs="0"/>
<xsd:element name="winEndExpr" type="exprWrapper"/>
</xsd:sequence>
<xsd:attribute name="onlyEnd" type="xsd:boolean" default="false"/>
</xsd:complexType>
<xsd:element name="windowEndCondition" type="windowEndCondition"/>
<!-- windowVars -->
<!-- Corresponds to the following XQuery grammar -->
<!-- WindowVars ::= ("$" CurrentItem)? PositionalVar? ("previous" "$" PreviousItem)? -->
<!-- ("next" "$" NextItem)? -->
<xsd:complexType name="windowVars">
<xsd:sequence>
<xsd:element name="currentItem" type="QName" minOccurs="0"/>
<xsd:element ref="positionalVariableBinding"/>
<xsd:element name="previousItem" type="QName" minOccurs="0"/>
<xsd:element name="nextItem" type="QName" minOccurs="0"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="windowVars" type="windowVars"/>
<!-- countClause (part of FLWOR expression) -->
<xsd:complexType name="countClause">
<xsd:sequence>
<xsd:element ref="varRef"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="countClause" type="countClause"/>
<!-- whereClause (part of FLWOR expression) -->
<xsd:element name="whereClause" type="exprWrapper"/>
<!-- groupByClause (part of FLWOR expression) -->
<!-- Corresponds to the following XQuery syntax -->
<!-- GroupByClause ::= "group" "by" GroupingSpecList -->
<!-- GroupingSpecList ::= GroupingSpec ("," GroupingSpec)* -->
<xsd:complexType name="groupByClause">
<xsd:sequence maxOccurs="unbounded">
<xsd:element ref="groupingSpec"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="groupByClause" type="groupByClause"/>
<!-- Corresponds to the following XQuery syntax -->
<!-- GroupingSpec ::= "$" VarName ("collation" URILiteral)? -->
<xsd:complexType name="groupingSpec">
<xsd:sequence>
<xsd:element name="varName" type="QName"/>
<xsd:element name="collation" type="xsd:string" minOccurs="0"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="groupingSpec" type="groupingSpec"/>
<!-- order by clause -->
<xsd:simpleType name="emptyOrderingMode">
<xsd:restriction base="xsd:string">
<xsd:enumeration value="empty greatest"/>
<xsd:enumeration value="empty least"/>
</xsd:restriction>
</xsd:simpleType>
<xsd:simpleType name="orderingKind">
<xsd:restriction base="xsd:string">
<xsd:enumeration value="ascending"/>
<xsd:enumeration value="descending"/>
</xsd:restriction>
</xsd:simpleType>
<xsd:complexType name="orderModifier">
<xsd:sequence>
<xsd:element name="orderingKind" type="orderingKind" minOccurs="0"/>
<xsd:element name="emptyOrderingMode" type="emptyOrderingMode" minOccurs="0"/>
<xsd:element name="collation" type="xsd:string" minOccurs="0"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="orderModifier" type="orderModifier"/>
<xsd:complexType name="orderBySpec">
<xsd:sequence>
<xsd:element name="orderByExpr" type="exprWrapper"/>
<xsd:element ref="orderModifier" minOccurs="0"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="orderBySpec" type="orderBySpec"/>
<xsd:complexType name="orderByClause">
<xsd:sequence>
<xsd:element name="stable" type="emptyContent" minOccurs="0"/>
<xsd:element ref="orderBySpec" maxOccurs="unbounded"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="orderByClause" type="orderByClause"/>
<!-- return clause -->
<xsd:element name="returnClause" type="exprWrapper"/>
<!-- This is the XQuery 1.1 flwor expression -->
<!-- Corresponds to the following XQuery syntax: -->
<!-- 1.1 FLWORExpr ::= (ForClause | LetClause | WindowClause) -->
<!-- (ForClause | LetClause | WindowClause | CountClause | -->
<!-- WhereClause | GroupByClause | OrderByClause)* -->
<!-- ReturnClause -->
<xsd:complexType name="flworExpr">
<xsd:complexContent>
<xsd:extension base="expr">
<xsd:sequence>
<xsd:choice>
<xsd:element ref="forClause"/>
<xsd:element ref="letClause"/>
<xsd:element ref="windowClause"/>
</xsd:choice>
<xsd:sequence>
<xsd:choice minOccurs="0" maxOccurs="unbounded">
<xsd:element ref="forClause"/>
<xsd:element ref="letClause"/>
<xsd:element ref="windowClause"/>
<xsd:element ref="countClause"/>
<xsd:element ref="whereClause"/>
<xsd:element ref="groupByClause"/>
<xsd:element ref="orderByClause"/>
</xsd:choice>
<xsd:element ref="returnClause"/>
</xsd:sequence>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="flworExpr" type="flworExpr" substitutionGroup="expr"/>
<!-- conditional expressions -->
<xsd:complexType name="ifThenElseExpr">
<xsd:complexContent>
<xsd:extension base="expr">
<xsd:sequence>
<xsd:element name="ifClause" type="exprWrapper"/>
<xsd:element name="thenClause" type="exprWrapper"/>
<xsd:element name="elseClause" type="exprWrapper"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="ifThenElseExpr" type="ifThenElseExpr"
substitutionGroup="expr"/>
<!-- The following clauses describe quantified expressions -->
<xsd:simpleType name="quantifier">
<xsd:restriction base="xsd:NMTOKEN">
<xsd:enumeration value="some"/>
<xsd:enumeration value="every"/>
</xsd:restriction>
</xsd:simpleType>
<xsd:complexType name="quantifiedExprInClause">
<xsd:sequence>
<xsd:element ref="typedVariableBinding"/>
<xsd:element name="sourceExpr" type="exprWrapper"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="quantifiedExprInClause" type="quantifiedExprInClause"/>
<xsd:complexType name="quantifiedExpr">
<xsd:complexContent>
<xsd:extension base="expr">
<xsd:sequence>
<xsd:element name="quantifier" type="quantifier"/>
<xsd:element ref="quantifiedExprInClause" maxOccurs="unbounded"/>
<xsd:element name="predicateExpr" type="exprWrapper"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="quantifiedExpr" type="quantifiedExpr"
substitutionGroup="expr"/>
<!-- handle the typeswitch construct -->
<!-- Note: no substitutionGroup as we cannot use this anywhere -->
<xsd:complexType name="typeswitchExprCaseClause">
<xsd:complexContent>
<xsd:extension base="expr">
<xsd:sequence>
<xsd:element ref="variableBinding" minOccurs="0"/>
<xsd:element ref="sequenceType"/>
<xsd:element name="resultExpr" type="exprWrapper"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="typeswitchExprCaseClause"
type="typeswitchExprCaseClause"/>
<!-- Note: no substitutionGroup as we cannot use this anywhere -->
<xsd:complexType name="typeswitchExprDefaultClause">
<xsd:complexContent>
<xsd:extension base="expr">
<xsd:sequence>
<xsd:element ref="variableBinding" minOccurs="0"/>
<xsd:element name="resultExpr" type="exprWrapper"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="typeswitchExprDefaultClause"
type="typeswitchExprDefaultClause"/>
<xsd:complexType name="typeswitchExpr">
<xsd:complexContent>
<xsd:extension base="expr">
<xsd:sequence>
<xsd:element name="argExpr" type="exprWrapper"/>
<xsd:element ref="typeswitchExprCaseClause" maxOccurs="unbounded"/>
<xsd:element ref="typeswitchExprDefaultClause"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="typeswitchExpr" type="typeswitchExpr"
substitutionGroup="expr"/>
<!-- TryCatchExpression -->
<!-- Corresponds to the following XQuery syntax -->
<!-- TryCatchExpression ::= TryClause CatchClause+ -->
<!-- TryClause ::= "{" TryTargetExpr "}" -->
<!-- TryTargetExpr ::= Expr -->
<xsd:complexType name="tryCatchExpr">
<xsd:complexContent>
<xsd:extension base="expr">
<xsd:sequence>
<xsd:element name="tryClause" type="exprWrapper"/>
<xsd:element ref="catchClause" maxOccurs="unbounded"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="tryCatchExpr" type="tryCatchExpr"
substitutionGroup="expr"/>
<!-- CatchClause (part of the TryCatchExpression) -->
<!-- Corresponds to the following XQuery syntax -->
<!-- CatchClause ::= "catch" CatchErrorList CatchVars* "{" Expr "}" -->
<xsd:complexType name="catchClause">
<xsd:sequence>
<xsd:element ref="catchErrorList"/>
<xsd:element ref="catchVars" minOccurs="0"/>
<xsd:element name="catchExpr" type="exprWrapper"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="catchClause" type="catchClause"/>
<!-- CatchErrorList (part of the TryCatchExpression) -->
<!-- Corresponds to the following XQuery syntax -->
<!-- CatchErrorList ::= NameTest ( "|" NameTest )* -->
<xsd:complexType name="catchErrorList">
<xsd:sequence>
<xsd:element ref="nameTest" maxOccurs="unbounded"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="catchErrorList" type="catchErrorList"/>
<!-- CatchVars (part of the TryCatchExpression) -->
<!-- Corresponds to the following XQuery syntax -->
<!-- CatchVars ::= "(" CatchErrorCode ( "," CatchErrorDesc ( "," CatchErrorVal )? )? ")"-->
<!-- CatchErrorCode ::= "$" VarName -->
<!-- CatchErrorDesc ::= "$" VarName -->
<!-- CatchErrorVal ::= "$" VarName -->
<xsd:complexType name="catchVars">
<xsd:sequence>
<xsd:element name="catchErrorCode">
<xsd:complexType>
<xsd:sequence>
<xsd:element ref="varRef"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<xsd:sequence minOccurs="0">
<xsd:element name="catchErrorDesc">
<xsd:complexType>
<xsd:sequence>
<xsd:element ref="varRef"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<xsd:sequence minOccurs="0">
<xsd:element name="catchErrorVal">
<xsd:complexType>
<xsd:sequence>
<xsd:element ref="varRef"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
</xsd:sequence>
</xsd:sequence>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="catchVars" type="catchVars"/>
<!-- instance-of expressions -->
<xsd:complexType name="instanceOfExpr">
<xsd:complexContent>
<xsd:extension base="expr">
<xsd:sequence>
<xsd:element name="argExpr" type="exprWrapper"/>
<xsd:element ref="sequenceType"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="instanceOfExpr" type="instanceOfExpr"
substitutionGroup="expr"/>
<!-- treat-as expressions -->
<xsd:complexType name="treatExpr">
<xsd:complexContent>
<xsd:extension base="expr">
<xsd:sequence>
<xsd:element name="argExpr" type="exprWrapper"/>
<xsd:element ref="sequenceType"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="treatExpr" type="treatExpr"
substitutionGroup="expr"/>
<!-- castable and cast expressions -->
<xsd:complexType name="castableExpr">
<xsd:complexContent>
<xsd:extension base="expr">
<xsd:sequence>
<xsd:element name="argExpr" type="exprWrapper"/>
<xsd:element ref="singleType"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="castableExpr" type="castableExpr"
substitutionGroup="expr"/>
<xsd:complexType name="castExpr">
<xsd:complexContent>
<xsd:extension base="expr">
<xsd:sequence>
<xsd:element name="argExpr" type="exprWrapper"/>
<xsd:element ref="singleType"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="castExpr" type="castExpr"
substitutionGroup="expr"/>
<!-- Validate expressions -->
<xsd:simpleType name="validationMode">
<xsd:restriction base="xsd:NMTOKEN">
<xsd:enumeration value="lax"/>
<xsd:enumeration value="strict"/>
</xsd:restriction>
</xsd:simpleType>
<xsd:complexType name="validateExpr">
<xsd:complexContent>
<xsd:extension base="expr">
<xsd:sequence>
<xsd:choice>
<xsd:element name="validationMode" type="validationMode" minOccurs="0"/>
<xsd:element ref="sequenceType" minOccurs="0"/>
</xsd:choice>
<xsd:element name="argExpr" type="exprWrapper"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="validateExpr" type="validateExpr"
substitutionGroup="expr"/>
<!-- Direct constructors. Only elementConstructor for now -->
<!-- Note the absence of constructors corresponding to -->
<!-- the directCommentConstructor and the directPIConstructor -->
<!-- productions in the XQuery grammar. This is because they are -->
<!-- trivially identical to the computed variants -->
<!-- attributeConstructor is no longer a subclass of expr -->
<xsd:complexType name="attributeConstructor">
<xsd:sequence>
<xsd:element name="attributeName" type="QName"/>
<xsd:choice>
<xsd:element name="attributeValueExpr" type="exprList"/>
<xsd:element name="attributeValue" type="xsd:string"/>
</xsd:choice>
</xsd:sequence>
</xsd:complexType>
<xsd:complexType name="namespaceDeclaration">
<xsd:sequence>
<xsd:element name="prefix" type="xsd:NCName" minOccurs="0"/>
<xsd:element name="uri" type="xsd:string"/>
</xsd:sequence>
</xsd:complexType>
<!-- element constructors -->
<xsd:complexType name="attributeList">
<xsd:sequence>
<xsd:choice maxOccurs="unbounded">
<xsd:element name="attributeConstructor" type="attributeConstructor"/>
<xsd:element name="namespaceDeclaration" type="namespaceDeclaration"/>
</xsd:choice>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="attributeList" type="attributeList"/>
<xsd:element name="elementContent" type="exprList"/>
<xsd:complexType name="elementConstructor">
<xsd:complexContent>
<xsd:extension base="expr">
<xsd:sequence>
<xsd:element name="tagName" type="QName"/>
<xsd:element ref="attributeList" minOccurs="0"/>
<xsd:element ref="elementContent" minOccurs="0"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="elementConstructor" type="elementConstructor"
substitutionGroup="expr"/>
<!-- computed constructors -->
<!-- computed element constructor -->
<xsd:complexType name="computedElementConstructor">
<xsd:complexContent>
<xsd:extension base="expr">
<xsd:sequence>
<xsd:choice>
<xsd:element name="tagName" type="QName"/>
<xsd:element name="tagNameExpr" type="exprWrapper"/>
</xsd:choice>
<xsd:element name="contentExpr" type="exprWrapper" minOccurs="0"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="computedElementConstructor" type="computedElementConstructor"
substitutionGroup="expr"/>
<!-- computed attribute constructor -->
<xsd:complexType name="computedAttributeConstructor">
<xsd:complexContent>
<xsd:extension base="expr">
<xsd:sequence>
<xsd:choice>
<xsd:element name="tagName" type="QName"/>
<xsd:element name="tagNameExpr" type="exprWrapper"/>
</xsd:choice>
<xsd:element name="valueExpr" type="exprWrapper" minOccurs="0"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="computedAttributeConstructor" type="computedAttributeConstructor"
substitutionGroup="expr"/>
<!-- computed document constructor -->
<xsd:complexType name="computedDocumentConstructor">
<xsd:complexContent>
<xsd:extension base="expr">
<xsd:sequence>
<xsd:element name="argExpr" type="exprWrapper"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="computedDocumentConstructor" type="computedDocumentConstructor"
substitutionGroup="expr"/>
<!-- computed text constructor -->
<xsd:complexType name="computedTextConstructor">
<xsd:complexContent>
<xsd:extension base="expr">
<xsd:sequence>
<xsd:element name="argExpr" type="exprWrapper" minOccurs="0"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="computedTextConstructor" type="computedTextConstructor"
substitutionGroup="expr"/>
<!-- computed comment constructor -->
<xsd:complexType name="computedCommentConstructor">
<xsd:complexContent>
<xsd:extension base="expr">
<xsd:sequence>
<xsd:element name="argExpr" type="exprWrapper"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="computedCommentConstructor" type="computedCommentConstructor"
substitutionGroup="expr"/>
<!-- computed namespace constructor -->
<xsd:complexType name="computedNamespaceConstructor">
<xsd:complexContent>
<xsd:extension base="expr">
<xsd:sequence>
<xsd:choice>
<xsd:element name="prefix" type="xsd:NCName"/>
<xsd:element name="prefixExpr" type="exprWrapper"/>
</xsd:choice>
<xsd:element name="URIExpr" type="exprWrapper" minOccurs="0"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="computedNamespaceConstructor" type="computedNamespaceConstructor"
substitutionGroup="expr"/>
<!-- computed processing instruction constructor -->
<xsd:complexType name="computedPIConstructor">
<xsd:complexContent>
<xsd:extension base="expr">
<xsd:sequence>
<xsd:choice>
<xsd:element name="piTarget" type="xsd:NCName"/>
<xsd:element name="piTargetExpr" type="exprWrapper"/>
</xsd:choice>
<xsd:element name="piValueExpr" type="exprWrapper" minOccurs="0"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="computedPIConstructor" type="computedPIConstructor"
substitutionGroup="expr"/>
<!-- ordered and unordered expressions -->
<xsd:complexType name="unorderedExpr">
<xsd:complexContent>
<xsd:extension base="expr">
<xsd:sequence>
<xsd:element name="argExpr" type="exprWrapper"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="unorderedExpr" type="unorderedExpr" substitutionGroup="expr"/>
<xsd:complexType name="orderedExpr">
<xsd:complexContent>
<xsd:extension base="expr">
<xsd:sequence>
<xsd:element name="argExpr" type="exprWrapper"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="orderedExpr" type="orderedExpr" substitutionGroup="expr"/>
<!-- wildcards -->
<xsd:complexType name="simpleWildcard">
<xsd:choice>
<xsd:element name="QName" type="QName"/>
<xsd:element name="star" type="emptyContent"/>
</xsd:choice>
</xsd:complexType>
<xsd:complexType name="Wildcard">
<xsd:all>
<xsd:element name="star" type="emptyContent" minOccurs="0"/>
<xsd:element ref="NCName" minOccurs="0"/>
</xsd:all>
</xsd:complexType>
<xsd:element name="Wildcard" type="Wildcard"/>
<!-- tests (name and/or type) -->
<xsd:element name="schemaAttributeTest" type="QName"
substitutionGroup="kindTest"/>
<xsd:complexType name="attributeTest">
<xsd:complexContent>
<xsd:extension base="emptyItemTypeContent">
<xsd:sequence minOccurs="0">
<xsd:element name="attributeName" type="simpleWildcard"/>
<xsd:element name="typeName" type="QName" minOccurs="0"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="attributeTest" type="attributeTest"
substitutionGroup="kindTest"/>
<xsd:element name="anyElementTest" abstract="true"
substitutionGroup="kindTest"/>
<xsd:element name="schemaElementTest" type="QName"
substitutionGroup="anyElementTest"/>
<xsd:complexType name="elementTest">
<xsd:complexContent>
<xsd:extension base="emptyItemTypeContent">
<xsd:sequence minOccurs="0">
<xsd:element name="elementName" type="simpleWildcard"/>
<xsd:sequence minOccurs="0">
<xsd:element name="typeName" type="QName"/>
<xsd:element name="nillable" type="emptyContent" minOccurs="0"/>
</xsd:sequence>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="elementTest" type="elementTest"
substitutionGroup="anyElementTest"/>
<xsd:complexType name="documentTest">
<xsd:complexContent>
<xsd:extension base="emptyItemTypeContent">
<xsd:sequence>
<xsd:element ref="anyElementTest" minOccurs="0"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="documentTest" type="documentTest"
substitutionGroup="kindTest"/>
<xsd:complexType name="piTest">
<xsd:complexContent>
<xsd:extension base="emptyItemTypeContent">
<xsd:sequence>
<xsd:element name="piTarget" type="xsd:NCName" minOccurs="0"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="piTest" type="piTest" substitutionGroup="kindTest"/>
<xsd:element name="nameTest" type="QName"/>
<xsd:element name="kindTest" substitutionGroup="itemType"/>
<xsd:element name="textTest" type="emptyItemTypeContent"
substitutionGroup="kindTest"/>
<xsd:element name="commentTest" type="emptyItemTypeContent"
substitutionGroup="kindTest"/>
<xsd:element name="namespaceTest" type="emptyItemTypeContent"
substitutionGroup="kindTest"/>
<xsd:element name="anyKindTest" type="emptyItemTypeContent"
substitutionGroup="kindTest"/>
<!-- XPath axes -->
<xsd:simpleType name="xpathAxis">
<xsd:restriction base="xsd:NMTOKEN">
<xsd:enumeration value="child"/>
<xsd:enumeration value="attribute"/>
<xsd:enumeration value="self"/>
<xsd:enumeration value="parent"/>
<xsd:enumeration value="descendant-or-self"/>
<xsd:enumeration value="descendant"/>
<xsd:enumeration value="following"/>
<xsd:enumeration value="following-sibling"/>
<xsd:enumeration value="ancestor"/>
<xsd:enumeration value="ancestor-or-self"/>
<xsd:enumeration value="preceding"/>
<xsd:enumeration value="preceding-sibling"/>
</xsd:restriction>
</xsd:simpleType>
<xsd:element name="xpathAxis" type="xpathAxis"/>
<!-- filter expressions -->
<xsd:group name="filterExpr">
<xsd:choice>
<xsd:element ref="constantExpr"/>
<xsd:element ref="varRef"/>
<xsd:element ref="contextItemExpr"/>
<xsd:element ref="functionCallExpr"/>
<xsd:element ref="sequenceExpr"/>
<xsd:element ref="elementConstructor"/>
<xsd:element ref="computedElementConstructor"/>
<xsd:element ref="computedAttributeConstructor"/>
<xsd:element ref="computedDocumentConstructor"/>
<xsd:element ref="computedTextConstructor"/>
<xsd:element ref="computedCommentConstructor"/>
<xsd:element ref="computedNamespaceConstructor"/>
<xsd:element ref="computedPIConstructor"/>
<xsd:element ref="orderedExpr"/>
<xsd:element ref="unorderedExpr"/>
</xsd:choice>
</xsd:group>
<!-- step expression -->
<!-- removed nameTest and Wildcard outer choices per Bugzilla Bug #2523 -->
<xsd:complexType name="stepExpr">
<xsd:sequence>
<xsd:choice>
<xsd:sequence>
<xsd:element ref="xpathAxis"/>
<xsd:choice>
<xsd:element ref="kindTest"/>
<xsd:element ref="nameTest"/>
<xsd:element ref="Wildcard"/>
</xsd:choice>
</xsd:sequence>
<xsd:element name="filterExpr">
<xsd:complexType>
<xsd:sequence>
<xsd:group ref="filterExpr"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
</xsd:choice>
<xsd:element name="predicates" type="exprList" minOccurs="0"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="stepExpr" type="stepExpr"/>
<!-- path expression -->
<!-- rewrote pathExpr definition per Bugzilla Bug #2523 -->
<xsd:complexType name="pathExpr">
<xsd:complexContent>
<xsd:extension base="expr">
<xsd:choice>
<xsd:sequence>
<xsd:element name="rootExpr" type="emptyContent"/>
<xsd:element ref="stepExpr" minOccurs="0" maxOccurs="unbounded"/>
</xsd:sequence>
<xsd:element ref="stepExpr" maxOccurs="unbounded"/>
</xsd:choice>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="pathExpr" type="pathExpr" substitutionGroup="expr"/>
<!-- The following constructs deal with the query prolog -->
<xsd:complexType name="module">
<xsd:sequence>
<xsd:element ref="versionDecl" minOccurs="0"/>
<xsd:choice>
<xsd:element ref="mainModule"/>
<xsd:element ref="libraryModule"/>
</xsd:choice>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="module" type="module"/>
<xsd:complexType name="mainModule">
<xsd:sequence>
<xsd:element ref="prolog" minOccurs="0"/>
<xsd:element name="queryBody" type="exprWrapper"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="mainModule" type="mainModule"/>
<xsd:complexType name="libraryModule">
<xsd:sequence>
<xsd:element ref="moduleDecl"/>
<xsd:element ref="prolog" minOccurs="0"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="libraryModule" type="libraryModule"/>
<xsd:complexType name="versionDecl">
<xsd:sequence>
<xsd:element name="version" type="xsd:string" minOccurs="0"/>
<xsd:element name="encoding" type="xsd:string" minOccurs="0"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="versionDecl" type="versionDecl"/>
<xsd:complexType name="prolog">
<xsd:sequence>
<xsd:element ref="prologPartOneItem" minOccurs="0" maxOccurs="unbounded"/>
<xsd:element ref="prologPartTwoItem" minOccurs="0" maxOccurs="unbounded"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="prolog" type="prolog"/>
<xsd:element name="prologPartOneItem" abstract="true"/>
<xsd:element name="prologPartTwoItem" abstract="true"/>
<xsd:simpleType name="boundarySpaceDecl">
<xsd:restriction base="xsd:NMTOKEN">
<xsd:enumeration value="strip"/>
<xsd:enumeration value="preserve"/>
</xsd:restriction>
</xsd:simpleType>
<xsd:element name="boundarySpaceDecl" type="boundarySpaceDecl"
substitutionGroup="prologPartOneItem"/>
<xsd:element name="defaultCollationDecl" type="xsd:string"
substitutionGroup="prologPartOneItem"/>
<xsd:element name="baseUriDecl" type="xsd:string"
substitutionGroup="prologPartOneItem"/>
<xsd:simpleType name="constructionDecl">
<xsd:restriction base="xsd:NMTOKEN">
<xsd:enumeration value="strip"/>
<xsd:enumeration value="preserve"/>
</xsd:restriction>
</xsd:simpleType>
<xsd:element name="constructionDecl" type="constructionDecl"
substitutionGroup="prologPartOneItem"/>
<xsd:simpleType name="orderingModeDecl">
<xsd:restriction base="xsd:NMTOKEN">
<xsd:enumeration value="ordered"/>
<xsd:enumeration value="unordered"/>
</xsd:restriction>
</xsd:simpleType>
<xsd:element name="orderingModeDecl" type="orderingModeDecl"
substitutionGroup="prologPartOneItem"/>
<xsd:element name="emptyOrderingDecl" type="emptyOrderingMode"
substitutionGroup="prologPartOneItem"/>
<xsd:complexType name="copyNamespacesDecl">
<xsd:sequence>
<xsd:element name="preserveMode">
<xsd:simpleType>
<xsd:restriction base="xsd:NMTOKEN">
<xsd:enumeration value="preserve"/>
<xsd:enumeration value="no-preserve"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:element>
<xsd:element name="inheritMode">
<xsd:simpleType>
<xsd:restriction base="xsd:NMTOKEN">
<xsd:enumeration value="inherit"/>
<xsd:enumeration value="no-inherit"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:element>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="copyNamespacesDecl" type="copyNamespacesDecl"
substitutionGroup="prologPartOneItem"/>
<xsd:simpleType name="defaultNamespaceCategory">
<xsd:restriction base="xsd:NMTOKEN">
<xsd:enumeration value="function"/>
<xsd:enumeration value="element"/>
</xsd:restriction>
</xsd:simpleType>
<xsd:complexType name="defaultNamespaceDecl">
<xsd:sequence>
<xsd:element name="defaultNamespaceCategory" type="defaultNamespaceCategory"/>
<xsd:element name="uri" type="xsd:string"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="defaultNamespaceDecl" type="defaultNamespaceDecl"
substitutionGroup="prologPartOneItem"/>
<xsd:complexType name="namespaceDeclType">
<xsd:sequence>
<xsd:element name="prefix" type="xsd:NCName"/>
<xsd:element name="uri" type="xsd:string"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="namespaceDecl" type="namespaceDeclType"
substitutionGroup="prologPartOneItem"/>
<xsd:element name="moduleDecl" type="namespaceDeclType"/>
<xsd:complexType name="decimalFormatDeclType">
<xsd:sequence>
<xsd:element name="decimalFormatName" type="xsd:QName" minOccurs="0"/>
<xsd:element name="decimalFormatParam" minOccurs="0" maxOccurs="unbounded">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="decimalFormatParamName">
<xsd:simpleType>
<xsd:restriction base="xsd:NMTOKEN">
<xsd:enumeration value="decimal-separator"/>
<xsd:enumeration value="grouping-separator"/>
<xsd:enumeration value="infinity"/>
<xsd:enumeration value="minus-sign"/>
<xsd:enumeration value="NaN"/>
<xsd:enumeration value="percent"/>
<xsd:enumeration value="per-mille"/>
<xsd:enumeration value="zero-digit"/>
<xsd:enumeration value="digit"/>
<xsd:enumeration value="pattern-separator"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:element>
<xsd:element name="decimalFormatParamValue" type="xsd:string"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
</xsd:sequence>
<xsd:attribute name="default" default="false">
<xsd:simpleType>
<xsd:restriction base="xsd:NMTOKEN">
<xsd:enumeration value="true"/>
<xsd:enumeration value="false"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:attribute>
</xsd:complexType>
<xsd:element name="decimalFormatDecl" type="decimalFormatDeclType"
substitutionGroup="prologPartOneItem"/>
<xsd:complexType name="schemaImport">
<xsd:sequence>
<xsd:choice minOccurs="0">
<xsd:element name="namespacePrefix" type="xsd:NCName"/>
<xsd:element name="defaultElementNamespace" type="emptyContent"/>
</xsd:choice>
<xsd:element name="targetNamespace" type="xsd:string"/>
<xsd:element name="targetLocation" type="xsd:string"
minOccurs="0" maxOccurs="unbounded"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="schemaImport" type="schemaImport"
substitutionGroup="prologPartOneItem"/>
<xsd:complexType name="moduleImport">
<xsd:sequence>
<xsd:element name="namespacePrefix" type="xsd:NCName" minOccurs="0"/>
<xsd:element name="targetNamespace" type="xsd:string"/>
<xsd:element name="targetLocation" type="xsd:string"
minOccurs="0" maxOccurs="unbounded"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="moduleImport" type="moduleImport"
substitutionGroup="prologPartOneItem"/>
<xsd:complexType name="contextItemDecl">
<xsd:sequence>
<xsd:element ref="typeDeclaration" minOccurs="0"/>
<xsd:choice>
<xsd:element name="varValue" type="exprWrapper"/>
<xsd:sequence>
<xsd:element name="external">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="varValue" type="exprWrapper" minOccurs="0"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
</xsd:sequence>
</xsd:choice>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="contextItemDecl" type="contextItemDecl"
substitutionGroup="prologPartTwoItem"/>
<xsd:complexType name="varDecl">
<xsd:sequence>
<xsd:element name="varName" type="QName"/>
<xsd:element ref="typeDeclaration" minOccurs="0"/>
<xsd:choice>
<xsd:element name="varValue" type="exprWrapper"/>
<xsd:sequence>
<xsd:element name="external">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="varValue" type="exprWrapper" minOccurs="0"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
</xsd:sequence>
</xsd:choice>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="varDecl" type="varDecl"
substitutionGroup="prologPartTwoItem"/>
<xsd:complexType name="optionDecl">
<xsd:sequence>
<xsd:element name="optionName" type="QName"/>
<xsd:element name="optionContents" type="xsd:string"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="optionDecl" type="optionDecl"
substitutionGroup="prologPartTwoItem"/>
<xsd:complexType name="functionDecl">
<xsd:sequence>
<xsd:element name="functionName" type="QName"/>
<xsd:element ref="paramList"/>
<xsd:element ref="typeDeclaration" minOccurs="0"/>
<xsd:choice>
<xsd:element name="functionBody" type="exprWrapper"/>
<xsd:element name="externalDefinition">
<xsd:complexType>
<xsd:attribute name="nondeterministic" use="optional"
type="xsd:boolean" default="false"/>
</xsd:complexType>
</xsd:element>
</xsd:choice>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="functionDecl" type="functionDecl"
substitutionGroup="prologPartTwoItem"/>
<xsd:complexType name="param">
<xsd:sequence>
<xsd:element name="varName" type="QName"/>
<xsd:element ref="typeDeclaration" minOccurs="0"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="param" type="param"/>
<xsd:complexType name="paramList">
<xsd:sequence>
<xsd:element ref="param" minOccurs="0" maxOccurs="unbounded"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="paramList" type="paramList"/>
</xsd:schema>
5
Conformance
This section defines the conformance criteria for an XQueryX
processor (see Figure 1, "Processing Model Overview", in
[XQuery 1.1] , Section 2.2
Processing ModelXQ.
In this section, the following terms are used to indicate the
requirement levels defined in [RFC 2119].
[Definition: MUST means that the item is an absolute requirement of
the specification.] [Definition: SHOULD means that there may exist
valid reasons in particular circumstances to ignore a particular
item, but the full implications must be understood and carefully
weighed before choosing a different course.] [Definition: MAY means
that an item is truly optional.]
An XQueryX processor that claims to conform to this
specification MUST implement the XQueryX syntax as defined in
4 An XML Schema for the XQuery XML
Syntax of this specification and include a claim of Minimal
Conformance as defined in [XQuery
1.1] , Section
5.1 Minimal ConformanceXQ11. In
addition to a claim of Minimal Conformance, it MAY claim
conformance to one or more optional features defined in
[XQuery 1.1] , Section
5.2 Optional FeaturesXQ11.