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 a
Candidate Recommendation
as described in the Process Document.
This documentis intended for review by W3C members and other interested parties.
The publication of this document constitutes a
call for implementations
of this specification.
This specification will remain a Candidate Recommendation until at least 2006-02-28.
This document has been produced by the
XML Query Working Group (WG),
which is part of the XML Activity.
Publication as a Candidate Recommendation 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 draft includes corrections and changes based on
publiccommentsrecordedin the W3Cpublic Bugzilla repository
(http://www.w3.org/Bugs/Public/)
usedforLast Callissues tracking.
Alist of substantive changes since the LastCall WorkingDraft of 04 April 2005 can befound in
D Change log.
Commentson this document should be made in W3C's
publicBugzilla system(instructions can be found at
http://www.w3.org/XML/2005/04/qt-bugzilla).
Ifaccess to that systemis not feasible, you may send your comments tothe W3C
XSLT/XPath/XQuery mailinglist,
public-qt-comments@w3.org.
Itwill be very helpful if you include thestring [XQueryX] in the subjectlineof your comment,
whethermade in Bugzilla or in email.
EachBugzillaentry and email message should contain only one comment.
Archives of thecomments and responses are available at
http://lists.w3.org/Archives/Public/public-qt-comments/.
TheXML Query WG plans to submit this specification for considerationas a
W3C Proposed Recommendation
assoon asthe following conditionsare met:
Atest suite is available that testseachidentified XQuery feature,
bothrequiredand optional.
Eachidentified XQuery feature has at least two implementations.
Atleast twodistinct implementations have demonstrated Minimal
Conformanceto this specification as defined in
Section
5.1 Minimal ConformanceXQ.Oneof these implementations must
usethe XQuery human-readable syntax definedin [XQuery 1.0: An XML Query Language]and one
mustuse the XQueryX XML syntaxdefined in this specification.
TheWorking Group has responded formally to allissuesraised during
the CRperiodagainst this document.
The XML Query and XPath Test Suite
is under development.
Implementorsare encouraged to run this test suiteand reporttheir results.
The patent policy for this document is the5 February 2004 W3C Patent Policy.
Patent disclosures relevant to this specification may be found on the
XML Query Working Group's patent disclosure page.
An individual who has actual knowledge of a patent which the individual believes contains
Essential Claim(s) with respect to this specification should disclose the information in accordance with
section
6
of the W3C Patent Policy.
1 Introduction
The [XML Query 1.0 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.0: An XML Query Language].
|
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.
2 Mapping the XQuery Syntax
XQueryX is an XML representation of the abstract syntax found in
Appendix A of [XQuery 1.0: An XML Query Language]. 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 ::= (ForClause | LetClause)+ WhereClause? OrderByClause? "return" ExprSingle
ForClause ::= <"for" "$"> VarName TypeDeclaration? PositionalVar? "in"
ExprSingle ("," "$" VarName TypeDeclaration? PositionalVar?
"in" ExprSingle)*
LetClause ::= <"let" "$"> VarName TypeDeclaration? ":="
ExprSingle ("," "$" VarName TypeDeclaration? ":=" ExprSingle)*
WhereClause ::= "where" ExprSingle
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 maxOccurs="unbounded">
<xsd:element ref="forClause"/>
<xsd:element ref="letClause"/>
</xsd:choice>
<xsd:element name="whereClause" minOccurs="0"/>
<xsd:element name="orderByClause" minOccurs="0"/>
<xsd:element name="returnClause"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="flworExpr" type="flworExpr" substitutionGroup="expr"/>
<xsd:element name="forClause">
<xsd:complexType>
<xsd:sequence>
<xsd:element ref="forClauseItem" maxOccurs="unbounded"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<xsd:element name="forClauseItem">
<xsd:complexType>
<xsd:sequence>
<xsd:element ref="typedVariableBinding"/>
<xsd:element ref="positionalVariableBinding" minOccurs="0"/>
<xsd:element name="forExpr" type="exprWrapper"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<xsd:element name="letClause">
<xsd:complexType>
<xsd:sequence>
<xsd:element ref="letClauseItem" maxOccurs="unbounded"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<xsd:element name="letClauseItem">
<xsd:complexType>
<xsd:sequence>
<xsd:element ref="typedVariableBinding"/>
<xsd:element name="letExpr" type="exprWrapper"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<xsd:element name="whereClause" type="exprWrapper"/>
<xsd:element name="returnClause" 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 [XML Query 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 [XML Query 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 [XML Query 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 [XML Query 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 [XML Query 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:argExpr>
<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:argExpr>
<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:argExpr>
<xqx:varRef>
<xqx:name>b</xqx:name>
</xqx:varRef>
</xqx:argExpr>
<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:argExpr>
<xqx:varRef>
<xqx:name>b</xqx:name>
</xqx:varRef>
</xqx:argExpr>
<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:argExpr>
<xqx:varRef>
<xqx:name>b</xqx:name>
</xqx:varRef>
</xqx:argExpr>
<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:argExpr>
<xqx:varRef>
<xqx:name>b</xqx:name>
</xqx:varRef>
</xqx:argExpr>
<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 solutionresults 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/2005/qt-applets/xqueryApplet.html.
XPath2
QueryList
Module
MainModule
Prolog
QueryBody
Expr
PathExpr
Constructor
DirectConstructor
DirElemConstructor
StartTagOpenRoot <
TagQName bib
DirAttributeList
StartTagClose >
DirElemContent
ElementContentChar
DirElemContent
ElementContentChar
DirElemContent
CommonContent
EnclosedExpr
Lbrace {
Expr
FLWORExpr
VarName b
In in
PathExpr
FunctionCall
QNameLpar doc(
PathExpr
StringLiteral "http://bstore1.example.com/bib.xml"
StepExpr
NodeTest
NameTest
QName bib
StepExpr
NodeTest
NameTest
QName book
WhereClause
Where where
AndExpr and
ComparisonExpr =
PathExpr
VarName b
StepExpr
NodeTest
NameTest
QName publisher
PathExpr
StringLiteral "Addison-Wesley"
ComparisonExpr >
PathExpr
VarName b
StepExpr
At @
NodeTest
NameTest
QName year
PathExpr
IntegerLiteral 1991
PathExpr
Constructor
DirectConstructor
DirElemConstructor
StartTagOpenRoot <
TagQName book
DirAttributeList
S
TagQName year
ValueIndicator =
DirAttributeValue
OpenQuot "
QuotAttrValueContent
CommonContent
EnclosedExpr
Lbrace {
Expr
PathExpr
VarName b
StepExpr
At @
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 b
StepExpr
NodeTest
NameTest
QName title
Rbrace }
DirElemContent
ElementContentChar
DirElemContent
ElementContentChar
DirElemContent
ElementContentChar
DirElemContent
ElementContentChar
DirElemContent
ElementContentChar
EndTagOpen </
TagQName book
EndTagClose >
Rbrace }
DirElemContent
ElementContentChar
EndTagOpen </
TagQName bib
EndTagClose >
3.2 Example 2
Here is Q4 from the [XML Query 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:argExpr>
<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:argExpr>
<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:argExpr>
<xqx:varRef>
<xqx:name>a</xqx:name>
</xqx:varRef>
</xqx:argExpr>
<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:argExpr>
<xqx:varRef>
<xqx:name>a</xqx:name>
</xqx:varRef>
</xqx:argExpr>
<xqx:predicates>
<xqx:equalOp>
<xqx:firstOperand>
<xqx:pathExpr>
<xqx:argExpr>
<xqx:contextItemExpr/>
</xqx:argExpr>
<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: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:argExpr>
<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:argExpr>
<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:argExpr>
<xqx:varRef>
<xqx:name>b</xqx:name>
</xqx:varRef>
</xqx:argExpr>
<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:argExpr>
<xqx:varRef>
<xqx:name>ba</xqx:name>
</xqx:varRef>
</xqx:argExpr>
<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:argExpr>
<xqx:varRef>
<xqx:name>ba</xqx:name>
</xqx:varRef>
</xqx:argExpr>
<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:argExpr>
<xqx:varRef>
<xqx:name>b</xqx:name>
</xqx:varRef>
</xqx:argExpr>
<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 ofthe stylesheet in B Transforming XQueryX to XQuery to the XQueryX solutionresults 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 [XML Query 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:argExpr>
<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:argExpr>
<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:argExpr>
<xqx:varRef>
<xqx:name>b</xqx:name>
</xqx:varRef>
</xqx:argExpr>
<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:argExpr>
<xqx:varRef>
<xqx:name>b</xqx:name>
</xqx:varRef>
</xqx:argExpr>
<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:argExpr>
<xqx:varRef>
<xqx:name>b</xqx:name>
</xqx:varRef>
</xqx:argExpr>
<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:argExpr>
<xqx:varRef>
<xqx:name>b</xqx:name>
</xqx:varRef>
</xqx:argExpr>
<xqx:stepExpr>
<xqx:xpathAxis>attribute</xqx:xpathAxis>
<xqx:nameTest>year</xqx:nameTest>
</xqx:stepExpr>
</xqx:pathExpr>
<xqx:pathExpr>
<xqx:argExpr>
<xqx:varRef>
<xqx:name>b</xqx:name>
</xqx:varRef>
</xqx:argExpr>
<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 ofthe stylesheet in B Transforming XQueryX to XQuery to the XQueryX solution,
we get:
<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 [XML Query 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"?>
<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:argExpr>
<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:argExpr>
<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:parenthesizedExpr>
<xqx:unionOp>
<xqx:firstOperand>
<xqx:pathExpr>
<xqx:stepExpr>
<xqx:nameTest xqx:prefix="ma">Seller</xqx:nameTest>
</xqx:stepExpr>
</xqx:pathExpr>
</xqx:firstOperand>
<xqx:secondOperand>
<xqx:pathExpr>
<xqx:stepExpr>
<xqx:nameTest xqx:prefix="ma">High_Bidder</xqx:nameTest>
</xqx:stepExpr>
</xqx:pathExpr>
</xqx:secondOperand>
</xqx:unionOp>
</xqx:parenthesizedExpr>
</xqx:filterExpr>
</xqx:stepExpr>
</xqx:pathExpr>
</xqx:forExpr>
</xqx:forClauseItem>
</xqx:forClause>
<xqx:whereClause>
<xqx:equalOp>
<xqx:firstOperand>
<xqx:pathExpr>
<xqx:argExpr>
<xqx:varRef>
<xqx:name>s</xqx:name>
</xqx:varRef>
</xqx:argExpr>
<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 solutionresults 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/(ma:Seller union 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 for the proposed syntax.
<?xml version="1.0"?>
<!-- Readers of this schema are reminded that the default value for both
minOccurs and maxOccurs is 1. -->
<xsd:schema xmlns="http://www.w3.org/2005/XQueryX"
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
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 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>
<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 -->
<xsd:complexType name="rootExpr">
<xsd:complexContent>
<xsd:extension base="expr"/>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="rootExpr" type="rootExpr" substitutionGroup="expr"/>
<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:element name="pragma">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="pragmaName" type="QName"/>
<xsd:element name="pragmaContents" type="xsd:string"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<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"/>
<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"/>
<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 -->
<xsd:element name="singleType">
<xsd:complexType>
<xsd:sequence>
<xsd:element ref="atomicType"/>
<xsd:element name="optional" type="emptyContent" minOccurs="0"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<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>
<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:element name="typedVariableBinding">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="varName" type="QName"/>
<xsd:element ref="typeDeclaration" minOccurs="0"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<xsd:element name="positionalVariableBinding" type="QName"/>
<xsd:element name="variableBinding" type="QName"/>
<xsd:element name="forClauseItem">
<xsd:complexType>
<xsd:sequence>
<xsd:element ref="typedVariableBinding"/>
<xsd:element ref="positionalVariableBinding" minOccurs="0"/>
<xsd:element name="forExpr" type="exprWrapper"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<xsd:element name="forClause">
<xsd:complexType>
<xsd:sequence>
<xsd:element ref="forClauseItem" maxOccurs="unbounded"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<xsd:element name="letClauseItem">
<xsd:complexType>
<xsd:sequence>
<xsd:element ref="typedVariableBinding"/>
<xsd:element name="letExpr" type="exprWrapper"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<xsd:element name="letClause">
<xsd:complexType>
<xsd:sequence>
<xsd:element ref="letClauseItem" maxOccurs="unbounded"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<xsd:element name="whereClause" type="exprWrapper"/>
<xsd:element name="returnClause" type="exprWrapper"/>
<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:element name="orderModifier">
<xsd:complexType>
<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>
<xsd:element name="orderBySpec">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="orderByExpr" type="exprWrapper"/>
<xsd:element ref="orderModifier" minOccurs="0"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<xsd:element name="orderByClause">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="stable" type="emptyContent" minOccurs="0"/>
<xsd:element ref="orderBySpec" maxOccurs="unbounded"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<!-- This is the flwor expression -->
<xsd:complexType name="flworExpr">
<xsd:complexContent>
<xsd:extension base="expr">
<xsd:sequence>
<xsd:choice maxOccurs="unbounded">
<xsd:element ref="forClause"/>
<xsd:element ref="letClause"/>
</xsd:choice>
<xsd:element ref="whereClause" minOccurs="0"/>
<xsd:element ref="orderByClause" minOccurs="0"/>
<xsd:element ref="returnClause"/>
</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:element name="quantifiedExprInClause">
<xsd:complexType>
<xsd:sequence>
<xsd:element ref="typedVariableBinding"/>
<xsd:element name="sourceExpr" type="exprWrapper"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<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:element name="typeswitchExprCaseClause">
<xsd:complexType>
<xsd:complexContent>
<xsd:extension base="expr">
<xsd:sequence>
<xsd:element ref="variableBinding" minOccurs="0"/>
<xsd:element ref="typeDeclaration"/>
<xsd:element name="resultExpr" type="exprWrapper"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
</xsd:element>
<!-- Note: no substitutionGroup as we cannot use this anywhere -->
<xsd:element name="typeswitchExprDefaultClause">
<xsd:complexType>
<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>
<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"/>
<!-- 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:element name="validationMode" type="validationMode" minOccurs="0"/>
<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>
<xsd:element name="attributeList">
<xsd:complexType>
<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>
<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 -->
<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"/>
<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"/>
<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"/>
<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"/>
<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"/>
<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"/>
<xsd:complexType name="simpleWildcard">
<xsd:choice>
<xsd:element name="QName" type="QName"/>
<xsd:element name="star" type="emptyContent"/>
</xsd:choice>
</xsd:complexType>
<xsd:element name="Wildcard">
<xsd:complexType>
<xsd:all>
<xsd:element name="star" type="emptyContent" minOccurs="0"/>
<xsd:element ref="NCName" minOccurs="0"/>
</xsd:all>
</xsd:complexType>
</xsd:element>
<xsd:element name="schemaAttributeTest" type="QName" substitutionGroup="kindTest"/>
<xsd:element name="attributeTest" substitutionGroup="kindTest">
<xsd:complexType>
<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>
<xsd:element name="anyElementTest" abstract="true" substitutionGroup="kindTest"/>
<xsd:element name="schemaElementTest" type="QName" substitutionGroup="anyElementTest"/>
<xsd:element name="elementTest" substitutionGroup="anyElementTest">
<xsd:complexType>
<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>
<xsd:element name="documentTest" substitutionGroup="kindTest">
<xsd:complexType>
<xsd:complexContent>
<xsd:extension base="emptyItemTypeContent">
<xsd:sequence>
<xsd:element ref="anyElementTest" minOccurs="0"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
</xsd:element>
<xsd:element name="piTest" substitutionGroup="kindTest">
<xsd:complexType>
<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>
<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="anyKindTest" type="emptyItemTypeContent" substitutionGroup="kindTest"/>
<xsd:element name="xpathAxis">
<xsd:simpleType>
<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>
<xsd:element name="parenthesizedExpr" type="exprWrapperOptional"/>
<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="parenthesizedExpr"/>
<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="computedPIConstructor"/>
<xsd:element ref="orderedExpr"/>
<xsd:element ref="unorderedExpr"/>
</xsd:choice>
</xsd:group>
<xsd:element name="stepExpr">
<xsd:complexType>
<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 ref="nameTest"/>
<xsd:element ref="Wildcard"/>
<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>
<xsd:complexType name="pathExpr">
<xsd:complexContent>
<xsd:extension base="expr">
<xsd:sequence>
<xsd:sequence minOccurs="0">
<xsd:element name="argExpr" type="exprWrapper"/>
<xsd:element name="predicates" type="exprList" minOccurs="0"/>
</xsd:sequence>
<xsd:element ref="stepExpr" minOccurs="0" maxOccurs="unbounded"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="pathExpr" type="pathExpr" substitutionGroup="expr"/>
<!-- The following constructs deal with the query prolog -->
<xsd:element name="module">
<xsd:complexType>
<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>
<xsd:element name="mainModule">
<xsd:complexType>
<xsd:sequence>
<xsd:element ref="prolog" minOccurs="0"/>
<xsd:element name="queryBody" type="exprWrapper"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<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"/>
<xsd:element name="moduleDecl" type="namespaceDeclType"/>
<xsd:element name="libraryModule">
<xsd:complexType>
<xsd:sequence>
<xsd:element ref="moduleDecl"/>
<xsd:element ref="prolog" minOccurs="0"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<xsd:element name="versionDecl">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="version" type="xsd:string"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<xsd:element name="prolog">
<xsd:complexType>
<xsd:sequence>
<xsd:choice minOccurs="0" maxOccurs="unbounded">
<xsd:element ref="defaultCollationDecl"/>
<xsd:element ref="baseUriDecl"/>
<xsd:element ref="constructionDecl"/>
<xsd:element ref="orderingModeDecl"/>
<xsd:element ref="emptyOrderingDecl"/>
<xsd:element ref="copyNamespacesDecl"/>
</xsd:choice>
<xsd:choice minOccurs="0" maxOccurs="unbounded">
<xsd:element ref="defaultNamespaceDecl"/>
<xsd:element ref="namespaceDecl"/>
<xsd:element ref="schemaImport"/>
<xsd:element ref="moduleImport"/>
</xsd:choice>
<xsd:choice minOccurs="0" maxOccurs="unbounded">
<xsd:element ref="varDecl"/>
<xsd:element ref="functionDecl"/>
<xsd:element ref="optionDecl"/>
</xsd:choice>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<xsd:element name="defaultCollationDecl" type="xsd:string"/>
<xsd:element name="baseUriDecl" type="xsd:string"/>
<xsd:element name="orderingModeDecl">
<xsd:simpleType>
<xsd:restriction base="xsd:NMTOKEN">
<xsd:enumeration value="ordered"/>
<xsd:enumeration value="unordered"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:element>
<xsd:element name="emptyOrderingDecl" type="emptyOrderingMode"/>
<xsd:element name="constructionDecl">
<xsd:simpleType>
<xsd:restriction base="xsd:NMTOKEN">
<xsd:enumeration value="strip"/>
<xsd:enumeration value="preserve"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:element>
<xsd:element name="copyNamespacesDecl">
<xsd:complexType>
<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>
<xsd:simpleType name="defaultNamespaceCategory">
<xsd:restriction base="xsd:NMTOKEN">
<xsd:enumeration value="function"/>
<xsd:enumeration value="element"/>
</xsd:restriction>
</xsd:simpleType>
<xsd:element name="defaultNamespaceDecl">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="defaultNamespaceCategory" type="defaultNamespaceCategory"/>
<xsd:element name="uri" type="xsd:string"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<xsd:element name="varDecl">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="varName" type="QName"/>
<xsd:element ref="typeDeclaration" minOccurs="0"/>
<xsd:choice>
<xsd:element name="varValue" type="exprWrapper"/>
<xsd:element name="external" type="emptyContent"/>
</xsd:choice>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<xsd:element name="optionDecl">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="optionName" type="QName"/>
<xsd:element name="optionContents" type="xsd:string"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<xsd:element name="param">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="varName" type="QName"/>
<xsd:element ref="typeDeclaration" minOccurs="0"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<xsd:element name="paramList">
<xsd:complexType>
<xsd:sequence>
<xsd:element ref="param" minOccurs="0" maxOccurs="unbounded"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<xsd:element name="functionDecl">
<xsd:complexType>
<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" type="emptyContent"/>
</xsd:choice>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<xsd:element name="moduleImport">
<xsd:complexType>
<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>
<xsd:element name="schemaImport">
<xsd:complexType>
<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>
<!-- The element below handles the trivial XQuery embedding -->
<xsd:element name="xquery" type="xsd:string"/>
</xsd:schema>
5 A Trivial Embedding of XQuery
1 Introduction observed that the
[XML Query 1.0 Requirements] says "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."
There are many possible ways to define an XML syntax for XQuery.
This document specifies two XML Syntaxes for XQuery:
the one in 4 An XML Schema for the XQuery XML Syntax and the "trivial embedding"
defined in this section.
Of course, XQueries could be expressed in XML Syntax in other ways.
The trivial embedding specified here can be used when an
XQuery is exchanged with other entities as XML or embedded
in an XML document, and when it is not necessary to communicate
the underlying structure of the query.
When this alternative is chosen, the XQuery expression is treated
as though it were ordinary text.
The trivial embedding defined in this specification requires that the
entire query be enclosed within an element named "xquery" in the XQueryX namespace
(the "xqx:" namespace prefix is used here only for the purposes of this example),
as illustrated here:
<xqx:xquery>for $i... let $j...where $x = $y...return...</xqx:xquery>
If the XQuery contains characters that are prohibited in XML text (specifically < and &),
except when they occur within a CDATA section within the XQuery,
they must be "escaped" as either character entity references (< and &, respectively)
or numeric character references (for example, <and &, respectively).
In addition, because the sequence of characters "]]>" is always prohibited as element content,
it is recommended that > always be "escaped" (for example, as > or E;).
<xqx:xquery>for $i... let $j...where $x < $y...return...</xqx:xquery>
or
<xqx:xquery>for $i... let $j...where $x &x003C; $y...return...</xqx:xquery>
This limitation may require that user agents scan the XQuery text, escaping such
prohibited characters, before transmitting or embedding the XQuery as XML.
The following two more complete examples (which are equivalent to one another
and to "for $i in (1 to 5) let $j :=4 where $i < $j return
<x/><i>{$i}</i></x>") further illustrate the use of the
XQueryX trivial embedding. CDATA sections within an XQuery expression are embedded in
the same form in which they appear in any XML document.
<xqx:xquery>for $i in (1 to 5) let $j := 4 where $i < $j return
<x/><i>{$i}</i></x></xqx:xquery>
<xqx:xquery><![CDATA[for $i in (1 to 5) let $j := 4 where $i < $j
return <x/><i>{$i}</i></x>]]></xqx:xquery>
6 Conformance
In
this section, thefollowing terms are used toindicate the
requirementlevels defined in [RFC 2119].
[Definition:
MUST means thatthe item isan absolute requirement ofthespecification.]
[Definition:SHOULD meansthat there may exist valid reasons in particular
circumstances to ignore a particular item, butthe full implications
must be understood and carefully weighed before choosinga different course.]
[Definition:MAYmeansthat an item istruly optional.]