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/.
On 3 November 2005, this specification was published as a Candidate Recommendation, and a Call for Implementations was announced. This revision is published in order to give visibility to the technical decisions that have been made so far during this phase of the process and to allow review by W3C Members and other interested parties. The maturity level of the specification
remains unchanged, and the work is on track to move forward to the Proposed Recommendation stage when the exit criteria for the current phase have been met. 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
specification will remain a Candidate Recommendation until at least 28 February 2006.
This document was produced by the XML Query Working Group, part of the XML Activity.
On 03 November 2005, this specification was published as a Candidate Recommendation, and a Call for Implementations was announced. This revised document is published in order to give visibility to the technical decisions that have been made so far during this phase of the process. The maturity level of the specification remains unchanged, and the work is on track to move
forward to the W3C Proposed Recommendation stage when the exit criteria for the current phase have been met.
This draft includes corrections and changes based on public comments recorded in the W3C public Bugzilla repository (http://www.w3.org/Bugs/Public/) used for Last Call issues tracking. A list of substantive changes since the publication of the Candidate Recommendation of 03 November 2005 can be found in D Change log.
Comments on this document are invited and should be made in 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 mailing list, public-qt-comments@w3.org. It will be very helpful if you include the string
[XQueryX] in the subject line of your comment, whether made in Bugzilla or in email. Each Bugzilla entry and email message should contain only one comment. Archives of the comments and responses are available at http://lists.w3.org/Archives/Public/public-qt-comments/ .
The XML Query and XPath Test Suite is under development. Implementors are encouraged to run this test suite and report their results. A preliminary XQuery Test Suite Result Summary has been prepared that contains information submitted for several implementations.
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 [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: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/2005/qt-applets/xqueryApplet.html.
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 [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: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 [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: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, 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: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:parenthesizedExpr>
<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:parenthesizedExpr>
</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 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 -->
<!-- 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: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>
<!-- removed nameTest and Wildcard outer choices per Bugzilla Bug #2523 -->
<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 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>
<!-- 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: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>
XQuery expressions are, for the purposes of this trivial embedding, treated as literal text. Therefore, if the XQuery contains characters that are prohibited in XML text (specifically < and &), they must be "escaped" as character entity references (< and &, respectively) or as numeric character references (for example, < and &, respectively), or they must be enclosed in a CDATA section (for example, <![CDATA[<]] or <![CDATA[&]]). Note that this
includes the leading "<" of a CDATA section that appears in the original XQuery expression. In addition, because the sequence of characters "]]>" is always prohibited within element content, it is recommended that instances of > in the original XQuery always be "escaped" (for example, as >, >, or <![CDATA[>]]).
<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.
<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>