IntroductionThe XQuery 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.
In this document, examples and material labeled as Note
are provided for
explanatory purposes and are not normative.
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
.
There are several environments in which XQueryX may be useful:
Parser Reuse. In heterogeneous environments, a
variety of systems may be used to execute a query. One parser can generate XQueryX
for all of these systems.
Queries on Queries. Because XQueryX is represented in XML, queries
can be queried and can be transformed into new queries. For instance, a query can
be performed against a set of XQueryX queries to determine which queries use
FLWOR expressions to range over a set of invoices.
Generating Queries. In some XML-oriented programming
environments, it may be more convenient to build a query in its XQueryX
representation than in the corresponding XQuery representation, since ordinary
XML tools can be used.
Embedding Queries in XML. XQueryX can be embedded
directly in an XML document.
This version of XQueryX is fully compatible with .
It differs from that earlier version of the language by the addition of new XML Schema
definitions and XSLT stylesheet templates. All queries expressed in the syntax defined
by continue to be valid, with the same meaning, when processed
by an implementation of this version of XQueryX.
The most recent versions of the XQueryX XML Schema and the XQueryX XSLT stylesheet
are available at
https://www.w3.org/2017/03/XQueryX/xqueryx.xsd
and
https://www.w3.org/2017/03/XQueryX/xqueryx.xsl,
respectively.
The locations at which the current versions of the XML Schema and XSLT stylesheet are located during development of
this specification will vary with each Working Draft and Candidate Recommendation of the spec that is published.
The namespace target URI is identical to that used for .
Mapping the XQuery SyntaxXQueryX is an XML representation of the abstract syntax found in
Appendix A of
.
The XQueryX syntax is defined by the XQueryX Schema,
which is specified in .
The XQueryX semantics are defined by a stylesheet that maps
an instance of XQueryX to an instance of XQuery;
see .
The main data structure in the XQueryX Schema is the set of types that describe
expressions. We have chosen to model expressions using substitution groups,
with an "expr" abstract base class and a number of intermediate abstract classes.
Consider the following productions from the abstract syntax:
FLWORExpr ::= InitialClause IntermediateClause* ReturnClause
InitialClause ::= ForClause | LetClause | WindowClause
IntermediateClause ::= InitialClause | WhereClause | GroupByClause | OrderByClause | CountClause
ForClause ::= "outer"? "for" "$" VarName TypeDeclaration? PositionalVar? "in" ExprSingle
("," "$" VarName TypeDeclaration? PositionalVar? "in" ExprSingle)*
PositionalVar ::= "at" "$" VarName
LetClause ::= "let" "$" VarName TypeDeclaration? ":=" ExprSingle
("," "$" VarName TypeDeclaration? ":=" ExprSingle)*
WhereClause ::= "where" ExprSingle
Those productions do not represent the entire FLWOR expression, so some of the
BNF non-terminal names are not resolved in the example abstract syntax.
The following XQueryX Schema definitions reflect the structure of those
productions from that abstract syntax:
<!-- The base class -->
<xsd:complexType name="expr"/>
<xsd:element name="expr" type="expr" abstract="true"/>
<!-- Simple wrapper class -->
<xsd:complexType name="exprWrapper">
<xsd:sequence>
<xsd:element ref="expr"/>
</xsd:sequence>
</xsd:complexType>
<xsd:complexType name="flworExpr">
<xsd:complexContent>
<xsd:extension base="expr">
<xsd:sequence>
<xsd:choice>
<xsd:element ref="forClause"/>
<xsd:element ref="letClause"/>
<xsd:element ref="windowClause"/>
</xsd:choice>
<xsd:sequence>
<xsd:choice minOccurs="0" maxOccurs="unbounded">
<xsd:element ref="forClause"/>
<xsd:element ref="letClause"/>
<xsd:element ref="windowClause"/>
<xsd:element ref="countClause"/>
<xsd:element ref="whereClause"/>
<xsd:element ref="groupByClause"/>
<xsd:element ref="orderByClause"/>
</xsd:choice>
<xsd:element ref="returnClause"/>
</xsd:sequence>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="flworExpr" type="flworExpr" substitutionGroup="expr"/>
<xsd:complexType name="forClause">
<xsd:sequence>
<xsd:element ref="forClauseItem" minOccurs="1" maxOccurs="unbounded"/>
</xsd:sequence>
<xsd:attribute name="outer" type="xsd:boolean" default="false"/>
</xsd:complexType>
<xsd:element name="forClause" type="forClause"/>
<xsd:complexType name="forClauseItem">
<xsd:sequence>
<xsd:element ref="typedVariableBinding"/>
<xsd:element ref="positionalVariableBinding" minOccurs="0" maxOccurs="1"/>
<xsd:element ref="forLetClauseItemExtensions" minOccurs="0"
maxOccurs="unbounded"/>
<xsd:element name="forExpr" type="exprWrapper"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="forClauseItem" type="forClauseItem"/>
<xsd:element name="forLetClauseItemExtensions" abstract="true"/>
<xsd:complexType name="letClause">
<xsd:sequence>
<xsd:element ref="letClauseItem" maxOccurs="unbounded"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="letClause" type="letClause"/>
<xsd:complexType name="letClauseItem">
<xsd:sequence>
<xsd:choice>
<xsd:sequence>
<xsd:element ref="typedVariableBinding"/>
<xsd:element ref="forLetClauseItemExtensions"
minOccurs="0" maxOccurs="unbounded"/>
</xsd:sequence>
<xsd:element ref="forLetClauseItemExtensions"
minOccurs="0" maxOccurs="unbounded"/>
</xsd:choice>
<xsd:element name="letExpr" type="exprWrapper"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="letClauseItem" type="letClauseItem"/>
<xsd:element name="whereClause" type="exprWrapper"/>
Since XQuery uses the expression production liberally to allow
expressions to be flexibly combined, XQueryX uses the exprWrapper type
in embedded contexts to allow all expression types to occur.
Examples from the XML Query Use Cases in XML SyntaxThree of following examples are based on the data and queries in the XMP
(Experiences and Exemplars) use case in
,
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
,
an XQueryX solution, and the XQuery that results from applying the XQueryX-to-XQuery transformation
defined by the stylesheet in to the XQueryX solution.
The generated XQuery is presented only as a sanity-check —
the intent of the stylesheet is not to create the identical
XQuery expression given in
,
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
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.
Example 1Here is Q1 from the
,
use case XMP (Experiences and Exemplars): "List books published by Addison-Wesley after 1991,
including their year and title."
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>
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>
Transformation of XQueryX Solution into XQueryApplication of the stylesheet in
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>
Corresponding Grammar Abstract Parse TreeFor comparison, here is the abstract parse tree corresponding to the
XQuery for Example 1, as produced by the XQuery grammar applets found at
https://www.w3.org/2007/01/applets/.
XPath2
QueryList
Module
MainModule
Prolog
QueryBody
Expr
PathExpr
Constructor
DirectConstructor
DirElemConstructor >
LessThanOpOrTagO <
TagQName bib
DirAttributeList
StartTagClose >
DirElemContent
ElementContentChar
DirElemContent
ElementContentChar
DirElemContent
CommonContent
EnclosedExpr
Lbrace {
Expr
FLWORExpr
ForClause
VarName
QName b
PathExpr
FunctionCall
FunctionQName doc
PathExpr
StringLiteral "http://bstore1.example.com/bib.xml"
StepExpr
AbbrevForwardStep
NodeTest
NameTest
QName bib
StepExpr
AbbrevForwardStep
NodeTest
NameTest
QName book
WhereClause
AndExpr and
ComparisonExpr =
PathExpr
VarName
QName b
StepExpr
AbbrevForwardStep
NodeTest
NameTest
QName publisher
PathExpr
StringLiteral "Addison-Wesley"
ComparisonExpr >
PathExpr
VarName
QName b
StepExpr
AbbrevForwardStep @
NodeTest
NameTest
QName year
PathExpr
IntegerLiteral 1991
PathExpr
Constructor
DirectConstructor
DirElemConstructor >
LessThanOpOrTagO <
TagQName book
DirAttributeList
S
TagQName year
ValueIndicator =
DirAttributeValue
OpenQuot "
QuotAttrValueContent
CommonContent
EnclosedExpr
Lbrace {
Expr
PathExpr
VarName
QName b
StepExpr
AbbrevForwardStep @
NodeTest
NameTest
QName year
Rbrace }
CloseQuot "
StartTagClose >
DirElemContent
ElementContentChar
DirElemContent
ElementContentChar
DirElemContent
ElementContentChar
DirElemContent
ElementContentChar
DirElemContent
ElementContentChar
DirElemContent
ElementContentChar
DirElemContent
CommonContent
EnclosedExpr
Lbrace {
Expr
PathExpr
VarName
QName b
StepExpr
AbbrevForwardStep
NodeTest
NameTest
QName title
Rbrace }
DirElemContent
ElementContentChar
DirElemContent
ElementContentChar
DirElemContent
ElementContentChar
DirElemContent
ElementContentChar
DirElemContent
ElementContentChar
Rbrace }
DirElemContent
ElementContentChar
Example 2Here is Q4 from the
,
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."
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>
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>
Transformation of XQueryX Solution into XQueryApplication of the stylesheet in
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>
Example 3Here is Q7 from the
,
use case XMP (Experiences and Exemplars): "List the titles and years of all books published by
Addison-Wesley after 1991, in alphabetic order."
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>
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>
Transformation of XQueryX Solution into XQueryApplication of the stylesheet in to the XQueryX solution
results in:
<bib>{
for $b in doc("http://bstore1.example.com/bib.xml")/descendant-or-self::node()/child::book
where (($b/child::publisher = "Addison-Wesley") and ($b/attribute::year > 1991))
order by $b/child::title
return <book>{$b/attribute::year}{$b/child::title}</book>
}</bib>
Example 4Here is Q8 from the
,
use case NS (Queries Using Namespaces):
"Select all traders (either seller or high bidder) without negative comments."
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>
A solution in XQueryX:
<?xml version="1.0"?>
<!-- ================================================================================ -->
<!-- Errata applied: -->
<!-- XQX.E2 - Editorial (Bugzilla Bug 4963) -->
<!-- ================================================================================ -->
<xqx:module xmlns:xqx="http://www.w3.org/2005/XQueryX"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.w3.org/2005/XQueryX
http://www.w3.org/2005/XQueryX/xqueryx.xsd">
<xqx:mainModule>
<xqx:prolog>
<xqx:namespaceDecl>
<xqx:prefix>ma</xqx:prefix>
<xqx:uri>http://www.example.com/AuctionWatch</xqx:uri>
</xqx:namespaceDecl>
</xqx:prolog>
<xqx:queryBody>
<xqx:elementConstructor>
<xqx:tagName>Q8</xqx:tagName>
<xqx:attributeList>
<xqx:namespaceDeclaration>
<xqx:prefix>ma</xqx:prefix>
<xqx:uri>http://www.example.com/AuctionWatch</xqx:uri>
</xqx:namespaceDeclaration>
<xqx:namespaceDeclaration>
<xqx:prefix>eachbay</xqx:prefix>
<xqx:uri>http://www.example.com/auctioneers#eachbay</xqx:uri>
</xqx:namespaceDeclaration>
<xqx:namespaceDeclaration>
<xqx:prefix>xlink</xqx:prefix>
<xqx:uri>http://www.w3.org/1999/xlink</xqx:uri>
</xqx:namespaceDeclaration>
</xqx:attributeList>
<xqx:elementContent>
<xqx:flworExpr>
<xqx:forClause>
<xqx:forClauseItem>
<xqx:typedVariableBinding>
<xqx:varName>s</xqx:varName>
</xqx:typedVariableBinding>
<xqx:forExpr>
<xqx:pathExpr>
<xqx:stepExpr>
<xqx:filterExpr>
<xqx:functionCallExpr>
<xqx:functionName xqx:prefix="fn">doc</xqx:functionName>
<xqx:arguments>
<xqx:stringConstantExpr>
<xqx:value>auction.xml</xqx:value>
</xqx:stringConstantExpr>
</xqx:arguments>
</xqx:functionCallExpr>
</xqx:filterExpr>
</xqx:stepExpr>
<xqx:stepExpr>
<xqx:xpathAxis>descendant-or-self</xqx:xpathAxis>
<xqx:anyKindTest/>
</xqx:stepExpr>
<xqx:stepExpr>
<xqx:xpathAxis>child</xqx:xpathAxis>
<xqx:nameTest xqx:prefix="ma">Trading_Partners</xqx:nameTest>
</xqx:stepExpr>
<xqx:stepExpr>
<xqx:filterExpr>
<xqx:sequenceExpr>
<xqx:unionOp>
<xqx:firstOperand>
<xqx:pathExpr>
<xqx:stepExpr>
<xqx:xpathAxis>child</xqx:xpathAxis>
<xqx:nameTest xqx:prefix="ma">Seller</xqx:nameTest>
</xqx:stepExpr>
</xqx:pathExpr>
</xqx:firstOperand>
<xqx:secondOperand>
<xqx:pathExpr>
<xqx:stepExpr>
<xqx:xpathAxis>child</xqx:xpathAxis>
<xqx:nameTest xqx:prefix="ma">High_Bidder</xqx:nameTest>
</xqx:stepExpr>
</xqx:pathExpr>
</xqx:secondOperand>
</xqx:unionOp>
</xqx:sequenceExpr>
</xqx:filterExpr>
</xqx:stepExpr>
</xqx:pathExpr>
</xqx:forExpr>
</xqx:forClauseItem>
</xqx:forClause>
<xqx:whereClause>
<xqx:equalOp>
<xqx:firstOperand>
<xqx:pathExpr>
<xqx:stepExpr>
<xqx:filterExpr>
<xqx:varRef>
<xqx:name>s</xqx:name>
</xqx:varRef>
</xqx:filterExpr>
</xqx:stepExpr>
<xqx:stepExpr>
<xqx:xpathAxis>child</xqx:xpathAxis>
<xqx:Wildcard>
<xqx:star/>
<xqx:NCName>NegativeComments</xqx:NCName>
</xqx:Wildcard>
</xqx:stepExpr>
</xqx:pathExpr>
</xqx:firstOperand>
<xqx:secondOperand>
<xqx:integerConstantExpr>
<xqx:value>0</xqx:value>
</xqx:integerConstantExpr>
</xqx:secondOperand>
</xqx:equalOp>
</xqx:whereClause>
<xqx:returnClause>
<xqx:varRef>
<xqx:name>s</xqx:name>
</xqx:varRef>
</xqx:returnClause>
</xqx:flworExpr>
</xqx:elementContent>
</xqx:elementConstructor>
</xqx:queryBody>
</xqx:mainModule>
</xqx:module>
Transformation of XQueryX Solution into XQueryApplication of the stylesheet in
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>
An XML Schema for the XQuery XML SyntaxHere is the XML Schema against which XQueryX documents must be valid.
<?xml version="1.0"?>
<!-- ================================================================================ -->
<!-- NOTES TO READERS OF THIS SCHEMA: -->
<!-- The default value for both minOccurs and maxOccurs is "1". -->
<!-- The XQueryX schema has been designed to provide the ability to extend definitions -->
<!-- of top-level elements in extensions such as Full-Text and the Update Facility. -->
<!-- The nature of the modification is to define named complex types and redefine -->
<!-- those top-level elements in terms of the named complex types. -->
<!-- ================================================================================ -->
<!-- Changes from Recommendation (XQueryX 3.0): -->
<!-- ================================================================================ -->
<!-- Errata applied: -->
<!-- ================================================================================ -->
<!-- Modifications: -->
<!-- JM/2014-07-11 : Added support for anyMapText and typedMapTest -->
<!-- JM/2014-07-11 : Added support for anyArrayText and typedArrayTest -->
<!-- JM/2014-07-13 : Added support for new alternatives in stepExpr -->
<!-- JM/2014-07-13 : Added support for lookup (formerly mapLookup) and arrowPostfix -->
<!-- JM/2014-07-13 : Added support for unaryLookup (formerly unaryMapLookup) -->
<!-- JM/2014-07-13 : Added support for new alternatives in filterExpr -->
<!-- JM/2014-07-13 : Added support for mapConstructor and arrayConstructor -->
<!-- JM/2014-08-28 : Fixed [unary]Lookup replacing stringLiteral w/integerLiteral -->
<!-- JM/2015-01-21 : Replaced arrowPostfix with arrowExpr per bug 27537 -->
<!-- JS/2015-11-05 : Added support for stringConstructor and optional enclosed expr -->
<!-- JS/2016-09-23 : Bug 29823 - remove duplicate integerLiteral and variableRef -->
<!-- ================================================================================ -->
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns="http://www.w3.org/2005/XQueryX"
targetNamespace="http://www.w3.org/2005/XQueryX"
elementFormDefault="qualified" attributeFormDefault="qualified">
<!-- A few helper declarations -->
<xsd:complexType name="emptyContent"/>
<xsd:element name="NCName" type="xsd:NCName"/>
<xsd:complexType name="QName">
<xsd:simpleContent>
<xsd:extension base="xsd:NCName">
<xsd:attribute name="prefix" type="xsd:NCName" use="optional"/>
</xsd:extension>
</xsd:simpleContent>
</xsd:complexType>
<xsd:complexType name="EQName">
<xsd:simpleContent>
<xsd:extension base="xsd:NCName">
<xsd:attribute name="prefix" type="xsd:NCName" use="optional"/>
<xsd:attribute name="URI" type="xsd:string" use="optional"/>
</xsd:extension>
</xsd:simpleContent>
</xsd:complexType>
<!-- The base expression class -->
<xsd:complexType name="expr"/>
<xsd:element name="expr" type="expr" abstract="true"/>
<!-- A list of expressions -->
<xsd:complexType name="exprList">
<xsd:sequence>
<xsd:element ref="expr" minOccurs="0" maxOccurs="unbounded"/>
</xsd:sequence>
</xsd:complexType>
<!-- A list of expressions or placeholders -->
<xsd:complexType name="exprOrPlaceholderList">
<xsd:sequence>
<xsd:choice minOccurs="0" maxOccurs="unbounded">
<xsd:element ref="expr"/>
<xsd:element name="argumentPlaceholder" type="emptyContent"/>
</xsd:choice>
</xsd:sequence>
</xsd:complexType>
<!-- A type to be used by elements that comprise an optional expr -->
<xsd:complexType name="exprWrapperOptional">
<xsd:sequence>
<xsd:element ref="expr" minOccurs="0"/>
</xsd:sequence>
</xsd:complexType>
<!-- Simple wrapper class -->
<xsd:complexType name="exprWrapper">
<xsd:sequence>
<xsd:element ref="expr"/>
</xsd:sequence>
</xsd:complexType>
<!-- A list of literals -->
<xsd:complexType name="literalList">
<xsd:sequence>
<xsd:element ref="constantExpr" minOccurs="0" maxOccurs="unbounded"/>
</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="EQName"/>
</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 -->
<!-- 2010-01-01, JM replaced pragmaContents elem def'n with one that has a pattern -->
<xsd:complexType name="pragma">
<xsd:sequence>
<xsd:element name="pragmaName" type="EQName"/>
<xsd:element name="pragmaContents">
<xsd:simpleType>
<xsd:restriction base="xsd:string">
<xsd:pattern value="(([^#]|#+[^\)#])*#*)"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:element>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="pragma" type="pragma"/>
<xsd:complexType name="extensionExpr">
<xsd:complexContent>
<xsd:extension base="expr">
<xsd:sequence>
<xsd:element ref="pragma" maxOccurs="unbounded"/>
<xsd:element name="argExpr" type="exprWrapper" minOccurs="0"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="extensionExpr" type="extensionExpr"
substitutionGroup="expr"/>
<!-- Simple map expressions -->
<xsd:complexType name="simpleMapExpr">
<xsd:complexContent>
<xsd:extension base="expr">
<xsd:sequence minOccurs="2" maxOccurs="unbounded">
<xsd:element ref="pathExpr"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="simpleMapExpr" type="simpleMapExpr"
substitutionGroup="expr"/>
<!-- Function call expressions -->
<xsd:complexType name="functionCallExpr">
<xsd:complexContent>
<xsd:extension base="expr">
<xsd:sequence>
<xsd:element name="functionName" type="EQName"/>
<xsd:element name="arguments" type="exprOrPlaceholderList" 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="EQName"/>
<xsd:element name="argExpr" type="exprWrapper"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="constructorFunctionExpr" type="constructorFunctionExpr"
substitutionGroup="expr"/>
<!-- Sequence expressions -->
<xsd:complexType name="sequenceExpr">
<xsd:complexContent>
<xsd:extension base="expr">
<xsd:sequence>
<xsd:element ref="expr" minOccurs="0" maxOccurs="unbounded"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="sequenceExpr" type="sequenceExpr" substitutionGroup="expr"/>
<xsd:complexType name="rangeSequenceExpr">
<xsd:complexContent>
<xsd:extension base="expr">
<xsd:sequence>
<xsd:element name="startExpr" type="exprWrapper"/>
<xsd:element name="endExpr" type="exprWrapper"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="rangeSequenceExpr" type="rangeSequenceExpr"
substitutionGroup="expr"/>
<!-- Builtin operator expressions -->
<xsd:complexType name="operatorExpr">
<xsd:complexContent>
<xsd:extension base="expr"/>
</xsd:complexContent>
</xsd:complexType>
<xsd:complexType name="unaryOperatorExpr">
<xsd:complexContent>
<xsd:extension base="operatorExpr">
<xsd:sequence>
<xsd:element name="operand" type="exprWrapper"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:complexType name="binaryOperatorExpr">
<xsd:complexContent>
<xsd:extension base="operatorExpr">
<xsd:sequence>
<xsd:element name="firstOperand" type="exprWrapper"/>
<xsd:element name="secondOperand" type="exprWrapper"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<!-- General operator expressions -->
<xsd:element name="operatorExpr" type="operatorExpr"
abstract="true" substitutionGroup="expr"/>
<!-- Arithmetic operator expressions -->
<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"/>
<!-- String operator expressions -->
<xsd:element name="stringOp" type="operatorExpr"
abstract="true" substitutionGroup="operatorExpr"/>
<xsd:element name="stringConcatenateOp" type="binaryOperatorExpr"
substitutionGroup="stringOp"/>
<!-- Comparison operator expressions -->
<xsd:element name="comparisonOp" type="binaryOperatorExpr" abstract="true"
substitutionGroup="operatorExpr"/>
<!-- Value comparison operator expressions -->
<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"/>
<!-- General comparison operator expressions -->
<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"/>
<!-- Node comparison operator expressions -->
<xsd:element name="nodeComparisonOp" type="binaryOperatorExpr"
abstract="true" substitutionGroup="operatorExpr"/>
<xsd:element name="isOp" type="binaryOperatorExpr"
substitutionGroup="nodeComparisonOp"/>
<!-- Order comparison operator expressions -->
<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"/>
<!-- Logical operator expressions -->
<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 -->
<!-- By changing the type attribute from QName to EQName, this is now atomicOrUnionType -->
<!-- However, for backwards compatibility w/XQueryX 1.0, the name had to stay the same-->
<xsd:element name="atomicType" type="EQName" substitutionGroup="itemType"/>
<!-- Used in castable expression and cast expression -->
<xsd:complexType name="singleType">
<xsd:sequence>
<xsd:element ref="atomicType"/>
<xsd:element name="optional" type="emptyContent" minOccurs="0"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="singleType" type="singleType"/>
<!-- Item type schema types and elements -->
<xsd:element name="itemType" abstract="true"/>
<xsd:complexType name="contextItemType">
<xsd:complexContent>
<xsd:extension base="emptyItemTypeContent">
<xsd:sequence>
<xsd:element ref="itemType"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="contextItemType" type="contextItemType" substitutionGroup="itemType"/>
<xsd:complexType name="emptyItemTypeContent"/>
<xsd:element name="anyItemType" type="emptyItemTypeContent"
substitutionGroup="itemType"/>
<xsd:simpleType name="occurrenceIndicator">
<xsd:restriction base="xsd:string">
<xsd:enumeration value="?"/>
<xsd:enumeration value="*"/>
<xsd:enumeration value="+"/>
</xsd:restriction>
</xsd:simpleType>
<!-- Sequence type -->
<xsd:complexType name="sequenceType">
<xsd:choice>
<xsd:element name="voidSequenceType" type="emptyContent"/>
<xsd:sequence>
<xsd:element ref="itemType"/>
<xsd:element name="occurrenceIndicator" type="occurrenceIndicator"
minOccurs="0"/>
</xsd:sequence>
</xsd:choice>
</xsd:complexType>
<xsd:element name="sequenceType" type="sequenceType"/>
<xsd:element name="typeDeclaration" type="sequenceType"/>
<!-- Union of sequence types -->
<xsd:complexType name="sequenceTypeUnion">
<xsd:sequence minOccurs="1" maxOccurs="unbounded">
<xsd:element ref="sequenceType"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="sequenceTypeUnion" type="sequenceTypeUnion"/>
<!-- Represents a "typed" variable (for clause, let clause etc) -->
<xsd:complexType name="typedVariableBinding">
<xsd:sequence>
<xsd:element name="varName" type="EQName"/>
<xsd:element ref="typeDeclaration" minOccurs="0"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="typedVariableBinding" type="typedVariableBinding"/>
<!-- Represents an untyped variable for the "at" clause in a for clause -->
<xsd:element name="positionalVariableBinding" type="EQName"/>
<xsd:element name="variableBinding" type="EQName"/>
<!-- Represents all variable bindings in a for or let clause except typed and -->
<!-- positional variable bindings -->
<xsd:element name="forLetClauseItemExtensions" abstract="true"/>
<!-- Major syntax productions: FLWOR clause components -->
<!-- for clause -->
<xsd:complexType name="forClauseItem">
<xsd:sequence>
<xsd:element ref="typedVariableBinding"/>
<xsd:element name="allowingEmpty" type="emptyContent"
minOccurs="0"/>
<xsd:element ref="positionalVariableBinding" minOccurs="0" maxOccurs="1"/>
<xsd:element ref="forLetClauseItemExtensions" minOccurs="0"
maxOccurs="unbounded"/>
<xsd:element name="forExpr" type="exprWrapper"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="forClauseItem" type="forClauseItem"/>
<xsd:complexType name="forClause">
<xsd:sequence>
<xsd:element ref="forClauseItem" minOccurs="1" maxOccurs="unbounded"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="forClause" type="forClause"/>
<!-- let clause -->
<xsd:complexType name="letClauseItem">
<xsd:sequence>
<xsd:choice>
<xsd:sequence>
<xsd:element ref="typedVariableBinding"/>
<xsd:element ref="forLetClauseItemExtensions"
minOccurs="0" maxOccurs="unbounded"/>
</xsd:sequence>
<xsd:element ref="forLetClauseItemExtensions"
minOccurs="0" maxOccurs="unbounded"/>
</xsd:choice>
<xsd:element name="letExpr" type="exprWrapper"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="letClauseItem" type="letClauseItem"/>
<xsd:complexType name="letClause">
<xsd:sequence>
<xsd:element ref="letClauseItem" maxOccurs="unbounded"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="letClause" type="letClause"/>
<!-- This is the windowClause (part of FLWOR expression) -->
<!-- It corresponds to the following XQuery grammar -->
<!-- WindowClause ::= "for" (TumblingWindowClause | SlidingWindowClause) -->
<xsd:complexType name="windowClause">
<xsd:choice>
<xsd:element ref="tumblingWindowClause"/>
<xsd:element ref="slidingWindowClause"/>
</xsd:choice>
</xsd:complexType>
<xsd:element name="windowClause" type="windowClause"/>
<!-- This is the tumblingWindowClause -->
<!-- It corresponds to the following XQuery grammar -->
<!-- TumblingWindowClause ::= "tumbling" "window" "$" VarName TypeDeclaration? -->
<!-- "in" ExprSingle WindowStartCondition WindowEndCondition? -->
<xsd:complexType name="tumblingWindowClause">
<xsd:sequence>
<xsd:element ref="typedVariableBinding"/>
<xsd:element name="bindingSequence" type="exprWrapper"/>
<xsd:element ref="windowStartCondition"/>
<xsd:element ref="windowEndCondition" minOccurs="0"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="tumblingWindowClause" type="tumblingWindowClause"/>
<!-- This is the slidingWindowClause -->
<!-- It corresponds to the following XQuery grammar -->
<!-- SlidingWindowClause ::= "sliding" "window" "$" VarName TypeDeclaration? -->
<!-- "in" ExprSingle WindowStartCondition WindowEndCondition -->
<xsd:complexType name="slidingWindowClause">
<xsd:sequence>
<xsd:element ref="typedVariableBinding"/>
<xsd:element name="bindingSequence" type="exprWrapper"/>
<xsd:element ref="windowStartCondition"/>
<xsd:element ref="windowEndCondition"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="slidingWindowClause" type="slidingWindowClause"/>
<!-- windowStartCondition -->
<!-- Corresponds to the following XQuery grammar -->
<!-- WindowStartCondition ::= "start" WindowVars "when" ExprSingle -->
<xsd:complexType name="windowStartCondition">
<xsd:sequence>
<xsd:element ref="windowVars" minOccurs="0"/>
<xsd:element name="winStartExpr" type="exprWrapper"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="windowStartCondition" type="windowStartCondition"/>
<!-- windowEndCondition -->
<!-- Corresponds to the following XQuery grammar -->
<!-- WindowEndCondition ::= "only"? "end" WindowVars "when" ExprSingle -->
<xsd:complexType name="windowEndCondition">
<xsd:sequence>
<xsd:element ref="windowVars" minOccurs="0"/>
<xsd:element name="winEndExpr" type="exprWrapper"/>
</xsd:sequence>
<xsd:attribute name="onlyEnd" type="xsd:boolean" default="false"/>
</xsd:complexType>
<xsd:element name="windowEndCondition" type="windowEndCondition"/>
<!-- windowVars -->
<!-- Corresponds to the following XQuery grammar -->
<!-- WindowVars ::= ("$" \)? PositionalVar? ("previous" "$" PreviousItem)? -->
<!-- ("next" "$" NextItem)? -->
<xsd:complexType name="windowVars">
<xsd:sequence>
<xsd:element name="currentItem" type="EQName" minOccurs="0"/>
<xsd:element ref="positionalVariableBinding" minOccurs="0"/>
<xsd:element name="previousItem" type="EQName" minOccurs="0"/>
<xsd:element name="nextItem" type="EQName" minOccurs="0"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="windowVars" type="windowVars"/>
<!-- countClause (part of FLWOR expression) -->
<xsd:complexType name="countClause">
<xsd:sequence>
<xsd:element ref="varRef"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="countClause" type="countClause"/>
<!-- whereClause (part of FLWOR expression) -->
<xsd:element name="whereClause" type="exprWrapper"/>
<!-- groupByClause (part of FLWOR expression) -->
<!-- Corresponds to the following XQuery syntax -->
<!-- GroupByClause ::= "group" "by" GroupingSpecList -->
<!-- GroupingSpecList ::= GroupingSpec ("," GroupingSpec)* -->
<xsd:complexType name="groupByClause">
<xsd:sequence maxOccurs="unbounded">
<xsd:element ref="groupingSpec"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="groupByClause" type="groupByClause"/>
<!-- Corresponds to the following XQuery syntax -->
<!-- GroupingSpec ::= -->
<!-- "$" VarName ( typeDeclaration? ":=" exprSingle )? ("collation" URILiteral)? -->
<xsd:complexType name="groupingSpec">
<xsd:sequence>
<xsd:element name="varName" type="EQName"/>
<xsd:element name="groupVarInitialize" minOccurs="0">
<xsd:complexType>
<xsd:sequence>
<xsd:element ref="typeDeclaration" minOccurs="0"/>
<xsd:element name="varValue" type="exprWrapper"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<xsd:element name="collation" type="xsd:string" minOccurs="0"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="groupingSpec" type="groupingSpec"/>
<!-- order by clause -->
<xsd:simpleType name="emptyOrderingMode">
<xsd:restriction base="xsd:string">
<xsd:enumeration value="empty greatest"/>
<xsd:enumeration value="empty least"/>
</xsd:restriction>
</xsd:simpleType>
<xsd:simpleType name="orderingKind">
<xsd:restriction base="xsd:string">
<xsd:enumeration value="ascending"/>
<xsd:enumeration value="descending"/>
</xsd:restriction>
</xsd:simpleType>
<xsd:complexType name="orderModifier">
<xsd:sequence>
<xsd:element name="orderingKind" type="orderingKind" minOccurs="0"/>
<xsd:element name="emptyOrderingMode" type="emptyOrderingMode" minOccurs="0"/>
<xsd:element name="collation" type="xsd:string" minOccurs="0"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="orderModifier" type="orderModifier"/>
<xsd:complexType name="orderBySpec">
<xsd:sequence>
<xsd:element name="orderByExpr" type="exprWrapper"/>
<xsd:element ref="orderModifier" minOccurs="0"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="orderBySpec" type="orderBySpec"/>
<xsd:complexType name="orderByClause">
<xsd:sequence>
<xsd:element name="stable" type="emptyContent" minOccurs="0"/>
<xsd:element ref="orderBySpec" maxOccurs="unbounded"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="orderByClause" type="orderByClause"/>
<!-- return clause -->
<xsd:element name="returnClause" type="exprWrapper"/>
<!-- This is the XQuery 1.1 flwor expression -->
<!-- Corresponds to the following XQuery syntax: -->
<!-- 1.1 FLWORExpr ::= (ForClause | LetClause | WindowClause) -->
<!-- (ForClause | LetClause | WindowClause | CountClause | -->
<!-- WhereClause | GroupByClause | OrderByClause)* -->
<!-- ReturnClause -->
<xsd:complexType name="flworExpr">
<xsd:complexContent>
<xsd:extension base="expr">
<xsd:sequence>
<xsd:choice>
<xsd:element ref="forClause"/>
<xsd:element ref="letClause"/>
<xsd:element ref="windowClause"/>
</xsd:choice>
<xsd:sequence>
<xsd:choice minOccurs="0" maxOccurs="unbounded">
<xsd:element ref="forClause"/>
<xsd:element ref="letClause"/>
<xsd:element ref="windowClause"/>
<xsd:element ref="countClause"/>
<xsd:element ref="whereClause"/>
<xsd:element ref="groupByClause"/>
<xsd:element ref="orderByClause"/>
</xsd:choice>
<xsd:element ref="returnClause"/>
</xsd:sequence>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="flworExpr" type="flworExpr" substitutionGroup="expr"/>
<!-- conditional expressions -->
<xsd:complexType name="ifThenElseExpr">
<xsd:complexContent>
<xsd:extension base="expr">
<xsd:sequence>
<xsd:element name="ifClause" type="exprWrapper"/>
<xsd:element name="thenClause" type="exprWrapper"/>
<xsd:element name="elseClause" type="exprWrapper"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="ifThenElseExpr" type="ifThenElseExpr"
substitutionGroup="expr"/>
<!-- The following clauses describe quantified expressions -->
<xsd:simpleType name="quantifier">
<xsd:restriction base="xsd:NMTOKEN">
<xsd:enumeration value="some"/>
<xsd:enumeration value="every"/>
</xsd:restriction>
</xsd:simpleType>
<xsd:complexType name="quantifiedExprInClause">
<xsd:sequence>
<xsd:element ref="typedVariableBinding"/>
<xsd:element name="sourceExpr" type="exprWrapper"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="quantifiedExprInClause" type="quantifiedExprInClause"/>
<xsd:complexType name="quantifiedExpr">
<xsd:complexContent>
<xsd:extension base="expr">
<xsd:sequence>
<xsd:element name="quantifier" type="quantifier"/>
<xsd:element ref="quantifiedExprInClause" maxOccurs="unbounded"/>
<xsd:element name="predicateExpr" type="exprWrapper"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="quantifiedExpr" type="quantifiedExpr"
substitutionGroup="expr"/>
<!-- handle the switch expression -->
<!-- Note: no substitutionGroup as we cannot use this anywhere except within switch -->
<xsd:complexType name="switchExprCaseClause">
<xsd:complexContent>
<xsd:extension base="expr">
<xsd:sequence>
<xsd:element name="switchCaseExpr" type="exprWrapper" maxOccurs="unbounded"/>
<xsd:element name="resultExpr" type="exprWrapper"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="switchExprCaseClause"
type="switchExprCaseClause"/>
<!-- Note: no substitutionGroup as we cannot use this anywhere except within switch -->
<xsd:complexType name="switchExprDefaultClause">
<xsd:complexContent>
<xsd:extension base="expr">
<xsd:sequence>
<xsd:element name="resultExpr" type="exprWrapper"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="switchExprDefaultClause"
type="switchExprDefaultClause"/>
<xsd:complexType name="switchExpr">
<xsd:complexContent>
<xsd:extension base="expr">
<xsd:sequence>
<xsd:element name="argExpr" type="exprWrapper"/>
<xsd:element ref="switchExprCaseClause" maxOccurs="unbounded"/>
<xsd:element ref="switchExprDefaultClause"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="switchExpr" type="switchExpr"
substitutionGroup="expr"/>
<!-- handle the typeswitch expression -->
<!-- Note: no substitutionGroup as we cannot use this anywhere except within typeswitch -->
<xsd:complexType name="typeswitchExprCaseClause">
<xsd:complexContent>
<xsd:extension base="expr">
<xsd:sequence>
<xsd:element ref="variableBinding" minOccurs="0"/>
<xsd:choice>
<xsd:element ref="sequenceType"/>
<xsd:element ref="sequenceTypeUnion"/>
</xsd:choice>
<xsd:element name="resultExpr" type="exprWrapper"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="typeswitchExprCaseClause"
type="typeswitchExprCaseClause"/>
<!-- Note: no substitutionGroup as we cannot use this anywhere except within typeswitch -->
<xsd:complexType name="typeswitchExprDefaultClause">
<xsd:complexContent>
<xsd:extension base="expr">
<xsd:sequence>
<xsd:element ref="variableBinding" minOccurs="0"/>
<xsd:element name="resultExpr" type="exprWrapper"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="typeswitchExprDefaultClause"
type="typeswitchExprDefaultClause"/>
<xsd:complexType name="typeswitchExpr">
<xsd:complexContent>
<xsd:extension base="expr">
<xsd:sequence>
<xsd:element name="argExpr" type="exprWrapper"/>
<xsd:element ref="typeswitchExprCaseClause" maxOccurs="unbounded"/>
<xsd:element ref="typeswitchExprDefaultClause"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="typeswitchExpr" type="typeswitchExpr"
substitutionGroup="expr"/>
<!-- TryCatchExpression -->
<!-- Corresponds to the following XQuery syntax -->
<!-- TryCatchExpression ::= TryClause CatchClause+ -->
<!-- TryClause ::= "{" TryTargetExpr "}" -->
<!-- TryTargetExpr ::= Expr -->
<xsd:complexType name="tryCatchExpr">
<xsd:complexContent>
<xsd:extension base="expr">
<xsd:sequence>
<xsd:element name="tryClause" type="exprWrapper"/>
<xsd:element ref="catchClause" maxOccurs="unbounded" minOccurs="0"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="tryCatchExpr" type="tryCatchExpr"
substitutionGroup="expr"/>
<!-- CatchClause (part of the TryCatchExpression) -->
<!-- Corresponds to the following XQuery syntax -->
<!-- CatchClause ::= "catch" CatchErrorList "{" Expr "}" -->
<xsd:complexType name="catchClause">
<xsd:sequence>
<xsd:element ref="catchErrorList"/>
<xsd:element name="catchExpr" type="exprWrapper" minOccurs="0"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="catchClause" type="catchClause"/>
<!-- CatchErrorList (part of the TryCatchExpression) -->
<!-- Corresponds to the following XQuery syntax -->
<!-- CatchErrorList ::= NameTest ( "|" NameTest )* -->
<!-- (remembering that NameTest is either QName or Wildcard) -->
<xsd:complexType name="catchErrorList">
<xsd:sequence maxOccurs="unbounded">
<xsd:choice>
<xsd:element ref="nameTest"/>
<xsd:element ref="Wildcard"/>
</xsd:choice>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="catchErrorList" type="catchErrorList"/>
<!-- 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"/>
<!-- 2015-02-11/JM Added arrowExpr (replacing arrowPostfix) -->
<!-- 2016-09-23/JS Bug 29823 - remove duplicate integerLiteral and variableRef -->
<!-- Corresponds to XQuery syntax: -->
<!-- ArrowExpr ::= UnaryExpr "=>" ArrowFunctionSpecifier ArgumentList -->
<!-- ArrowFunctionSpecifier ::= EQName | VarRef | ParenthesizedExpression -->
<xsd:complexType name="arrowExpr">
<xsd:complexContent>
<xsd:extension base="expr">
<xsd:sequence>
<xsd:element name="argExpr" type="exprWrapper"/>
<xsd:sequence minOccurs="1" maxOccurs="unbounded">
<xsd:choice>
<xsd:element name="EQName" type="EQName"/>
<xsd:element ref="expr"/>
</xsd:choice>
<xsd:element name="arguments" type="exprOrPlaceholderList" minOccurs="0"/>
</xsd:sequence>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="arrowExpr" type="arrowExpr"
substitutionGroup="expr"/>
<!-- Validate expressions -->
<xsd:simpleType name="validationMode">
<xsd:restriction base="xsd:NMTOKEN">
<xsd:enumeration value="lax"/>
<xsd:enumeration value="strict"/>
</xsd:restriction>
</xsd:simpleType>
<xsd:complexType name="validateExpr">
<xsd:complexContent>
<xsd:extension base="expr">
<xsd:sequence>
<xsd:choice>
<xsd:element name="validationMode" type="validationMode" minOccurs="0"/>
<xsd:element name="typeName" type="EQName" minOccurs="0"/>
</xsd:choice>
<xsd:element name="argExpr" type="exprWrapper"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="validateExpr" type="validateExpr"
substitutionGroup="expr"/>
<!-- Direct constructors. Only elementConstructor for now -->
<!-- Note the absence of constructors corresponding to -->
<!-- the directCommentConstructor and the directPIConstructor -->
<!-- productions in the XQuery grammar. This is because they are -->
<!-- trivially identical to the computed variants -->
<!-- attributeConstructor is no longer a subclass of expr -->
<xsd:complexType name="attributeConstructor">
<xsd:sequence>
<xsd:element name="attributeName" type="QName"/>
<xsd:choice>
<xsd:element name="attributeValueExpr" type="exprList"/>
<xsd:element name="attributeValue" type="xsd:string"/>
</xsd:choice>
</xsd:sequence>
</xsd:complexType>
<xsd:complexType name="namespaceDeclaration">
<xsd:sequence>
<xsd:element name="prefix" type="xsd:NCName" minOccurs="0"/>
<xsd:element name="uri" type="xsd:string"/>
</xsd:sequence>
</xsd:complexType>
<!-- element constructors -->
<xsd:complexType name="attributeList">
<xsd:sequence>
<xsd:choice maxOccurs="unbounded">
<xsd:element name="attributeConstructor" type="attributeConstructor"/>
<xsd:element name="namespaceDeclaration" type="namespaceDeclaration"/>
</xsd:choice>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="attributeList" type="attributeList"/>
<xsd:element name="elementContent" type="exprList"/>
<xsd:complexType name="elementConstructor">
<xsd:complexContent>
<xsd:extension base="expr">
<xsd:sequence>
<xsd:element name="tagName" type="QName"/>
<xsd:element ref="attributeList" minOccurs="0"/>
<xsd:element ref="elementContent" minOccurs="0"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="elementConstructor" type="elementConstructor"
substitutionGroup="expr"/>
<!-- computed constructors -->
<!-- computed element constructor -->
<xsd:complexType name="computedElementConstructor">
<xsd:complexContent>
<xsd:extension base="expr">
<xsd:sequence>
<xsd:choice>
<xsd:element name="tagName" type="EQName"/>
<xsd:element name="tagNameExpr" type="exprWrapper"/>
</xsd:choice>
<xsd:element name="contentExpr" type="exprWrapper" minOccurs="0"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="computedElementConstructor" type="computedElementConstructor"
substitutionGroup="expr"/>
<!-- computed attribute constructor -->
<xsd:complexType name="computedAttributeConstructor">
<xsd:complexContent>
<xsd:extension base="expr">
<xsd:sequence>
<xsd:choice>
<xsd:element name="tagName" type="EQName"/>
<xsd:element name="tagNameExpr" type="exprWrapper"/>
</xsd:choice>
<xsd:element name="valueExpr" type="exprWrapper" minOccurs="0"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="computedAttributeConstructor" type="computedAttributeConstructor"
substitutionGroup="expr"/>
<!-- computed document constructor -->
<xsd:complexType name="computedDocumentConstructor">
<xsd:complexContent>
<xsd:extension base="expr">
<xsd:sequence>
<xsd:element name="argExpr" type="exprWrapper" minOccurs="0"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="computedDocumentConstructor" type="computedDocumentConstructor"
substitutionGroup="expr"/>
<!-- computed text constructor -->
<xsd:complexType name="computedTextConstructor">
<xsd:complexContent>
<xsd:extension base="expr">
<xsd:sequence>
<xsd:element name="argExpr" type="exprWrapper" minOccurs="0"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="computedTextConstructor" type="computedTextConstructor"
substitutionGroup="expr"/>
<!-- computed comment constructor -->
<xsd:complexType name="computedCommentConstructor">
<xsd:complexContent>
<xsd:extension base="expr">
<xsd:sequence>
<xsd:element name="argExpr" type="exprWrapper" minOccurs="0"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="computedCommentConstructor" type="computedCommentConstructor"
substitutionGroup="expr"/>
<!-- computed namespace constructor -->
<xsd:complexType name="computedNamespaceConstructor">
<xsd:complexContent>
<xsd:extension base="expr">
<xsd:sequence>
<xsd:choice>
<xsd:element name="prefix" type="xsd:NCName"/>
<xsd:element name="prefixExpr" type="exprWrapper"/>
</xsd:choice>
<xsd:element name="URIExpr" type="exprWrapper" minOccurs="0"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="computedNamespaceConstructor" type="computedNamespaceConstructor"
substitutionGroup="expr"/>
<!-- computed processing instruction constructor -->
<xsd:complexType name="computedPIConstructor">
<xsd:complexContent>
<xsd:extension base="expr">
<xsd:sequence>
<xsd:choice>
<xsd:element name="piTarget" type="xsd:NCName"/>
<xsd:element name="piTargetExpr" type="exprWrapper"/>
</xsd:choice>
<xsd:element name="piValueExpr" type="exprWrapper" minOccurs="0"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="computedPIConstructor" type="computedPIConstructor"
substitutionGroup="expr"/>
<!-- ordered and unordered expressions -->
<xsd:complexType name="unorderedExpr">
<xsd:complexContent>
<xsd:extension base="expr">
<xsd:sequence>
<xsd:element name="argExpr" type="exprWrapper" minOccurs="0"/>
</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" minOccurs="0"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="orderedExpr" type="orderedExpr" substitutionGroup="expr"/>
<!-- function item expressions -->
<!-- literal function item expression -->
<xsd:complexType name="namedFunctionRef">
<xsd:complexContent>
<xsd:extension base="expr">
<xsd:sequence>
<xsd:element name="functionName" type="EQName"/>
<xsd:element name="integerConstantExpr" type="integerConstantExpr"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="namedFunctionRef" type="namedFunctionRef" substitutionGroup="expr"/>
<!-- inline function item expression -->
<xsd:complexType name="inlineFunctionExpr">
<xsd:complexContent>
<xsd:extension base="expr">
<xsd:sequence>
<xsd:element name="annotation" type="annotation"
minOccurs="0" maxOccurs="unbounded"/>
<xsd:element ref="paramList"/>
<xsd:element ref="typeDeclaration" minOccurs="0"/>
<xsd:element name="functionBody" type="exprWrapper"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="inlineFunctionExpr" type="inlineFunctionExpr" substitutionGroup="expr"/>
<!-- dynamic function invocations -->
<xsd:complexType name="dynamicFunctionInvocationExpr">
<xsd:complexContent>
<xsd:extension base="expr">
<xsd:sequence>
<xsd:element name="functionItem">
<xsd:complexType>
<xsd:sequence>
<xsd:group ref="filterExpr"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<xsd:element name="predicates" type="exprList" minOccurs="0"/>
<xsd:element name="arguments" type="exprOrPlaceholderList" minOccurs="0"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="dynamicFunctionInvocationExpr" type="dynamicFunctionInvocationExpr" substitutionGroup="expr"/>
<!-- 2014-07-13/JM Added mapConstructor -->
<!-- Corresponds to XQuery syntax: -->
<!-- MapConstructor ::= "map" "{" (MapConstructorEntry ("," MapConstructorEntry)*)? "}" -->
<!-- MapConstructorEntry ::= MapKeyExpr ":" MapValueExpr -->
<!-- MapKeyExpr ::= ExprSingle -->
<!-- MapValueExpr ::= ExprSingle -->
<xsd:complexType name="mapConstructor">
<xsd:complexContent>
<xsd:extension base="expr">
<xsd:sequence>
<xsd:element ref="mapConstructorEntry" minOccurs="0" maxOccurs="unbounded"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="mapConstructor" type="mapConstructor" substitutionGroup="expr"/>
<xsd:complexType name="mapConstructorEntry">
<xsd:sequence>
<xsd:element name="mapKeyExpr" type="exprWrapper"/>
<xsd:element name="mapValueExpr" type="exprWrapper"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="mapConstructorEntry" type="mapConstructorEntry"/>
<!-- 2014-07-13/JM Added arrayConstructor -->
<!-- Corresponds to XQuery syntax: -->
<!-- ArrayConstructor ::= SquareArrayConstructor | CurlyArrayConstructor -->
<!-- SquareArrayConstructor ::= "[" (ExprSingle ("," ExprSingle)*)? "]" -->
<!-- CurlyArrayConstructor ::= "array" "{" Expr? "}" -->
<xsd:complexType name="arrayConstructor">
<xsd:complexContent>
<xsd:extension base="expr">
<xsd:choice>
<xsd:element ref="squareArray"/>
<xsd:element ref="curlyArray"/>
</xsd:choice>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="arrayConstructor" type="arrayConstructor" substitutionGroup="expr"/>
<xsd:complexType name="squareArray">
<xsd:sequence minOccurs="0" maxOccurs="unbounded">
<xsd:element name="arrayElem" type="exprWrapper"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="squareArray" type="squareArray"/>
<xsd:complexType name="curlyArray">
<xsd:sequence minOccurs="0" maxOccurs="1">
<xsd:element name="arrayElem" type="exprWrapper"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="curlyArray" type="curlyArray"/>
<!-- 2015-11-05/JS added stringConstructor -->
<xsd:complexType name="stringConstructor">
<xsd:complexContent>
<xsd:extension base="expr">
<xsd:sequence>
<xsd:choice minOccurs="0" maxOccurs="unbounded">
<xsd:element name="stringConstructorChars" type="xsd:string"/>
<xsd:element name="stringConstructorInterpolation" type="exprWrapperOptional"/>
</xsd:choice>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="stringConstructor" type="stringConstructor" substitutionGroup="expr"/>
<!-- wildcards -->
<xsd:complexType name="simpleWildcard">
<xsd:choice>
<xsd:element name="QName" type="EQName"/>
<xsd:element name="star" type="emptyContent"/>
</xsd:choice>
</xsd:complexType>
<!-- Corresponds to the following XQuery syntax: -->
<!-- [44] Wildcard ::= "*" -->
<!-- | (NCName ":" "*") -->
<!-- | ("*" ":" NCName) -->
<!-- | (URILiteral ":" "*") -->
<xsd:complexType name="Wildcard">
<xsd:choice minOccurs="0">
<xsd:sequence>
<xsd:element name="star" type="emptyContent"/>
<xsd:element ref="NCName"/>
</xsd:sequence>
<xsd:sequence>
<xsd:element ref="NCName"/>
<xsd:element name="star" type="emptyContent"/>
</xsd:sequence>
<xsd:sequence>
<xsd:element name="uri" type="xsd:string"/>
<xsd:element name="star" type="emptyContent"/>
</xsd:sequence>
</xsd:choice>
</xsd:complexType>
<xsd:element name="Wildcard" type="Wildcard"/>
<!-- tests (name and/or type) -->
<xsd:element name="schemaAttributeTest" type="EQName"
substitutionGroup="kindTest"/>
<xsd:complexType name="attributeTest">
<xsd:complexContent>
<xsd:extension base="emptyItemTypeContent">
<xsd:sequence minOccurs="0">
<xsd:element name="attributeName" type="simpleWildcard"/>
<xsd:element name="typeName" type="EQName" minOccurs="0"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="attributeTest" type="attributeTest"
substitutionGroup="kindTest"/>
<xsd:element name="anyElementTest" abstract="true"
substitutionGroup="kindTest"/>
<xsd:element name="schemaElementTest" type="EQName"
substitutionGroup="anyElementTest"/>
<xsd:complexType name="elementTest">
<xsd:complexContent>
<xsd:extension base="emptyItemTypeContent">
<xsd:sequence minOccurs="0">
<xsd:element name="elementName" type="simpleWildcard"/>
<xsd:sequence minOccurs="0">
<xsd:element name="typeName" type="EQName"/>
<xsd:element name="nillable" type="emptyContent" minOccurs="0"/>
</xsd:sequence>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="elementTest" type="elementTest"
substitutionGroup="anyElementTest"/>
<xsd:complexType name="documentTest">
<xsd:complexContent>
<xsd:extension base="emptyItemTypeContent">
<xsd:sequence>
<xsd:element ref="anyElementTest" minOccurs="0"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="documentTest" type="documentTest"
substitutionGroup="kindTest"/>
<xsd:complexType name="piTest">
<xsd:complexContent>
<xsd:extension base="emptyItemTypeContent">
<xsd:sequence>
<xsd:element name="piTarget" type="xsd:NCName" minOccurs="0"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="piTest" type="piTest" substitutionGroup="kindTest"/>
<xsd:element name="nameTest" type="EQName"/>
<!-- a kindTest is a kind of itemType -->
<xsd:element name="kindTest" substitutionGroup="itemType"/>
<xsd:element name="textTest" type="emptyItemTypeContent"
substitutionGroup="kindTest"/>
<xsd:element name="commentTest" type="emptyItemTypeContent"
substitutionGroup="kindTest"/>
<xsd:element name="namespaceTest" type="emptyItemTypeContent"
substitutionGroup="kindTest"/>
<xsd:element name="anyKindTest" type="emptyItemTypeContent"
substitutionGroup="kindTest"/>
<!-- functionTest variations -->
<xsd:complexType name="anyFunctionTest">
<xsd:complexContent>
<xsd:extension base="emptyItemTypeContent">
<xsd:sequence>
<xsd:element name="annotation" type="annotation"
minOccurs="0" maxOccurs="unbounded"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<!-- a functionTest is a kind of itemType -->
<xsd:element name="anyFunctionTest" type="anyFunctionTest" substitutionGroup="itemType"/>
<xsd:complexType name="typedFunctionTest">
<xsd:complexContent>
<xsd:extension base="emptyItemTypeContent">
<xsd:sequence>
<xsd:element name="annotation" type="annotation"
minOccurs="0" maxOccurs="unbounded"/>
<xsd:element ref="paramTypeList" minOccurs="0"/>
<xsd:element ref="sequenceType"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="typedFunctionTest" type="typedFunctionTest" substitutionGroup="itemType"/>
<xsd:complexType name="paramTypeList">
<xsd:sequence>
<xsd:element ref="sequenceType" minOccurs="0" maxOccurs="unbounded"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="paramTypeList" type="paramTypeList"/>
<!-- a parenthesizedItemType is a kind of itemType -->
<xsd:complexType name="parenthesizedItemType">
<xsd:complexContent>
<xsd:extension base="emptyItemTypeContent">
<xsd:sequence>
<xsd:element ref="itemType"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="parenthesizedItemType" type="parenthesizedItemType" substitutionGroup="itemType"/>
<!-- 2014-07-13/JM Added anyMapTest and typedMapTest -->
<!-- mapTest variations -->
<!-- a mapTest is a kind of itemType -->
<xsd:element name="anyMapTest" type="emptyItemTypeContent" substitutionGroup="itemType"/>
<xsd:complexType name="typedMapTest">
<xsd:complexContent>
<xsd:extension base="emptyItemTypeContent">
<xsd:sequence>
<xsd:element ref="atomicType"/>
<xsd:element ref="sequenceType"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="typedMapTest" type="typedMapTest" substitutionGroup="itemType"/>
<!-- 2014-07-13/JM Added anyArrayTest and typedArrayTest -->
<!-- arrayTest variations -->
<!-- an arrayTest is a kind of itemType -->
<xsd:element name="anyArrayTest" type="emptyItemTypeContent" substitutionGroup="itemType"/>
<xsd:complexType name="typedArrayTest">
<xsd:complexContent>
<xsd:extension base="emptyItemTypeContent">
<xsd:sequence>
<xsd:element ref="sequenceType"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="typedArrayTest" type="typedArrayTest" substitutionGroup="itemType"/>
<!-- 2016-09-23/JS : Bug 29823 - remove duplicate integerLiteral and variableRef -->
<!-- 2014-07-13/JM Added lookup (formerly mapLookup) -->
<!-- Corresponds to XQuery syntax: -->
<!-- Lookup ::= "?" KeySpecifier -->
<!-- UnaryLookup ::= "?" KeySpecifier -->
<!-- KeySpecifier ::= NCName | IntegerLiteral | ParenthesizedExpr | "*" -->
<xsd:complexType name="lookup">
<xsd:complexContent>
<xsd:extension base="expr">
<xsd:sequence>
<xsd:choice>
<xsd:element ref="NCName"/>
<xsd:element ref="expr"/>
<xsd:element name="star" type="emptyContent"/>
</xsd:choice>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="lookup" type="lookup"/>
<xsd:element name="unaryLookup" type="lookup"
substitutionGroup="expr"/>
<!-- XPath axes -->
<xsd:simpleType name="xpathAxis">
<xsd:restriction base="xsd:NMTOKEN">
<xsd:enumeration value="child"/>
<xsd:enumeration value="attribute"/>
<xsd:enumeration value="self"/>
<xsd:enumeration value="parent"/>
<xsd:enumeration value="descendant-or-self"/>
<xsd:enumeration value="descendant"/>
<xsd:enumeration value="following"/>
<xsd:enumeration value="following-sibling"/>
<xsd:enumeration value="ancestor"/>
<xsd:enumeration value="ancestor-or-self"/>
<xsd:enumeration value="preceding"/>
<xsd:enumeration value="preceding-sibling"/>
</xsd:restriction>
</xsd:simpleType>
<xsd:element name="xpathAxis" type="xpathAxis"/>
<!-- filter expressions -->
<!-- 2014-07-13/JM added mapConstructor, arrayConstructor, and unaryLookup -->
<xsd:group name="filterExpr">
<xsd:choice>
<xsd:element ref="constantExpr"/>
<xsd:element ref="varRef"/>
<xsd:element ref="contextItemExpr"/>
<xsd:element ref="functionCallExpr"/>
<xsd:element ref="sequenceExpr"/>
<xsd:element ref="elementConstructor"/>
<xsd:element ref="computedElementConstructor"/>
<xsd:element ref="computedAttributeConstructor"/>
<xsd:element ref="computedDocumentConstructor"/>
<xsd:element ref="computedTextConstructor"/>
<xsd:element ref="computedCommentConstructor"/>
<xsd:element ref="computedNamespaceConstructor"/>
<xsd:element ref="computedPIConstructor"/>
<xsd:element ref="orderedExpr"/>
<xsd:element ref="unorderedExpr"/>
<xsd:element ref="namedFunctionRef"/>
<xsd:element ref="inlineFunctionExpr"/>
<xsd:element ref="dynamicFunctionInvocationExpr"/>
<xsd:element ref="mapConstructor"/>
<xsd:element ref="arrayConstructor"/>
<xsd:element ref="stringConstructor"/>
<xsd:element ref="unaryLookup"/>
</xsd:choice>
</xsd:group>
<!-- step expression -->
<!-- 2014-07-13/JM Added alts to predicates to support lookup (formerly mapLookup) -->
<xsd:complexType name="stepExpr">
<xsd:sequence>
<xsd:choice>
<xsd:sequence>
<xsd:element ref="xpathAxis"/>
<xsd:choice>
<xsd:element ref="kindTest"/>
<xsd:element ref="nameTest"/>
<xsd:element ref="Wildcard"/>
</xsd:choice>
<xsd:element name="predicates" type="exprList" minOccurs="0"/>
</xsd:sequence>
<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:choice minOccurs="0" maxOccurs="unbounded">
<xsd:element name="predicate">
<xsd:complexType>
<xsd:sequence>
<xsd:element ref="expr"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<xsd:element ref="lookup"/>
</xsd:choice>
</xsd:choice>
</xsd:sequence>
</xsd:choice>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="stepExpr" type="stepExpr"/>
<!-- path expression -->
<xsd:complexType name="pathExpr">
<xsd:complexContent>
<xsd:extension base="expr">
<xsd:choice>
<xsd:sequence>
<xsd:element name="rootExpr" type="emptyContent"/>
<xsd:element ref="stepExpr" minOccurs="0" maxOccurs="unbounded"/>
</xsd:sequence>
<xsd:element ref="stepExpr" maxOccurs="unbounded"/>
</xsd:choice>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="pathExpr" type="pathExpr" substitutionGroup="expr"/>
<!-- The following constructs deal with the query prolog -->
<xsd:complexType name="module">
<xsd:sequence>
<xsd:element ref="versionDecl" minOccurs="0"/>
<xsd:choice>
<xsd:element ref="mainModule"/>
<xsd:element ref="libraryModule"/>
</xsd:choice>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="module" type="module"/>
<xsd:complexType name="mainModule">
<xsd:sequence>
<xsd:element ref="prolog" minOccurs="0"/>
<xsd:element name="queryBody" type="exprWrapper"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="mainModule" type="mainModule"/>
<xsd:complexType name="libraryModule">
<xsd:sequence>
<xsd:element ref="moduleDecl"/>
<xsd:element ref="prolog" minOccurs="0"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="libraryModule" type="libraryModule"/>
<!-- Corrected versionDecl element to require at least one of version or encoding -->
<xsd:complexType name="versionDecl">
<xsd:choice>
<xsd:sequence>
<xsd:element name="version" type="xsd:string"/>
<xsd:element name="encoding" type="xsd:string" minOccurs="0"/>
</xsd:sequence>
<xsd:element name="encoding" type="xsd:string"/>
</xsd:choice>
</xsd:complexType>
<xsd:element name="versionDecl" type="versionDecl"/>
<xsd:complexType name="prolog">
<xsd:sequence>
<xsd:element ref="prologPartOneItem" minOccurs="0" maxOccurs="unbounded"/>
<xsd:element ref="prologPartTwoItem" minOccurs="0" maxOccurs="unbounded"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="prolog" type="prolog"/>
<xsd:element name="prologPartOneItem" abstract="true"/>
<xsd:element name="prologPartTwoItem" abstract="true"/>
<xsd:simpleType name="boundarySpaceDecl">
<xsd:restriction base="xsd:NMTOKEN">
<xsd:enumeration value="strip"/>
<xsd:enumeration value="preserve"/>
</xsd:restriction>
</xsd:simpleType>
<xsd:element name="boundarySpaceDecl" type="boundarySpaceDecl"
substitutionGroup="prologPartOneItem"/>
<xsd:element name="defaultCollationDecl" type="xsd:string"
substitutionGroup="prologPartOneItem"/>
<xsd:element name="baseUriDecl" type="xsd:string"
substitutionGroup="prologPartOneItem"/>
<xsd:simpleType name="constructionDecl">
<xsd:restriction base="xsd:NMTOKEN">
<xsd:enumeration value="strip"/>
<xsd:enumeration value="preserve"/>
</xsd:restriction>
</xsd:simpleType>
<xsd:element name="constructionDecl" type="constructionDecl"
substitutionGroup="prologPartOneItem"/>
<xsd:simpleType name="orderingModeDecl">
<xsd:restriction base="xsd:NMTOKEN">
<xsd:enumeration value="ordered"/>
<xsd:enumeration value="unordered"/>
</xsd:restriction>
</xsd:simpleType>
<xsd:element name="orderingModeDecl" type="orderingModeDecl"
substitutionGroup="prologPartOneItem"/>
<xsd:element name="emptyOrderingDecl" type="emptyOrderingMode"
substitutionGroup="prologPartOneItem"/>
<xsd:complexType name="copyNamespacesDecl">
<xsd:sequence>
<xsd:element name="preserveMode">
<xsd:simpleType>
<xsd:restriction base="xsd:NMTOKEN">
<xsd:enumeration value="preserve"/>
<xsd:enumeration value="no-preserve"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:element>
<xsd:element name="inheritMode">
<xsd:simpleType>
<xsd:restriction base="xsd:NMTOKEN">
<xsd:enumeration value="inherit"/>
<xsd:enumeration value="no-inherit"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:element>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="copyNamespacesDecl" type="copyNamespacesDecl"
substitutionGroup="prologPartOneItem"/>
<xsd:simpleType name="defaultNamespaceCategory">
<xsd:restriction base="xsd:NMTOKEN">
<xsd:enumeration value="function"/>
<xsd:enumeration value="element"/>
</xsd:restriction>
</xsd:simpleType>
<xsd:complexType name="defaultNamespaceDecl">
<xsd:sequence>
<xsd:element name="defaultNamespaceCategory" type="defaultNamespaceCategory"/>
<xsd:element name="uri" type="xsd:string"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="defaultNamespaceDecl" type="defaultNamespaceDecl"
substitutionGroup="prologPartOneItem"/>
<xsd:complexType name="namespaceDeclType">
<xsd:sequence>
<xsd:element name="prefix" type="xsd:NCName"/>
<xsd:element name="uri" type="xsd:string"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="namespaceDecl" type="namespaceDeclType"
substitutionGroup="prologPartOneItem"/>
<xsd:element name="moduleDecl" type="namespaceDeclType"/>
<xsd:complexType name="decimalFormatDeclType">
<xsd:sequence>
<xsd:element name="decimalFormatName" type="EQName" minOccurs="0"/>
<xsd:element name="decimalFormatParam" minOccurs="0" maxOccurs="unbounded">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="decimalFormatParamName">
<xsd:simpleType>
<xsd:restriction base="xsd:NMTOKEN">
<xsd:enumeration value="decimal-separator"/>
<xsd:enumeration value="grouping-separator"/>
<xsd:enumeration value="infinity"/>
<xsd:enumeration value="minus-sign"/>
<xsd:enumeration value="NaN"/>
<xsd:enumeration value="percent"/>
<xsd:enumeration value="per-mille"/>
<xsd:enumeration value="zero-digit"/>
<xsd:enumeration value="digit"/>
<xsd:enumeration value="pattern-separator"/>
<xsd:enumeration value="exponent-separator"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:element>
<xsd:element name="decimalFormatParamValue" type="xsd:string"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="decimalFormatDecl" type="decimalFormatDeclType"
substitutionGroup="prologPartOneItem"/>
<xsd:complexType name="schemaImport">
<xsd:sequence>
<xsd:choice minOccurs="0">
<xsd:element name="namespacePrefix" type="xsd:NCName"/>
<xsd:element name="defaultElementNamespace" type="emptyContent"/>
</xsd:choice>
<xsd:element name="targetNamespace" type="xsd:string"/>
<xsd:element name="targetLocation" type="xsd:string"
minOccurs="0" maxOccurs="unbounded"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="schemaImport" type="schemaImport"
substitutionGroup="prologPartOneItem"/>
<xsd:complexType name="moduleImport">
<xsd:sequence>
<xsd:element name="namespacePrefix" type="xsd:NCName" minOccurs="0"/>
<xsd:element name="targetNamespace" type="xsd:string"/>
<xsd:element name="targetLocation" type="xsd:string"
minOccurs="0" maxOccurs="unbounded"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="moduleImport" type="moduleImport"
substitutionGroup="prologPartOneItem"/>
<xsd:complexType name="contextItemDecl">
<xsd:sequence>
<xsd:element ref="contextItemType" minOccurs="0"/>
<xsd:choice>
<xsd:element name="varValue" type="exprWrapper"/>
<xsd:sequence>
<xsd:element name="external">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="varValue" type="exprWrapper" minOccurs="0"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
</xsd:sequence>
</xsd:choice>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="contextItemDecl" type="contextItemDecl"
substitutionGroup="prologPartTwoItem"/>
<!-- For %-annotations -->
<xsd:complexType name="annotation">
<xsd:sequence>
<xsd:element name="annotationName" type="EQName"/>
<xsd:element name="arguments" type="literalList" minOccurs="0"/>
</xsd:sequence>
</xsd:complexType>
<xsd:complexType name="varDecl">
<xsd:sequence>
<xsd:element name="annotation" type="annotation"
minOccurs="0" maxOccurs="unbounded"/>
<xsd:element name="varName" type="EQName"/>
<xsd:element ref="typeDeclaration" minOccurs="0"/>
<xsd:choice>
<xsd:element name="varValue" type="exprWrapper"/>
<xsd:sequence>
<xsd:element name="external">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="varValue" type="exprWrapper" minOccurs="0"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
</xsd:sequence>
</xsd:choice>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="varDecl" type="varDecl"
substitutionGroup="prologPartTwoItem"/>
<xsd:complexType name="optionDecl">
<xsd:sequence>
<xsd:element name="optionName" type="EQName"/>
<xsd:element name="optionContents" type="xsd:string"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="optionDecl" type="optionDecl"
substitutionGroup="prologPartTwoItem"/>
<!-- function declarations can no longer specify "nondeterministic" or "private" -->
<xsd:complexType name="functionDecl">
<xsd:sequence>
<xsd:element name="annotation" type="annotation"
minOccurs="0" maxOccurs="unbounded"/>
<xsd:element name="functionName" type="EQName"/>
<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 name="functionDecl" type="functionDecl"
substitutionGroup="prologPartTwoItem"/>
<xsd:complexType name="param">
<xsd:sequence>
<xsd:element name="varName" type="EQName"/>
<xsd:element ref="typeDeclaration" minOccurs="0"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="param" type="param"/>
<xsd:complexType name="paramList">
<xsd:sequence>
<xsd:element ref="param" minOccurs="0" maxOccurs="unbounded"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="paramList" type="paramList"/>
</xsd:schema>
ConformanceThis section defines the conformance criteria for an XQueryX processor
(see Figure 1, "Processing Model Overview", in
,
.
In this section, the following terms are used to indicate the
requirement levels defined in .
[Definition: MUST means that the item is an absolute requirement of the specification.]
[Definition: SHOULD means that there may exist valid reasons in particular
circumstances to ignore a particular item, but the full implications
must be understood and carefully weighed before choosing a different course.]
[Definition: MAY means that an item is truly optional.]
An XQueryX processor that claims to conform to this specification MUST
implement the XQueryX syntax as defined in of this
specification and include a claim of Minimal Conformance as defined in
,
.
In addition to a claim of Minimal Conformance, it MAY claim conformance to
one or more optional features defined in
,
.
ReferencesS. Bradner.
Key Words for use in RFCs to Indicate Requirement Levels. IETF RFC 2119.
See http://www.ietf.org/rfc/rfc2119.txt.M. Murata, S. St. Laurent, and D. Kohn.
XML Media Types IETF RFC 3023 or its successors.
See http://www.ietf.org/rfc/rfc3023.txt.Transforming XQueryX to XQueryThe following stylesheet converts from XQueryX syntax to XQuery syntax.
Note the intent of the stylesheet is to produce a valid XQuery with the
same semantics (see ) as the input XQueryX.
<?xml version="1.0"?>
<!-- ================================================================================ -->
<!-- Changes from Recommendation (XQueryX 3.0): -->
<!-- ================================================================================ -->
<!-- Errata applied: -->
<!-- ================================================================================ -->
<!-- Modifications: -->
<!-- JM/2014-07-11 : Added support for anyMapText and typedMapTest -->
<!-- JM/2014-07-11 : Added support for anyArrayText and typedArrayTest -->
<!-- JM/2014-07-13 : Added support for new alternatives in stepExpr -->
<!-- JM/2014-07-13 : Added support for lookup (formerly mapLookup) -->
<!-- JM/2014-07-13 : Added support for unaryLookup (formerly unaryMapLookup) -->
<!-- JM/2014-07-13 : Added support for new alternatives in filterExpr -->
<!-- JM/2014-07-13 : Added support for mapConstructor and arrayConstructor -->
<!-- JM/2014-08-28 : Fixed [unary]Lookup replacing stringLiteral w/integerLiteral -->
<!-- JM/2015-02-11 : Replaced arrowPostfix with arrowExpr per bug 27537 -->
<!-- JS/2015-11-05 : Added support for stringConstructor -->
<!-- JS/2016-01-20 : Added support for unaryLookup per bug 29364 -->
<!-- JS/2016-01-20 : Added xqx:EQName to renderEQName per bug 29365 -->
<!-- JS/2016-09-23 : Bug 29823 - remove duplicate integerLiteral and variableRef -->
<!-- JS/2016-11-01 : Bug 29868 - does not always convert arrowExpr to XQuery -->
<!-- ================================================================================ -->
<xsl:stylesheet version="2.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:xqx="http://www.w3.org/2005/XQueryX">
<!-- Note that this stylesheet frequently invokes templates for
specified elements, even when there are no templates in the
stylesheet whose match="" attribute identifies those elements.
In such case, the default template's element matching template
is invoked, which merely invokes xsl:apply-templates -->
<xsl:output method="text"/>
<xsl:strip-space elements="*"/>
<xsl:preserve-space elements="xqx:value xqx:attributeValue xqx:pragmaContents
xqx:optionContents xqx:xquery xqx:stringConstructorChars"/>
<xsl:variable name="DOT" select="'.'"/>
<xsl:variable name="SPACE" select="' '"/>
<xsl:variable name="SLASH" select="'/'"/>
<xsl:variable name="SLASH_SLASH" select="'//'"/>
<xsl:variable name="LESSTHAN" select="'<'"/>
<xsl:variable name="GREATERTHAN" select="'>'"/>
<xsl:variable name="LPAREN" select="'('"/>
<xsl:variable name="RPAREN" select="')'"/>
<xsl:variable name="NEWLINE"><xsl:text>
</xsl:text></xsl:variable>
<xsl:variable name="COMMA" select="','"/>
<xsl:variable name="COMMA_SPACE" select="', '"/>
<xsl:variable name="COMMA_NEWLINE"><xsl:text>,
</xsl:text></xsl:variable>
<xsl:variable name="QUOTE"><xsl:text>'</xsl:text></xsl:variable>
<xsl:variable name="DOUBLEQUOTE"><xsl:text>"</xsl:text></xsl:variable>
<xsl:variable name="TO" select="' to '"/>
<xsl:variable name="LBRACE" select="'{'"/>
<xsl:variable name="RBRACE" select="'}'"/>
<xsl:variable name="LBRACKET" select="'['"/>
<xsl:variable name="RBRACKET" select="']'"/>
<xsl:variable name="DOLLAR" select="'$'"/>
<xsl:variable name="MINUS" select="'-'"/>
<xsl:variable name="PLUS" select="'+'"/>
<xsl:variable name="EQUAL" select="'='"/>
<xsl:variable name="COLON" select="':'"/>
<xsl:variable name="DOUBLE_COLON" select="'::'"/>
<xsl:variable name="SEMICOLON" select="';'"/>
<xsl:variable name="AT" select="'@'"/>
<xsl:variable name="STAR" select="'*'"/>
<xsl:variable name="QUESTIONMARK" select="'?'"/>
<xsl:variable name="EXCLAMATIONMARK" select="'!'"/>
<xsl:variable name="PERCENT" select="'%'"/>
<xsl:variable name="ASSIGN" select="':='"/>
<xsl:variable name="SEPARATOR" select="';'"/>
<xsl:variable name="PRAGMA_BEGIN" select="'(# '"/>
<xsl:variable name="PRAGMA_END" select="' #)'"/>
<xsl:variable name="CONCATENATE" select="'||'"/>
<xsl:template name="delimitedList">
<xsl:param name="delimiter" />
<xsl:param name="leftEncloser"/>
<xsl:param name="rightEncloser" />
<xsl:param name="selector"/>
<xsl:value-of select="$leftEncloser"/>
<xsl:for-each select="*">
<xsl:apply-templates select="."/>
<xsl:if test="not (position()=last())">
<xsl:value-of select="$delimiter"/>
</xsl:if>
</xsl:for-each>
<xsl:value-of select="$rightEncloser"/>
</xsl:template>
<xsl:template name="parenthesizedList">
<xsl:param name="delimiter" select="$COMMA_SPACE"/>
<xsl:call-template name="delimitedList">
<xsl:with-param name="delimiter" select="$delimiter" />
<xsl:with-param name="leftEncloser" select="$LPAREN"/>
<xsl:with-param name="rightEncloser" select="$RPAREN"/>
</xsl:call-template>
</xsl:template>
<xsl:template name="commaSeparatedList">
<xsl:call-template name="delimitedList">
<xsl:with-param name="delimiter">
<xsl:value-of select="$COMMA_SPACE"/>
</xsl:with-param>
</xsl:call-template>
</xsl:template>
<xsl:template name="quote">
<xsl:param name="item"/>
<xsl:value-of select="$DOUBLEQUOTE"/>
<xsl:call-template name="globalReplace">
<xsl:with-param name="stringToBeFixed">
<xsl:call-template name="globalReplace">
<xsl:with-param name="stringToBeFixed">
<xsl:call-template name="globalReplace">
<xsl:with-param name="stringToBeFixed">
<xsl:call-template name="globalReplace">
<xsl:with-param name="stringToBeFixed">
<xsl:call-template name="globalReplace">
<xsl:with-param name="stringToBeFixed">
<xsl:call-template name="globalReplace">
<xsl:with-param name="stringToBeFixed">
<xsl:value-of select="$item"/>
</xsl:with-param>
<xsl:with-param name="toBeReplaced">&</xsl:with-param>
<xsl:with-param name="replacement">&amp;</xsl:with-param>
</xsl:call-template>
</xsl:with-param>
<xsl:with-param name="toBeReplaced"><</xsl:with-param>
<xsl:with-param name="replacement">&lt;</xsl:with-param>
</xsl:call-template>
</xsl:with-param>
<xsl:with-param name="toBeReplaced" select="'…'"/>
<xsl:with-param name="replacement">&#x85;</xsl:with-param>
</xsl:call-template>
</xsl:with-param>
<xsl:with-param name="toBeReplaced" select="'
'"/>
<xsl:with-param name="replacement">&#xD;</xsl:with-param>
</xsl:call-template>
</xsl:with-param>
<xsl:with-param name="toBeReplaced" select="'
'"/>
<xsl:with-param name="replacement">&#x2028;</xsl:with-param>
</xsl:call-template>
</xsl:with-param>
<xsl:with-param name="toBeReplaced"><xsl:text>"</xsl:text></xsl:with-param>
<xsl:with-param name="replacement"><xsl:text>""</xsl:text></xsl:with-param>
</xsl:call-template>
<xsl:value-of select="$DOUBLEQUOTE"/>
</xsl:template>
<xsl:template name="globalReplace">
<xsl:param name="stringToBeFixed"/>
<xsl:param name="toBeReplaced"/>
<xsl:param name="replacement"/>
<xsl:choose>
<xsl:when test="contains($stringToBeFixed, $toBeReplaced)">
<xsl:value-of select="concat(substring-before($stringToBeFixed, $toBeReplaced), $replacement)"/>
<xsl:call-template name="globalReplace">
<xsl:with-param name="stringToBeFixed" select="substring-after($stringToBeFixed, $toBeReplaced)"/>
<xsl:with-param name="toBeReplaced" select="$toBeReplaced"/>
<xsl:with-param name="replacement" select="$replacement"/>
</xsl:call-template>
</xsl:when>
<xsl:otherwise>
<xsl:value-of select="$stringToBeFixed"/>
</xsl:otherwise>
</xsl:choose>
</xsl:template>
<xsl:template name="renderQName">
<xsl:if test="@xqx:prefix">
<xsl:value-of select="@xqx:prefix"/>
<xsl:value-of select="$COLON"/>
</xsl:if>
<xsl:value-of select="."/>
</xsl:template>
<xsl:template name="renderEQName"
match="xqx:QName | xqx:EQName | xqx:pragmaName | xqx:typeName | xqx:varName |
xqx:functionName | xqx:optionName | xqx:annotationName |
xqx:atomicType | xqx:tagName | xqx:name | xqx:decimalFormatName">
<xsl:choose>
<xsl:when test="xqx:tagName/parent::xqx:elementConstructor">
<xsl:call-template name="renderQName"/>
</xsl:when>
<xsl:otherwise>
<xsl:choose>
<xsl:when test="@xqx:prefix and @xqx:URI">
<xsl:message terminate="yes">Incorrect XQueryX: Elements of type xqx:EQName must not have both 'prefix' and 'URI' attributes</xsl:message>
</xsl:when>
<xsl:when test="@xqx:prefix">
<xsl:value-of select="@xqx:prefix"/>
<xsl:value-of select="$COLON"/>
<xsl:value-of select="."/>
</xsl:when>
<xsl:when test="@xqx:URI">
<xsl:text>Q</xsl:text>
<xsl:value-of select="$LBRACE"/>
<xsl:value-of select="@xqx:URI"/>
<xsl:value-of select="$RBRACE"/>
<xsl:value-of select="."/>
</xsl:when>
<xsl:otherwise>
<xsl:value-of select="."/>
</xsl:otherwise>
</xsl:choose>
</xsl:otherwise>
</xsl:choose>
</xsl:template>
<xsl:template match="xqx:attributeName">
<xsl:choose>
<xsl:when test="@xqx:prefix='xmlns'">
<xsl:message terminate="yes">Incorrect XQueryX: Attribute names are not permitted to have prefix 'xmlns'; use xqx:namespaceDeclaration to declare namespaces</xsl:message>
</xsl:when>
<xsl:when test=". = 'xmlns'">
<xsl:message terminate="yes">Incorrect XQueryX: Attribute names are not permitted to be 'xmlns'; use xqx:namespaceDeclaration to declare namespaces</xsl:message>
</xsl:when>
<xsl:otherwise>
<xsl:call-template name="renderQName"/>
</xsl:otherwise>
</xsl:choose>
</xsl:template>
<xsl:template match="xqx:NCName">
<xsl:value-of select="."/>
</xsl:template>
<xsl:template match="xqx:rootExpr">
<xsl:value-of select="$SLASH"/>
</xsl:template>
<xsl:template match="xqx:argumentPlaceholder">
<xsl:value-of select="$QUESTIONMARK"/>
</xsl:template>
<xsl:template match="xqx:pathExpr/xqx:rootExpr">
<xsl:if test="not(following-sibling::xqx:stepExpr)">
<xsl:value-of select="$LPAREN"/>
</xsl:if>
<xsl:value-of select="$SPACE"/>
<xsl:value-of select="$SLASH"/>
<xsl:value-of select="$SPACE"/>
<xsl:if test="not(following-sibling::xqx:stepExpr)">
<xsl:value-of select="$RPAREN"/>
</xsl:if>
</xsl:template>
<xsl:template match="xqx:contextItemExpr">
<xsl:value-of select="$DOT"/>
</xsl:template>
<xsl:template match="xqx:stringConstantExpr | xqx:stringLiteral">
<xsl:call-template name="quote">
<xsl:with-param name="item" select="xqx:value"/>
</xsl:call-template>
</xsl:template>
<!-- 2016-09-23/JS Bug 29823 - Removed integerLiteral -->
<!-- 2014-08-28/JM Added integerLiteral for use in lookup (formerly mapLookup) -->
<xsl:template match="xqx:integerConstantExpr |
xqx:decimalConstantExpr |
xqx:doubleConstantExpr">
<xsl:value-of select="xqx:value"/>
</xsl:template>
<!-- 2016-09-23/JS Bug 29823 - Removed variableRef -->
<!-- 2014-07-13/JM Added variiableRef for use in arrowExpr -->
<xsl:template match="xqx:varRef">
<xsl:value-of select="$DOLLAR"/>
<xsl:apply-templates select="xqx:name"/>
</xsl:template>
<xsl:template match="xqx:pragma">
<xsl:value-of select="$PRAGMA_BEGIN"/>
<xsl:apply-templates select="xqx:pragmaName"/>
<xsl:value-of select="$SPACE"/>
<xsl:value-of select="xqx:pragmaContents"/>
<xsl:value-of select="$PRAGMA_END"/>
</xsl:template>
<xsl:template match="xqx:extensionExpr">
<xsl:apply-templates select="xqx:pragma"/>
<xsl:value-of select="$LBRACE"/>
<xsl:apply-templates select="xqx:argExpr"/>
<xsl:value-of select="$RBRACE"/>
</xsl:template>
<xsl:template match="xqx:simpleMapExpr">
<xsl:value-of select="$LPAREN"/>
<xsl:value-of select="$SPACE"/>
<xsl:apply-templates select="xqx:pathExpr[1]"/>
<xsl:value-of select="$SPACE"/>
<xsl:value-of select="$RPAREN"/>
<xsl:for-each select="xqx:pathExpr[position() != 1]">
<xsl:value-of select="$NEWLINE"/>
<xsl:value-of select="$EXCLAMATIONMARK"/>
<xsl:value-of select="$SPACE"/>
<xsl:value-of select="$LPAREN"/>
<xsl:value-of select="$SPACE"/>
<xsl:apply-templates select="."/>
<xsl:value-of select="$SPACE"/>
<xsl:value-of select="$RPAREN"/>
</xsl:for-each>
</xsl:template>
<xsl:template match="xqx:functionCallExpr">
<xsl:if test="(xqx:functionName = 'node' or
xqx:functionName = 'document-node' or
xqx:functionName = 'element' or
xqx:functionName = 'attribute' or
xqx:functionName = 'schema-element' or
xqx:functionName = 'schema-attribute' or
xqx:functionName = 'processing-instruction' or
xqx:functionName = 'comment' or
xqx:functionName = 'text' or
xqx:functionName = 'function' or
xqx:functionName = 'namespace-node' or
xqx:functionName = 'item' or
xqx:functionName = 'if' or
xqx:functionName = 'switch' or
xqx:functionName = 'typeswitch' or
xqx:functionName = 'empty-sequence') and
((not(xqx:functionName/@xqx:prefix) and not(xqx:functionName/@xqx:URI)) or
xqx:functionName/@xqx:prefix = '' or
xqx:functionName/@xqx:URI = '')">
<xsl:variable name="message"><xsl:text>Incorrect XQueryX: function calls must not use unqualified "reserved" name "</xsl:text><xsl:value-of select="xqx:functionName"/><xsl:text>"</xsl:text></xsl:variable>
<xsl:message terminate="yes"><xsl:value-of select="$message"/></xsl:message>
</xsl:if>
<xsl:apply-templates select="xqx:functionName"/>
<xsl:choose>
<xsl:when test="xqx:arguments">
<xsl:for-each select="xqx:arguments">
<xsl:call-template name="parenthesizedList"/>
</xsl:for-each>
</xsl:when>
<xsl:otherwise>
<xsl:value-of select="$LPAREN"/>
<xsl:value-of select="$RPAREN"/>
</xsl:otherwise>
</xsl:choose>
</xsl:template>
<xsl:template match="xqx:constructorFunctionExpr">
<xsl:apply-templates select="xqx:typeName"/>
<xsl:for-each select="xqx:argExpr">
<xsl:call-template name="parenthesizedList"/>
</xsl:for-each>
</xsl:template>
<xsl:template match="xqx:unaryMinusOp | xqx:unaryPlusOp">
<xsl:value-of select="$LPAREN"/>
<xsl:choose>
<xsl:when test="self::xqx:unaryPlusOp"><xsl:value-of select="$PLUS"/></xsl:when>
<xsl:when test="self::xqx:unaryMinusOp"><xsl:value-of select="$MINUS"/></xsl:when>
</xsl:choose>
<xsl:apply-templates select="xqx:operand"/>
<xsl:value-of select="$RPAREN"/>
</xsl:template>
<xsl:template match="xqx:addOp | xqx:subtractOp | xqx:multiplyOp
| xqx:divOp | xqx:idivOp | xqx:modOp">
<xsl:value-of select="$LPAREN"/>
<xsl:apply-templates select="xqx:firstOperand"/>
<xsl:choose>
<xsl:when test="self::xqx:addOp"><xsl:value-of select="$PLUS"/></xsl:when>
<xsl:when test="self::xqx:subtractOp"><xsl:text> </xsl:text><xsl:value-of select="$MINUS"/><xsl:text> </xsl:text></xsl:when>
<xsl:when test="self::xqx:multiplyOp"><xsl:value-of select="$STAR"/></xsl:when>
<xsl:when test="self::xqx:divOp"><xsl:text> div </xsl:text></xsl:when>
<xsl:when test="self::xqx:idivOp"><xsl:text> idiv </xsl:text></xsl:when>
<xsl:when test="self::xqx:modOp"><xsl:text> mod </xsl:text></xsl:when>
</xsl:choose>
<xsl:apply-templates select="xqx:secondOperand"/>
<xsl:value-of select="$RPAREN"/>
</xsl:template>
<xsl:template match="xqx:stringConcatenateOp">
<xsl:value-of select="$LPAREN"/>
<xsl:apply-templates select="xqx:firstOperand"/>
<xsl:value-of select="$CONCATENATE"/>
<xsl:apply-templates select="xqx:secondOperand"/>
<xsl:value-of select="$RPAREN"/>
</xsl:template>
<xsl:template match="xqx:eqOp | xqx:neOp | xqx:ltOp
| xqx:gtOp | xqx:leOp | xqx:geOp">
<xsl:value-of select="$LPAREN"/>
<xsl:apply-templates select="xqx:firstOperand"/>
<xsl:choose>
<xsl:when test="self::xqx:eqOp"><xsl:text> eq </xsl:text></xsl:when>
<xsl:when test="self::xqx:neOp"><xsl:text> ne </xsl:text></xsl:when>
<xsl:when test="self::xqx:ltOp"><xsl:text> lt </xsl:text></xsl:when>
<xsl:when test="self::xqx:gtOp"><xsl:text> gt </xsl:text></xsl:when>
<xsl:when test="self::xqx:leOp"><xsl:text> le </xsl:text></xsl:when>
<xsl:when test="self::xqx:geOp"><xsl:text> ge </xsl:text></xsl:when>
</xsl:choose>
<xsl:apply-templates select="xqx:secondOperand"/>
<xsl:value-of select="$RPAREN"/>
</xsl:template>
<xsl:template match="xqx:equalOp | xqx:notEqualOp | xqx:lessThanOp
| xqx:greaterThanOp | xqx:lessThanOrEqualOp | xqx:greaterThanOrEqualOp">
<xsl:value-of select="$LPAREN"/>
<xsl:apply-templates select="xqx:firstOperand"/>
<xsl:choose>
<xsl:when test="self::xqx:equalOp">
<xsl:text> </xsl:text><xsl:value-of select="$EQUAL"/><xsl:text> </xsl:text>
</xsl:when>
<xsl:when test="self::xqx:notEqualOp">
<xsl:text> !</xsl:text><xsl:value-of select="$EQUAL"/><xsl:text> </xsl:text>
</xsl:when>
<xsl:when test="self::xqx:lessThanOp">
<xsl:text> </xsl:text><xsl:value-of select="$LESSTHAN"/><xsl:text> </xsl:text>
</xsl:when>
<xsl:when test="self::xqx:greaterThanOp">
<xsl:text> </xsl:text><xsl:value-of select="$GREATERTHAN"/><xsl:text> </xsl:text>
</xsl:when>
<xsl:when test="self::xqx:lessThanOrEqualOp">
<xsl:text> </xsl:text><xsl:value-of select="$LESSTHAN"/>
<xsl:value-of select="$EQUAL"/><xsl:text> </xsl:text>
</xsl:when>
<xsl:when test="self::xqx:greaterThanOrEqualOp">
<xsl:text> </xsl:text><xsl:value-of select="$GREATERTHAN"/>
<xsl:value-of select="$EQUAL"/><xsl:text> </xsl:text>
</xsl:when>
</xsl:choose>
<xsl:apply-templates select="xqx:secondOperand"/>
<xsl:value-of select="$RPAREN"/>
</xsl:template>
<xsl:template match="xqx:isOp | xqx:nodeBeforeOp | xqx:nodeAfterOp">
<xsl:value-of select="$LPAREN"/>
<xsl:apply-templates select="xqx:firstOperand"/>
<xsl:choose>
<xsl:when test="self::xqx:isOp"><xsl:text> is </xsl:text></xsl:when>
<xsl:when test="self::xqx:nodeBeforeOp"><xsl:text> </xsl:text>
<xsl:value-of select="$LESSTHAN"/><xsl:value-of select="$LESSTHAN"/>
<xsl:text> </xsl:text></xsl:when>
<xsl:when test="self::xqx:nodeAfterOp"><xsl:text> </xsl:text>
<xsl:value-of select="$GREATERTHAN"/><xsl:value-of select="$GREATERTHAN"/>
<xsl:text> </xsl:text></xsl:when>
</xsl:choose>
<xsl:apply-templates select="xqx:secondOperand"/>
<xsl:value-of select="$RPAREN"/>
</xsl:template>
<xsl:template match="xqx:andOp | xqx:orOp">
<xsl:value-of select="$LPAREN"/>
<xsl:apply-templates select="xqx:firstOperand"/>
<xsl:choose>
<xsl:when test="self::xqx:andOp"><xsl:text> and </xsl:text></xsl:when>
<xsl:when test="self::xqx:orOp"><xsl:text> or </xsl:text></xsl:when>
</xsl:choose>
<xsl:apply-templates select="xqx:secondOperand"/>
<xsl:value-of select="$RPAREN"/>
</xsl:template>
<xsl:template match="xqx:unionOp | xqx:intersectOp | xqx:exceptOp">
<xsl:value-of select="$LPAREN"/>
<xsl:apply-templates select="xqx:firstOperand"/>
<xsl:choose>
<xsl:when test="self::xqx:unionOp"><xsl:text> union </xsl:text></xsl:when>
<xsl:when test="self::xqx:intersectOp"><xsl:text> intersect </xsl:text></xsl:when>
<xsl:when test="self::xqx:exceptOp"><xsl:text> except </xsl:text></xsl:when>
</xsl:choose>
<xsl:apply-templates select="xqx:secondOperand"/>
<xsl:value-of select="$RPAREN"/>
</xsl:template>
<xsl:template match="xqx:sequenceExpr">
<xsl:for-each select=".">
<xsl:call-template name="parenthesizedList">
<xsl:with-param name="delimiter" select="$COMMA_NEWLINE"/>
</xsl:call-template>
</xsl:for-each>
</xsl:template>
<xsl:template match="xqx:rangeSequenceExpr">
<xsl:value-of select="$LPAREN"/>
<xsl:apply-templates select="xqx:startExpr"/>
<xsl:value-of select="$TO"/>
<xsl:apply-templates select="xqx:endExpr"/>
<xsl:value-of select="$RPAREN"/>
</xsl:template>
<xsl:template match="xqx:forClause">
<xsl:text> for </xsl:text>
<xsl:call-template name="commaSeparatedList"/>
<xsl:value-of select="$NEWLINE"/>
</xsl:template>
<xsl:template match="xqx:forClauseItem">
<xsl:apply-templates/>
</xsl:template>
<xsl:template match="xqx:allowingEmpty">
<xsl:text> allowing empty </xsl:text>
</xsl:template>
<xsl:template match="xqx:forExpr">
<xsl:value-of select="$NEWLINE"/>
<xsl:text> in </xsl:text>
<xsl:apply-templates/>
</xsl:template>
<xsl:template match="xqx:letClause">
<xsl:text> let </xsl:text>
<xsl:call-template name="commaSeparatedList"/>
<xsl:value-of select="$NEWLINE"/>
</xsl:template>
<xsl:template match="xqx:letClauseItem">
<xsl:apply-templates/>
</xsl:template>
<xsl:template match="xqx:letExpr">
<xsl:value-of select="$SPACE"/>
<xsl:value-of select="$ASSIGN"/>
<xsl:value-of select="$SPACE"/>
<xsl:apply-templates/>
</xsl:template>
<xsl:template match="xqx:windowClause">
<xsl:text> for </xsl:text>
<xsl:apply-templates/>
<xsl:value-of select="$NEWLINE"/>
</xsl:template>
<xsl:template match="xqx:tumblingWindowClause">
<xsl:text> tumbling window </xsl:text>
<xsl:apply-templates select="xqx:typedVariableBinding"/>
<xsl:text> in </xsl:text>
<xsl:apply-templates select="xqx:bindingSequence"/>
<xsl:value-of select="$NEWLINE"/>
<xsl:text> </xsl:text>
<xsl:apply-templates select="xqx:windowStartCondition"/>
<xsl:value-of select="$NEWLINE"/>
<xsl:text> </xsl:text>
<xsl:apply-templates select="xqx:windowEndCondition"/>
</xsl:template>
<xsl:template match="xqx:slidingWindowClause">
<xsl:text> sliding window </xsl:text>
<xsl:apply-templates select="xqx:typedVariableBinding"/>
<xsl:text> in </xsl:text>
<xsl:apply-templates select="xqx:bindingSequence"/>
<xsl:value-of select="$NEWLINE"/>
<xsl:text> </xsl:text>
<xsl:apply-templates select="xqx:windowStartCondition"/>
<xsl:value-of select="$NEWLINE"/>
<xsl:text> </xsl:text>
<xsl:apply-templates select="xqx:windowEndCondition"/>
</xsl:template>
<xsl:template match="xqx:bindingSequence">
<xsl:apply-templates/>
</xsl:template>
<xsl:template match="xqx:windowStartCondition">
<xsl:text>start </xsl:text>
<xsl:apply-templates select="xqx:windowVars"/>
<xsl:text> when </xsl:text>
<xsl:apply-templates select="xqx:winStartExpr"/>
</xsl:template>
<xsl:template match="xqx:windowEndCondition">
<xsl:if test="@xqx:onlyEnd='true'">
<xsl:text>only </xsl:text>
</xsl:if>
<xsl:text>end </xsl:text>
<xsl:apply-templates select="xqx:windowVars"/>
<xsl:text> when </xsl:text>
<xsl:apply-templates select="xqx:winEndExpr"/>
</xsl:template>
<xsl:template match="xqx:windowVars">
<xsl:apply-templates select="xqx:currentItem"/>
<xsl:apply-templates select="xqx:positionalVariableBinding"/>
<xsl:apply-templates select="xqx:previousItem"/>
<xsl:apply-templates select="xqx:nextItem"/>
</xsl:template>
<xsl:template match="xqx:currentItem">
<xsl:value-of select="$DOLLAR"/>
<xsl:call-template name="renderEQName"/>
</xsl:template>
<xsl:template match="xqx:previousItem">
<xsl:text> previous </xsl:text>
<xsl:value-of select="$DOLLAR"/>
<xsl:call-template name="renderEQName"/>
</xsl:template>
<xsl:template match="xqx:nextItem">
<xsl:text> next </xsl:text>
<xsl:value-of select="$DOLLAR"/>
<xsl:call-template name="renderEQName"/>
</xsl:template>
<xsl:template match="xqx:countClause">
<xsl:text> count </xsl:text>
<xsl:apply-templates/>
<xsl:value-of select="$NEWLINE"/>
</xsl:template>
<xsl:template match="xqx:whereClause">
<xsl:text> where </xsl:text>
<xsl:apply-templates select="*"/>
<xsl:value-of select="$NEWLINE"/>
</xsl:template>
<xsl:template match="xqx:groupByClause">
<xsl:text> group by </xsl:text>
<xsl:call-template name="commaSeparatedList"/>
<xsl:value-of select="$NEWLINE"/>
</xsl:template>
<xsl:template match="xqx:groupingSpec">
<xsl:value-of select="$DOLLAR"/>
<xsl:apply-templates/>
</xsl:template>
<xsl:template match="xqx:groupVarInitialize">
<xsl:if test="xqx:typeDeclaration">
<xsl:apply-templates select="xqx:typeDeclaration"/>
</xsl:if>
<xsl:value-of select="$SPACE"/>
<xsl:value-of select="$ASSIGN"/>
<xsl:value-of select="$SPACE"/>
<xsl:apply-templates select="xqx:varValue"/>
</xsl:template>
<xsl:template match="xqx:collation">
<xsl:text> collation </xsl:text>
<xsl:call-template name="quote">
<xsl:with-param name="item">
<xsl:value-of select="."/>
</xsl:with-param>
</xsl:call-template>
</xsl:template>
<xsl:template match="xqx:emptyOrderingMode">
<xsl:value-of select="$SPACE"/>
<xsl:value-of select="."/>
</xsl:template>
<xsl:template match="xqx:orderingKind">
<xsl:value-of select="$SPACE"/>
<xsl:value-of select="."/>
</xsl:template>
<xsl:template match="xqx:orderModifier">
<xsl:apply-templates select="*"/>
</xsl:template>
<xsl:template match="xqx:orderBySpec">
<xsl:apply-templates select="xqx:orderByExpr"/>
<xsl:value-of select="$SPACE"/>
<xsl:apply-templates select="xqx:orderModifier"/>
</xsl:template>
<xsl:template match="xqx:orderByClause">
<xsl:if test="xqx:stable">
<xsl:text> stable</xsl:text>
</xsl:if>
<xsl:text> order by </xsl:text>
<xsl:apply-templates select="xqx:orderBySpec[1]"/>
<xsl:for-each select="xqx:orderBySpec[position() > 1]">
<xsl:value-of select="$COMMA_SPACE"/>
<xsl:apply-templates select="."/>
</xsl:for-each>
<xsl:value-of select="$NEWLINE"/>
</xsl:template>
<xsl:template match="xqx:returnClause">
<xsl:text> return </xsl:text>
<xsl:apply-templates select="*"/>
<xsl:value-of select="$NEWLINE"/>
</xsl:template>
<!-- Surrounding FLWOR expressions with parentheses completes the set -->
<xsl:template match="xqx:flworExpr">
<xsl:value-of select="$NEWLINE"/>
<xsl:value-of select="$LPAREN"/>
<xsl:apply-templates select="*"/>
<xsl:value-of select="$RPAREN"/>
</xsl:template>
<xsl:template match="xqx:ifThenElseExpr">
<xsl:value-of select="$LPAREN"/>
<xsl:text> if </xsl:text>
<xsl:value-of select="$LPAREN"/>
<xsl:apply-templates select="xqx:ifClause"/>
<xsl:value-of select="$RPAREN"/>
<xsl:text> then </xsl:text>
<xsl:apply-templates select="xqx:thenClause"/>
<xsl:text> else </xsl:text>
<xsl:apply-templates select="xqx:elseClause"/>
<xsl:value-of select="$RPAREN"/>
</xsl:template>
<xsl:template match="xqx:positionalVariableBinding">
<xsl:text> at </xsl:text>
<xsl:value-of select="$DOLLAR"/>
<xsl:call-template name="renderEQName"/>
</xsl:template>
<xsl:template match="xqx:variableBinding">
<xsl:value-of select="$DOLLAR"/>
<xsl:call-template name="renderEQName"/>
<xsl:if test="parent::xqx:typeswitchExprCaseClause">
<xsl:text> as </xsl:text>
</xsl:if>
</xsl:template>
<xsl:template match="xqx:typedVariableBinding" name="typedVariableBinding">
<xsl:value-of select="$DOLLAR"/>
<xsl:apply-templates select="xqx:varName"/>
<xsl:apply-templates select="xqx:typeDeclaration"/>
</xsl:template>
<xsl:template match="xqx:quantifiedExprInClause">
<xsl:apply-templates select="xqx:typedVariableBinding"/>
<xsl:text> in </xsl:text>
<xsl:apply-templates select="xqx:sourceExpr"/>
</xsl:template>
<xsl:template match="xqx:quantifiedExpr">
<xsl:value-of select="$LPAREN"/>
<xsl:value-of select="xqx:quantifier"/>
<xsl:value-of select="$SPACE"/>
<xsl:apply-templates select="xqx:quantifiedExprInClause[1]"/>
<xsl:for-each select="xqx:quantifiedExprInClause[position() > 1]">
<xsl:value-of select="$COMMA_SPACE"/>
<xsl:apply-templates select="."/>
</xsl:for-each>
<xsl:text> satisfies </xsl:text>
<xsl:apply-templates select="xqx:predicateExpr"/>
<xsl:value-of select="$RPAREN"/>
</xsl:template>
<xsl:template match="xqx:instanceOfExpr">
<xsl:value-of select="$LPAREN"/>
<xsl:apply-templates select="xqx:argExpr"/>
<xsl:text> instance of </xsl:text>
<xsl:apply-templates select="xqx:sequenceType"/>
<xsl:value-of select="$RPAREN"/>
</xsl:template>
<xsl:template match="xqx:castExpr">
<xsl:value-of select="$LPAREN"/>
<xsl:apply-templates select="xqx:argExpr"/>
<xsl:text> cast as </xsl:text>
<xsl:apply-templates select="xqx:singleType"/>
<xsl:value-of select="$RPAREN"/>
</xsl:template>
<!-- 2015-02-11/JM For new expr arrowExpr -->
<!-- 2016-11-01/JS does not always convert arrowExpr to XQuery correctly -->
<xsl:template match="xqx:arrowExpr">
<xsl:value-of select="$LPAREN"/>
<xsl:value-of select="$SPACE"/>
<xsl:apply-templates select="xqx:argExpr"/>
<xsl:for-each select="*[not(self::xqx:argExpr) and not(self::xqx:arguments)]">
<xsl:text> => </xsl:text>
<xsl:choose>
<xsl:when test="self::xqx:EQName or self::xqx:variableRef">
<xsl:apply-templates select="."/>
</xsl:when>
<xsl:otherwise>
<xsl:value-of select="$LPAREN"/>
<xsl:apply-templates select="."/>
<xsl:value-of select="$RPAREN"/>
</xsl:otherwise>
</xsl:choose>
<xsl:choose>
<xsl:when test="following-sibling::*[1][self::xqx:arguments]">
<xsl:for-each select="following-sibling::*[1][self::xqx:arguments]">
<xsl:call-template name="parenthesizedList"/>
</xsl:for-each>
</xsl:when>
<xsl:otherwise>
<xsl:value-of select="$LPAREN"/>
<xsl:value-of select="$RPAREN"/>
</xsl:otherwise>
</xsl:choose>
</xsl:for-each>
<xsl:value-of select="$SPACE"/>
<xsl:value-of select="$RPAREN"/>
</xsl:template>
<xsl:template match="xqx:castableExpr">
<xsl:value-of select="$LPAREN"/>
<xsl:apply-templates select="xqx:argExpr"/>
<xsl:text> castable as </xsl:text>
<xsl:apply-templates select="xqx:singleType"/>
<xsl:value-of select="$RPAREN"/>
</xsl:template>
<xsl:template match="xqx:treatExpr">
<xsl:value-of select="$LPAREN"/>
<xsl:apply-templates select="xqx:argExpr"/>
<xsl:text> treat as </xsl:text>
<xsl:apply-templates select="xqx:sequenceType"/>
<xsl:value-of select="$RPAREN"/>
</xsl:template>
<xsl:template match="xqx:switchExprCaseClause">
<xsl:for-each select="xqx:switchCaseExpr">
<xsl:value-of select="$NEWLINE"/>
<xsl:text> case (</xsl:text>
<xsl:apply-templates select="."/>
<xsl:text>) </xsl:text>
</xsl:for-each>
<xsl:value-of select="$NEWLINE"/>
<xsl:text> return </xsl:text>
<xsl:apply-templates select="xqx:resultExpr"/>
</xsl:template>
<xsl:template match="xqx:switchExprDefaultClause">
<xsl:value-of select="$NEWLINE"/>
<xsl:text> default return </xsl:text>
<xsl:apply-templates select="xqx:resultExpr"/>
</xsl:template>
<xsl:template match="xqx:switchExpr">
<xsl:value-of select="$LPAREN"/>
<xsl:text>switch</xsl:text>
<xsl:value-of select="$LPAREN"/>
<xsl:apply-templates select="xqx:argExpr"/>
<xsl:value-of select="$RPAREN"/>
<xsl:apply-templates select="xqx:switchExprCaseClause"/>
<xsl:apply-templates select="xqx:switchExprDefaultClause"/>
<xsl:value-of select="$RPAREN"/>
</xsl:template>
<xsl:template match="xqx:typeswitchExprCaseClause">
<xsl:text> case </xsl:text>
<xsl:apply-templates select="xqx:variableBinding"/>
<xsl:apply-templates select="xqx:sequenceType | xqx:sequenceTypeUnion"/>
<xsl:text> return </xsl:text>
<xsl:apply-templates select="xqx:resultExpr"/>
</xsl:template>
<xsl:template match="xqx:typeswitchExprDefaultClause">
<xsl:text> default </xsl:text>
<xsl:apply-templates select="xqx:variableBinding"/>
<xsl:text> return </xsl:text>
<xsl:apply-templates select="xqx:resultExpr"/>
</xsl:template>
<xsl:template match="xqx:typeswitchExpr">
<xsl:value-of select="$LPAREN"/>
<xsl:text>typeswitch</xsl:text>
<xsl:value-of select="$LPAREN"/>
<xsl:apply-templates select="xqx:argExpr"/>
<xsl:value-of select="$RPAREN"/>
<xsl:apply-templates select="xqx:typeswitchExprCaseClause"/>
<xsl:apply-templates select="xqx:typeswitchExprDefaultClause"/>
<xsl:value-of select="$RPAREN"/>
</xsl:template>
<xsl:template match="xqx:tryCatchExpr">
<xsl:value-of select="$NEWLINE"/>
<xsl:value-of select="$LPAREN"/>
<xsl:text>try </xsl:text>
<xsl:apply-templates select="xqx:tryClause"/>
<xsl:apply-templates select="xqx:catchClause"/>
<xsl:value-of select="$RPAREN"/>
</xsl:template>
<xsl:template match="xqx:tryClause">
<xsl:value-of select="$LBRACE"/>
<xsl:value-of select="$SPACE"/>
<xsl:apply-templates/>
<xsl:value-of select="$SPACE"/>
<xsl:value-of select="$RBRACE"/>
</xsl:template>
<xsl:template match="xqx:catchClause">
<xsl:value-of select="$NEWLINE"/>
<xsl:text> catch </xsl:text>
<xsl:apply-templates select="xqx:catchErrorList"/>
<xsl:apply-templates select="xqx:catchExpr"/>
</xsl:template>
<xsl:template match="xqx:catchErrorList">
<xsl:for-each select="xqx:nameTest | xqx:Wildcard">
<xsl:if test="(position() mod 5) = 0">
<xsl:value-of select="$NEWLINE"/>
<xsl:text> </xsl:text>
</xsl:if>
<xsl:if test="position() > 1">
<xsl:text>| </xsl:text>
</xsl:if>
<xsl:apply-templates select="."/>
<xsl:value-of select="$SPACE"/>
</xsl:for-each>
</xsl:template>
<xsl:template match="xqx:catchExpr">
<xsl:value-of select="$NEWLINE"/>
<xsl:value-of select="$LBRACE"/>
<xsl:value-of select="$SPACE"/>
<xsl:apply-templates/>
<xsl:value-of select="$SPACE"/>
<xsl:value-of select="$RBRACE"/>
</xsl:template>
<xsl:template match="xqx:validateExpr">
<xsl:value-of select="$LPAREN"/>
<xsl:text> validate </xsl:text>
<xsl:if test="xqx:validationMode">
<xsl:value-of select="xqx:validationMode"/>
<xsl:value-of select="$SPACE"/>
</xsl:if>
<xsl:if test="xqx:typeName">
<xsl:text>type </xsl:text>
<xsl:apply-templates select="xqx:typeName"/>
<xsl:value-of select="$SPACE"/>
</xsl:if>
<xsl:value-of select="$LBRACE"/>
<xsl:apply-templates select="xqx:argExpr"/>
<xsl:value-of select="$SPACE"/>
<xsl:value-of select="$RBRACE"/>
<xsl:value-of select="$SPACE"/>
<xsl:value-of select="$RPAREN"/>
</xsl:template>
<xsl:template match="xqx:xpathAxis">
<xsl:value-of select="."/>
<xsl:value-of select="$DOUBLE_COLON"/>
</xsl:template>
<xsl:template match="xqx:predicates">
<xsl:for-each select="*">
<xsl:value-of select="$LBRACKET"/>
<xsl:apply-templates select="."/>
<xsl:value-of select="$RBRACKET"/>
</xsl:for-each>
</xsl:template>
<!-- 2014-07-13/JM Used in revised stepExpr to support new alternatives lookup (formerly mapLookup) -->
<xsl:template match="xqx:predicate">
<xsl:value-of select="$LBRACKET"/>
<xsl:apply-templates/>
<xsl:value-of select="$RBRACKET"/>
</xsl:template>
<!-- part of higher-order functions -->
<xsl:template match="xqx:dynamicFunctionInvocationExpr">
<xsl:apply-templates select="xqx:functionItem"/>
<xsl:apply-templates select="xqx:predicates"/>
<xsl:choose>
<xsl:when test="xqx:arguments">
<xsl:for-each select="xqx:arguments">
<xsl:call-template name="parenthesizedList"/>
</xsl:for-each>
</xsl:when>
<xsl:otherwise>
<xsl:value-of select="$LPAREN"/>
<xsl:value-of select="$RPAREN"/>
</xsl:otherwise>
</xsl:choose>
</xsl:template>
<!-- part of higher-order functions -->
<xsl:template match="xqx:functionItem">
<xsl:apply-templates/>
</xsl:template>
<!-- 2014-07-13/JM Added mapConstructor -->
<xsl:template match="xqx:mapConstructor">
<xsl:text>map { </xsl:text>
<xsl:apply-templates select="xqx:mapConstructorEntry[1]"/>
<xsl:if test="xqx:mapConstructorEntry[2]">
<xsl:for-each select="xqx:mapConstructorEntry[position() > 1]">
<xsl:text> , </xsl:text>
<xsl:apply-templates select="."/>
</xsl:for-each>
</xsl:if>
<xsl:text> } </xsl:text>
</xsl:template>
<!-- 2014-07-13/JM Added mapConstructorEntry -->
<xsl:template match="xqx:mapConstructorEntry">
<xsl:apply-templates select="*[1]"/>
<xsl:text> : </xsl:text>
<xsl:apply-templates select="*[2]"/>
</xsl:template>
<!-- 2014-07-13/JM Added arrayConstructor -->
<xsl:template match="xqx:arrayConstructor">
<xsl:apply-templates/>
</xsl:template>
<!-- 2014-07-13/JM Added squareArray -->
<xsl:template match="xqx:squareArray">
<xsl:text> [ </xsl:text>
<xsl:apply-templates select="xqx:arrayElem[1]"/>
<xsl:if test="xqx:arrayElem[2]">
<xsl:for-each select="xqx:arrayElem[position() > 1]">
<xsl:text> , </xsl:text>
<xsl:apply-templates select="."/>
</xsl:for-each>
</xsl:if>
<xsl:text> ] </xsl:text>
</xsl:template>
<!-- 2014-07-13/JM Added curlyArray -->
<xsl:template match="xqx:curlyArray">
<xsl:text> array { </xsl:text>
<xsl:apply-templates/>
<xsl:text> } </xsl:text>
</xsl:template>
<!-- 2015-11-05/JS Added stringConstructor -->
<xsl:template match="xqx:stringConstructor">
<xsl:text>``[</xsl:text>
<xsl:apply-templates/>
<xsl:text>]``</xsl:text>
</xsl:template>
<!-- 2015-11-05/JS Added stringConstructorInterpolation -->
<xsl:template match="xqx:stringConstructorInterpolation">
<xsl:text>`{</xsl:text>
<xsl:apply-templates/>
<xsl:text>}`</xsl:text>
</xsl:template>
<!-- 2015-11-05/JS Added stringConstructorChars -->
<xsl:template match="xqx:stringConstructorChars">
<xsl:value-of select="."/>
</xsl:template>
<xsl:template match="xqx:star">
<xsl:value-of select="$STAR"/>
</xsl:template>
<xsl:template match="xqx:Wildcard[*]">
<xsl:choose>
<xsl:when test="local-name(./child::*[1])='star'">
<xsl:apply-templates select="xqx:star"/>
<xsl:value-of select="$COLON"/>
<xsl:apply-templates select="xqx:NCName"/>
</xsl:when>
<xsl:when test="local-name(./child::*[1])='NCName'">
<xsl:apply-templates select="xqx:NCName"/>
<xsl:value-of select="$COLON"/>
<xsl:apply-templates select="xqx:star"/>
</xsl:when>
<xsl:when test="local-name(./child::*[1])='uri'">
<xsl:text>Q</xsl:text>
<xsl:value-of select="$LBRACE"/>
<xsl:value-of select="./xqx:uri"/>
<xsl:value-of select="$RBRACE"/>
<xsl:apply-templates select="xqx:star"/>
</xsl:when>
</xsl:choose>
</xsl:template>
<xsl:template match="xqx:Wildcard[not(*)]">
<xsl:value-of select="$STAR"/>
</xsl:template>
<xsl:template name="simpleWildcard" match="xqx:simpleWildcard">
<xsl:apply-templates select="xqx:star"/>
<xsl:apply-templates select="xqx:QName"/>
</xsl:template>
<xsl:template match="xqx:textTest">
<xsl:text>text()</xsl:text>
</xsl:template>
<xsl:template match="xqx:commentTest">
<xsl:text>comment()</xsl:text>
</xsl:template>
<xsl:template match="xqx:namespaceTest">
<xsl:text>namespace-node()</xsl:text>
</xsl:template>
<xsl:template match="xqx:anyKindTest">
<xsl:text>node()</xsl:text>
</xsl:template>
<xsl:template match="xqx:piTest">
<xsl:text>processing-instruction</xsl:text>
<xsl:value-of select="$LPAREN"/>
<xsl:value-of select="*"/>
<xsl:value-of select="$RPAREN"/>
</xsl:template>
<xsl:template match="xqx:documentTest">
<xsl:text>document-node</xsl:text>
<xsl:value-of select="$LPAREN"/>
<xsl:apply-templates select="*"/>
<xsl:value-of select="$RPAREN"/>
</xsl:template>
<xsl:template match="xqx:nameTest">
<xsl:call-template name="renderEQName"/>
</xsl:template>
<xsl:template match="xqx:attributeTest">
<xsl:text>attribute</xsl:text>
<xsl:value-of select="$LPAREN"/>
<xsl:for-each select="xqx:attributeName">
<xsl:call-template name="simpleWildcard"/>
</xsl:for-each>
<xsl:if test="xqx:typeName">
<xsl:value-of select="$COMMA"/>
<xsl:apply-templates select="xqx:typeName"/>
</xsl:if>
<xsl:value-of select="$RPAREN"/>
</xsl:template>
<xsl:template match="xqx:elementTest">
<xsl:text>element</xsl:text>
<xsl:value-of select="$LPAREN"/>
<xsl:for-each select="xqx:elementName">
<xsl:call-template name="simpleWildcard"/>
</xsl:for-each>
<xsl:if test="xqx:typeName">
<xsl:value-of select="$COMMA"/>
<xsl:apply-templates select="xqx:typeName"/>
</xsl:if>
<xsl:if test="xqx:nillable">
<xsl:value-of select="$QUESTIONMARK"/>
</xsl:if>
<xsl:value-of select="$RPAREN"/>
</xsl:template>
<xsl:template match="xqx:schemaElementTest">
<xsl:text>schema-element</xsl:text>
<xsl:value-of select="$LPAREN"/>
<xsl:call-template name="renderEQName"/>
<xsl:value-of select="$RPAREN"/>
</xsl:template>
<xsl:template match="xqx:schemaAttributeTest">
<xsl:text>schema-attribute</xsl:text>
<xsl:value-of select="$LPAREN"/>
<xsl:call-template name="renderEQName"/>
<xsl:value-of select="$RPAREN"/>
</xsl:template>
<!-- anyFunctionTest, part of higher-order functions -->
<xsl:template match="xqx:anyFunctionTest">
<xsl:apply-templates select="xqx:annotation"/>
<xsl:text> function(*)</xsl:text>
</xsl:template>
<!-- typedFunctionTest, part of higher-order functions -->
<xsl:template match="xqx:typedFunctionTest">
<xsl:apply-templates select="xqx:annotation"/>
<xsl:text> function</xsl:text>
<xsl:apply-templates select="xqx:paramTypeList"/>
<xsl:text> as </xsl:text>
<xsl:apply-templates select="xqx:sequenceType"/>
</xsl:template>
<xsl:template match="xqx:paramTypeList">
<xsl:call-template name="parenthesizedList"/>
</xsl:template>
<!-- 2014-07-11/JM For new MapTest -->
<xsl:template match="xqx:anyMapTest">
<xsl:text> map(*)</xsl:text>
</xsl:template>
<!-- 2014-07-11/JM For new MapTest -->
<xsl:template match="xqx:typedMapTest">
<xsl:text> map(</xsl:text>
<xsl:apply-templates select="xqx:atomicType"/>
<xsl:text>, </xsl:text>
<xsl:apply-templates select="xqx:sequenceType"/>
<xsl:text>) </xsl:text>
</xsl:template>
<!-- 2014-07-13/JM For new stepExpr alternative lookup (formerly mapLookup) -->
<!-- 2016-01-20/JS Add support for unaryLookup (bug 29364) -->
<!-- 2016-09-23/JS Bug 29823 - Renamed integerLiteral to integerConstantExpr -->
<xsl:template match="xqx:lookup | xqx:unaryLookup">
<xsl:text> ?</xsl:text>
<xsl:choose>
<xsl:when test="xqx:star | xqx:NCName | xqx:integerConstantExpr">
<xsl:apply-templates/>
</xsl:when>
<xsl:otherwise>
<xsl:value-of select="$LPAREN"/>
<xsl:apply-templates/>
<xsl:value-of select="$RPAREN"/>
</xsl:otherwise>
</xsl:choose>
</xsl:template>
<!-- 2014-07-11/JM For new ArrayTest -->
<xsl:template match="xqx:anyArrayTest">
<xsl:text> array(*)</xsl:text>
</xsl:template>
<!-- 2014-07-11/JM For new ArrayTest -->
<xsl:template match="xqx:typedArrayTest">
<xsl:text> array(</xsl:text>
<xsl:apply-templates select="xqx:sequenceType"/>
<xsl:text>) </xsl:text>
</xsl:template>
<!-- parenthesizedItemType, part of higher-order functions -->
<xsl:template match="xqx:parenthesizedItemType">
<xsl:text> ( </xsl:text>
<xsl:apply-templates/>
<xsl:text> ) </xsl:text>
</xsl:template>
<xsl:template match="xqx:stepExpr">
<xsl:if test="preceding-sibling::xqx:stepExpr">
<xsl:value-of select="$SLASH"/>
</xsl:if>
<xsl:apply-templates select="*"/>
</xsl:template>
<xsl:template match="xqx:filterExpr">
<xsl:apply-templates/>
</xsl:template>
<!-- part of higher-order functions -->
<xsl:template match="xqx:namedFunctionRef">
<xsl:if test="(xqx:functionName = 'node' or
xqx:functionName = 'document-node' or
xqx:functionName = 'element' or
xqx:functionName = 'attribute' or
xqx:functionName = 'schema-element' or
xqx:functionName = 'schema-attribute' or
xqx:functionName = 'processing-instruction' or
xqx:functionName = 'comment' or
xqx:functionName = 'text' or
xqx:functionName = 'function' or
xqx:functionName = 'namespace-node' or
xqx:functionName = 'item' or
xqx:functionName = 'if' or
xqx:functionName = 'switch' or
xqx:functionName = 'typeswitch' or
xqx:functionName = 'empty-sequence') and
((not(@xqx:prefix) and not(@xqx:URI)) or
(@xqx:prefix and @xqx:prefix = '') or
(@xqx:URI and @xqx:URI = ''))">
<xsl:variable name="message"><xsl:text>Incorrect XQueryX: function calls must not use unqualified "reserved" name "</xsl:text><xsl:value-of select="xqx:functionName"/><xsl:text>"</xsl:text></xsl:variable>
<xsl:message terminate="yes"><xsl:value-of select="$message"/></xsl:message>
</xsl:if>
<xsl:apply-templates select="xqx:functionName"/>
<xsl:text>#</xsl:text>
<xsl:apply-templates select="xqx:integerConstantExpr"/>
</xsl:template>
<!-- part of higher-order functions -->
<xsl:template match="xqx:inlineFunctionExpr">
<xsl:apply-templates select="xqx:annotation"/>
<xsl:text> function </xsl:text>
<xsl:apply-templates select="xqx:paramList"/>
<xsl:apply-templates select="xqx:typeDeclaration"/>
<xsl:apply-templates select="xqx:functionBody"/>
</xsl:template>
<xsl:template match="xqx:pathExpr">
<xsl:apply-templates select="xqx:rootExpr | xqx:stepExpr"/>
</xsl:template>
<xsl:template match="xqx:attributeConstructor">
<xsl:value-of select="$SPACE"/>
<xsl:apply-templates select="xqx:attributeName"/>
<xsl:value-of select="$EQUAL"/>
<xsl:choose>
<xsl:when test="xqx:attributeValue">
<xsl:call-template name="globalReplace">
<xsl:with-param name="stringToBeFixed">
<xsl:call-template name="globalReplace">
<xsl:with-param name="stringToBeFixed">
<xsl:call-template name="quote">
<xsl:with-param name="item">
<xsl:call-template name="globalReplace">
<xsl:with-param name="stringToBeFixed">
<xsl:call-template name="globalReplace">
<xsl:with-param name="stringToBeFixed">
<xsl:value-of select="xqx:attributeValue"/>
</xsl:with-param>
<xsl:with-param name="toBeReplaced"><xsl:text>{</xsl:text></xsl:with-param>
<xsl:with-param name="replacement"><xsl:text>{{</xsl:text></xsl:with-param>
</xsl:call-template>
</xsl:with-param>
<xsl:with-param name="toBeReplaced"><xsl:text>}</xsl:text></xsl:with-param>
<xsl:with-param name="replacement"><xsl:text>}}</xsl:text></xsl:with-param>
</xsl:call-template>
</xsl:with-param>
</xsl:call-template>
</xsl:with-param>
<xsl:with-param name="toBeReplaced" select="'
'"/>
<xsl:with-param name="replacement">&#xA;</xsl:with-param>
</xsl:call-template>
</xsl:with-param>
<xsl:with-param name="toBeReplaced" select="'	'"/>
<xsl:with-param name="replacement">&#x9;</xsl:with-param>
</xsl:call-template>
</xsl:when>
<xsl:otherwise>
<xsl:value-of select="$DOUBLEQUOTE"/>
<xsl:for-each select="./xqx:attributeValueExpr/xqx:*">
<xsl:value-of select="$LBRACE"/>
<xsl:apply-templates select="."/>
<xsl:value-of select="$RBRACE"/>
</xsl:for-each>
<xsl:value-of select="$DOUBLEQUOTE"/>
</xsl:otherwise>
</xsl:choose>
</xsl:template>
<xsl:template match="xqx:namespaceDeclaration">
<xsl:text> xmlns</xsl:text>
<xsl:if test="xqx:prefix">
<xsl:text>:</xsl:text>
<xsl:value-of select="xqx:prefix"/>
</xsl:if>
<xsl:value-of select="$EQUAL"/>
<xsl:call-template name="quote">
<xsl:with-param name="item">
<xsl:call-template name="globalReplace">
<xsl:with-param name="stringToBeFixed">
<xsl:call-template name="globalReplace">
<xsl:with-param name="stringToBeFixed">
<xsl:value-of select="xqx:uri"/>
</xsl:with-param>
<xsl:with-param name="toBeReplaced">
<xsl:text>{</xsl:text>
</xsl:with-param>
<xsl:with-param name="replacement">
<xsl:text>{{</xsl:text>
</xsl:with-param>
</xsl:call-template>
</xsl:with-param>
<xsl:with-param name="toBeReplaced">
<xsl:text>}</xsl:text>
</xsl:with-param>
<xsl:with-param name="replacement">
<xsl:text>}}</xsl:text>
</xsl:with-param>
</xsl:call-template>
</xsl:with-param>
</xsl:call-template>
</xsl:template>
<xsl:template match="xqx:attributeList">
<xsl:apply-templates select="*"/>
</xsl:template>
<xsl:template match="xqx:elementContent">
<xsl:for-each select="*">
<xsl:if test="not(self::xqx:elementConstructor)">
<xsl:value-of select="$SPACE"/>
<xsl:value-of select="$LBRACE"/>
</xsl:if>
<xsl:apply-templates select="."/>
<xsl:if test="not(self::xqx:elementConstructor)">
<xsl:value-of select="$SPACE"/>
<xsl:value-of select="$RBRACE"/>
</xsl:if>
</xsl:for-each>
</xsl:template>
<xsl:template match="xqx:elementConstructor">
<xsl:value-of select="$LESSTHAN"/>
<xsl:apply-templates select="xqx:tagName"/>
<xsl:apply-templates select="xqx:attributeList"/>
<xsl:value-of select="$GREATERTHAN"/>
<xsl:apply-templates select="xqx:elementContent"/>
<xsl:value-of select="$LESSTHAN"/>
<xsl:value-of select="$SLASH"/>
<xsl:apply-templates select="xqx:tagName"/>
<xsl:value-of select="$GREATERTHAN"/>
</xsl:template>
<xsl:template match="xqx:tagNameExpr">
<xsl:value-of select="$LBRACE"/>
<xsl:apply-templates select="*"/>
<xsl:value-of select="$RBRACE"/>
</xsl:template>
<xsl:template match="xqx:computedElementConstructor">
<xsl:text> element </xsl:text>
<xsl:apply-templates select="xqx:tagName"/>
<xsl:apply-templates select="xqx:tagNameExpr"/>
<xsl:value-of select="$SPACE"/>
<xsl:value-of select="$LBRACE"/>
<xsl:value-of select="$SPACE"/>
<xsl:apply-templates select="xqx:contentExpr"/>
<xsl:value-of select="$SPACE"/>
<xsl:value-of select="$RBRACE"/>
</xsl:template>
<xsl:template match="xqx:contentExpr">
<xsl:apply-templates/>
</xsl:template>
<xsl:template match="xqx:computedAttributeConstructor">
<xsl:text> attribute </xsl:text>
<xsl:apply-templates select="xqx:tagName"/>
<xsl:apply-templates select="xqx:tagNameExpr"/>
<xsl:value-of select="$SPACE"/>
<xsl:value-of select="$LBRACE"/>
<xsl:apply-templates select="xqx:valueExpr"/>
<xsl:value-of select="$SPACE"/>
<xsl:value-of select="$RBRACE"/>
</xsl:template>
<xsl:template match="xqx:computedDocumentConstructor">
<xsl:text> document {</xsl:text>
<xsl:apply-templates select="*"/>
<xsl:text> }</xsl:text>
</xsl:template>
<xsl:template match="xqx:computedTextConstructor">
<xsl:text> text</xsl:text>
<xsl:value-of select="$SPACE"/>
<xsl:value-of select="$LBRACE"/>
<xsl:apply-templates select="*"/>
<xsl:value-of select="$SPACE"/>
<xsl:value-of select="$RBRACE"/>
</xsl:template>
<xsl:template match="xqx:computedCommentConstructor">
<xsl:text> comment</xsl:text>
<xsl:value-of select="$LBRACE"/>
<xsl:apply-templates select="*"/>
<xsl:value-of select="$RBRACE"/>
</xsl:template>
<xsl:template match="xqx:computedNamespaceConstructor">
<xsl:text> namespace </xsl:text>
<xsl:choose>
<xsl:when test="xqx:prefix">
<xsl:value-of select="xqx:prefix"/>
</xsl:when>
<xsl:otherwise>
<xsl:value-of select="$LBRACE"/>
<xsl:apply-templates select="xqx:prefixExpr"/>
<xsl:value-of select="$RBRACE"/>
</xsl:otherwise>
</xsl:choose>
<xsl:value-of select="$SPACE"/>
<xsl:value-of select="$LBRACE"/>
<xsl:apply-templates select="xqx:URIExpr"/>
<xsl:value-of select="$RBRACE"/>
</xsl:template>
<xsl:template match="xqx:piTargetExpr">
<xsl:value-of select="$LBRACE"/>
<xsl:apply-templates select="*"/>
<xsl:value-of select="$RBRACE"/>
</xsl:template>
<xsl:template match="xqx:piValueExpr">
<xsl:apply-templates select="*"/>
</xsl:template>
<xsl:template match="xqx:computedPIConstructor">
<xsl:text> processing-instruction </xsl:text>
<xsl:value-of select="xqx:piTarget"/>
<xsl:apply-templates select="xqx:piTargetExpr"/>
<xsl:value-of select="$LBRACE"/>
<xsl:apply-templates select="xqx:piValueExpr"/>
<xsl:value-of select="$RBRACE"/>
</xsl:template>
<xsl:template match="xqx:unorderedExpr">
<xsl:text> unordered</xsl:text>
<xsl:value-of select="$LBRACE"/>
<xsl:text> </xsl:text>
<xsl:apply-templates select="*"/>
<xsl:text> </xsl:text>
<xsl:value-of select="$RBRACE"/>
</xsl:template>
<xsl:template match="xqx:orderedExpr">
<xsl:text> ordered</xsl:text>
<xsl:value-of select="$LBRACE"/>
<xsl:text> </xsl:text>
<xsl:apply-templates select="*"/>
<xsl:text> </xsl:text>
<xsl:value-of select="$RBRACE"/>
</xsl:template>
<xsl:template match="xqx:versionDecl">
<xsl:text>xquery </xsl:text>
<xsl:if test="xqx:version">
<xsl:text>version </xsl:text>
<xsl:call-template name="quote">
<xsl:with-param name="item" select="xqx:version"/>
</xsl:call-template>
</xsl:if>
<xsl:if test="xqx:encoding and xqx:version">
<xsl:value-of select="$SPACE"/>
</xsl:if>
<xsl:if test="xqx:encoding">
<xsl:text>encoding </xsl:text>
<xsl:call-template name="quote">
<xsl:with-param name="item" select="xqx:encoding"/>
</xsl:call-template>
</xsl:if>
<xsl:value-of select="$SEPARATOR"/>
<xsl:value-of select="$NEWLINE"/>
</xsl:template>
<xsl:template match="xqx:namespaceDecl">
<xsl:text>declare namespace </xsl:text>
<xsl:value-of select="xqx:prefix"/>
<xsl:value-of select="$EQUAL"/>
<xsl:call-template name="quote">
<xsl:with-param name="item" select="xqx:uri"/>
</xsl:call-template>
</xsl:template>
<xsl:template match="xqx:defaultNamespaceDecl">
<xsl:text>declare default </xsl:text>
<xsl:value-of select="xqx:defaultNamespaceCategory"/>
<xsl:text> namespace </xsl:text>
<xsl:call-template name="quote">
<xsl:with-param name="item" select="xqx:uri"/>
</xsl:call-template>
</xsl:template>
<xsl:template match="xqx:boundarySpaceDecl">
<xsl:text>declare boundary-space </xsl:text>
<xsl:value-of select="."/>
</xsl:template>
<xsl:template match="xqx:defaultCollationDecl">
<xsl:text>declare default collation </xsl:text>
<xsl:call-template name="quote">
<xsl:with-param name="item" select="."/>
</xsl:call-template>
</xsl:template>
<xsl:template match="xqx:baseUriDecl">
<xsl:text>declare base-uri </xsl:text>
<xsl:call-template name="quote">
<xsl:with-param name="item" select="."/>
</xsl:call-template>
</xsl:template>
<xsl:template match="xqx:constructionDecl">
<xsl:text>declare construction </xsl:text>
<xsl:value-of select="."/>
</xsl:template>
<xsl:template match="xqx:orderingModeDecl">
<xsl:text>declare ordering </xsl:text>
<xsl:value-of select="."/>
</xsl:template>
<xsl:template match="xqx:emptyOrderingDecl">
<xsl:text>declare default order </xsl:text>
<xsl:value-of select="."/>
</xsl:template>
<xsl:template match="xqx:copyNamespacesDecl">
<xsl:text>declare copy-namespaces </xsl:text>
<xsl:value-of select="xqx:preserveMode"/>
<xsl:value-of select="$COMMA"/>
<xsl:value-of select="xqx:inheritMode"/>
</xsl:template>
<xsl:template match="xqx:optionDecl">
<xsl:text>declare option </xsl:text>
<xsl:apply-templates select="xqx:optionName"/>
<xsl:value-of select="$SPACE"/>
<xsl:call-template name="quote">
<xsl:with-param name="item" select="xqx:optionContents"/>
</xsl:call-template>
</xsl:template>
<xsl:template match="xqx:decimalFormatDecl">
<xsl:text>declare </xsl:text>
<xsl:if test="not(xqx:decimalFormatName)">
<xsl:text>default </xsl:text>
</xsl:if>
<xsl:text>decimal-format </xsl:text>
<xsl:if test="xqx:decimalFormatName">
<xsl:apply-templates select="xqx:decimalFormatName"/>
<xsl:text> </xsl:text>
</xsl:if>
<xsl:apply-templates select="xqx:decimalFormatParam"/>
</xsl:template>
<xsl:template match="xqx:decimalFormatParam">
<xsl:value-of select="xqx:decimalFormatParamName"/>
<xsl:text> = </xsl:text>
<xsl:call-template name="quote">
<xsl:with-param name="item" select="xqx:decimalFormatParamValue"/>
</xsl:call-template>
<xsl:text> </xsl:text>
</xsl:template>
<xsl:template match="xqx:voidSequenceType">
<xsl:text>empty-sequence()</xsl:text>
</xsl:template>
<xsl:template match="xqx:occurrenceIndicator">
<xsl:value-of select="."/>
</xsl:template>
<xsl:template match="xqx:anyItemType">
<xsl:text>item()</xsl:text>
</xsl:template>
<xsl:template match="xqx:sequenceType">
<xsl:apply-templates select="*"/>
</xsl:template>
<xsl:template match="xqx:sequenceTypeUnion">
<xsl:apply-templates select="xqx:sequenceType[1]"/>
<xsl:if test="count(xqx:sequenceType) > 1">
<xsl:for-each select="xqx:sequenceType[position() > 1]">
<xsl:text> | </xsl:text>
<xsl:apply-templates select="."/>
</xsl:for-each>
</xsl:if>
</xsl:template>
<xsl:template match="xqx:singleType">
<xsl:apply-templates select="xqx:atomicType"/>
<xsl:if test="xqx:optional">
<xsl:text>?</xsl:text>
</xsl:if>
</xsl:template>
<xsl:template match="xqx:typeDeclaration">
<xsl:text> as </xsl:text>
<xsl:apply-templates select="*"/>
</xsl:template>
<!-- contextItemDecl shouldn't have sequenceType, but itemType -->
<xsl:template match="xqx:contextItemType">
<xsl:text> as </xsl:text>
<xsl:apply-templates select="*"/>
</xsl:template>
<!-- contextItemDecl shouldn't have sequenceType, but itemType -->
<xsl:template match="xqx:contextItemDecl">
<xsl:text>declare context item </xsl:text>
<xsl:apply-templates select="xqx:contextItemType"/>
<xsl:if test="xqx:varValue">
<xsl:value-of select="$SPACE"/>
<xsl:value-of select="$ASSIGN"/>
<xsl:value-of select="$SPACE"/>
<xsl:apply-templates select="xqx:varValue"/>
</xsl:if>
<xsl:if test="xqx:external">
<xsl:text> external </xsl:text>
<xsl:if test="xqx:external/xqx:varValue">
<xsl:text>:= </xsl:text>
<xsl:apply-templates select="xqx:external/xqx:varValue"/>
</xsl:if>
</xsl:if>
</xsl:template>
<xsl:template match="xqx:annotation">
<xsl:value-of select="$SPACE"/>
<xsl:value-of select="$PERCENT"/>
<xsl:apply-templates select="xqx:annotationName"/>
<xsl:if test="xqx:arguments">
<xsl:for-each select="xqx:arguments">
<xsl:call-template name="parenthesizedList"/>
</xsl:for-each>
</xsl:if>
</xsl:template>
<xsl:template match="xqx:varDecl">
<xsl:text>declare</xsl:text>
<xsl:apply-templates select="xqx:annotation"/>
<xsl:text> variable </xsl:text>
<xsl:value-of select="$DOLLAR"/>
<xsl:apply-templates select="xqx:varName"/>
<xsl:apply-templates select="xqx:typeDeclaration"/>
<xsl:if test="xqx:varValue">
<xsl:value-of select="$ASSIGN"/>
<xsl:apply-templates select="xqx:varValue"/>
</xsl:if>
<xsl:if test="xqx:external">
<xsl:text> external </xsl:text>
<xsl:if test="xqx:external/xqx:varValue">
<xsl:text>:= </xsl:text>
<xsl:apply-templates select="xqx:external/xqx:varValue"/>
</xsl:if>
</xsl:if>
</xsl:template>
<xsl:template match="xqx:targetLocation">
<xsl:choose>
<xsl:when test="position()=1"> at </xsl:when>
<xsl:otherwise>,
 </xsl:otherwise>
</xsl:choose>
<xsl:call-template name="quote">
<xsl:with-param name="item" select="."/>
</xsl:call-template>
</xsl:template>
<xsl:template match="xqx:schemaImport">
<xsl:text> import schema </xsl:text>
<xsl:if test="xqx:defaultElementNamespace">
<xsl:text> default element namespace </xsl:text>
</xsl:if>
<xsl:if test="xqx:namespacePrefix">
<xsl:text> namespace </xsl:text>
<xsl:value-of select="xqx:namespacePrefix"/>
<xsl:value-of select="$EQUAL"/>
</xsl:if>
<xsl:call-template name="quote">
<xsl:with-param name="item" select="xqx:targetNamespace"/>
</xsl:call-template>
<xsl:apply-templates select="xqx:targetLocation"/>
</xsl:template>
<xsl:template match="xqx:moduleImport">
<xsl:text> import module </xsl:text>
<xsl:if test="xqx:namespacePrefix">
<xsl:text> namespace </xsl:text>
<xsl:value-of select="xqx:namespacePrefix"/>
<xsl:value-of select="$EQUAL"/>
</xsl:if>
<xsl:call-template name="quote">
<xsl:with-param name="item" select="xqx:targetNamespace"/>
</xsl:call-template>
<xsl:apply-templates select="xqx:targetLocation"/>
</xsl:template>
<xsl:template match="xqx:param">
<xsl:value-of select="$DOLLAR"/>
<xsl:apply-templates select="xqx:varName"/>
<xsl:apply-templates select="xqx:typeDeclaration"/>
</xsl:template>
<xsl:template match="xqx:paramList">
<xsl:call-template name="parenthesizedList"/>
</xsl:template>
<xsl:template match="xqx:functionBody">
<xsl:value-of select="$NEWLINE"/>
<xsl:value-of select="$LBRACE"/>
<xsl:value-of select="$NEWLINE"/>
<xsl:apply-templates/>
<xsl:value-of select="$NEWLINE"/>
<xsl:value-of select="$RBRACE"/>
</xsl:template>
<xsl:template match="xqx:functionDecl">
<xsl:text>declare</xsl:text>
<xsl:apply-templates select="xqx:annotation"/>
<xsl:text> function </xsl:text>
<xsl:apply-templates select="xqx:functionName"/>
<xsl:apply-templates select="xqx:paramList"/>
<xsl:apply-templates select="xqx:typeDeclaration"/>
<xsl:choose>
<xsl:when test="xqx:externalDefinition">
<xsl:text> external </xsl:text>
</xsl:when>
<xsl:otherwise>
<xsl:apply-templates select="xqx:functionBody"/>
</xsl:otherwise>
</xsl:choose>
</xsl:template>
<xsl:template match="xqx:queryBody">
<xsl:apply-templates select="*"/>
<xsl:value-of select="$NEWLINE"/>
</xsl:template>
<xsl:template match="xqx:moduleDecl">
<xsl:text> module namespace </xsl:text>
<xsl:value-of select="xqx:prefix"/>
<xsl:value-of select="$EQUAL"/>
<xsl:call-template name="quote">
<xsl:with-param name="item" select="xqx:uri" />
</xsl:call-template>
<xsl:value-of select="$SEPARATOR"/>
<xsl:value-of select="$NEWLINE"/>
</xsl:template>
<xsl:template match="xqx:prolog">
<xsl:for-each select="*">
<xsl:apply-templates select="."/>
<xsl:value-of select="$SEPARATOR"/>
<xsl:value-of select="$NEWLINE"/>
</xsl:for-each>
</xsl:template>
<xsl:template match="xqx:libraryModule">
<xsl:apply-templates select="xqx:moduleDecl"/>
<xsl:apply-templates select="xqx:prolog"/>
</xsl:template>
<xsl:template match="xqx:mainModule">
<xsl:apply-templates select="xqx:prolog"/>
<xsl:apply-templates select="xqx:queryBody"/>
</xsl:template>
<!-- Enhanced to properly support encoding parameter -->
<xsl:template match="xqx:module" priority="2">
<xsl:choose>
<xsl:when test="xqx:versionDecl/xqx:encoding">
<xsl:variable name="enc">
<xsl:value-of select='xqx:versionDecl/xqx:encoding'/>
</xsl:variable>
<xsl:result-document encoding="{$enc}">
<xsl:apply-templates select="*"/>
<xsl:fallback>
<xsl:apply-templates select="*"/>
</xsl:fallback>
</xsl:result-document>
</xsl:when>
<xsl:otherwise>
<xsl:apply-templates select="*"/>
</xsl:otherwise>
</xsl:choose>
</xsl:template>
<xsl:template match="/xqx:*">
<xsl:message terminate="yes">Incorrect XQueryX: The only top-level element permitted is xqx:module</xsl:message>
</xsl:template>
</xsl:stylesheet>
The application/xquery+xml Media TypeThis Appendix specifies the media type for XQueryX Version 3.1.
XQueryX is the XML syntax of a language, XQuery, for querying over
data from XML data sources, as specified in
.
Specification of media types is described in
.
IntroductionThis document, together with its normative references, defines the
XML syntax for the XML Query language XQuery Version 3.1.
This Appendix specifies the application/xquery+xml media type,
which is intended to be used for transmitting queries expressed in the
XQueryX syntax.
This media type registration is to allow for the deployment of
XQueryX on the World Wide Web.
This document was prepared by members of the W3C XML Query Working
Group. Please send comments to public-qt-comments@w3.org,
a public mailing list with archives at
http://lists.w3.org/Archives/Public/public-qt-comments.
Registration of MIME Media Type application/xquery+xml
MIME media type name: application
MIME subtype name: xquery+xml
Required parameters: none
Optional parameters: charset
This parameter has identical semantics to the
charset parameter of the application/xml
media type as specified in [RFC 3023].
Encoding ConsiderationsBy virtue of XSLT content being XML, it has the same considerations
when sent as "application/xquery+xml" as does XML.
See [RFC 3023], section 3.2.
Security ConsiderationsQueries written in XQuery may cause arbitrary URIs or IRIs to be dereferenced.
Therefore, the security issues of [RFC 3987] Section 8 should be considered.
In addition, the contents of resources identified by file: URIs can in
some cases be accessed, processed and returned as results.
XQuery expressions can invoke any of the functions defined in
.
For example, the fn:doc() and fn:doc-available() functions
allow local filesystem probes as well as access to any URI-defined resource accessible
from the system evaluating the XQuery expression.
The fn:transform() function allows calls to
URI-identified XSLT transformations which may in turn call
external extension functions and access or write to the
file system. The fn:transform() function
should be sandboxed or disabled if untrusted queries are
run.
XQuery is a full declarative programming language, and supports
user-defined functions, external function libraries (modules)
referenced by URI, and system-specific "native" functions.
Arbitrary recursion is possible, as is arbitrarily large
memory usage, and implementations may place limits on CPU and
memory usage, as well as restricting access to system-defined functions.
The optional XQuery Update Facility allows XQuery expressions to
create and update persistent data, potentially including writing
to arbitrary locations on the local filesystem as well as to
remote URIs. Untrusted queries should not be given write access
to data.
Furthermore, because the XQuery language permits extensions, it is
possible that application/xquery+xml may describe content
that has security implications beyond those described here.
Interoperability ConsiderationsSee
.
Published specificationThis media type registration is for XQueryX documents as described
by the XQueryX 3.1 specification, which is located at
http://www.w3.org/TR/xqueryx-31/
.
It is also appropriate to use this media type with later versions of
the XQueryX language.
Applications That Use This Media TypeThe public XQuery Web page
lists more than two dozen implementations of the XQuery language,
both proprietary and open source. Some of these are known to
support XQueryX.
This new media type is being registered to allow for deployment
of XQueryX on the World Wide Web.
There is no experimental, vendor specific, or personal tree
predecessor to "application/xquery+xml", reflecting the fact
that no applications currently recognize it. This new type is
being registered in order to allow for the expected deployment
of XQueryX 3.1
on the World Wide Web, as a first class XML application.
Additional InformationRecognizing XQuery Files ("Magic Numbers")Although no byte sequences can be depended on to consistently
identify XQueryX, XQueryX documents will have the sequence
"http://www.w3.org/2005/XQueryX" to identify the XQueryX
namespace.
This sequence will normally be found in a namespace attribute
of the first element in the document.
File ExtensionsThe most common file extension in use for XQueryX is
.xqx.
Macintosh File Type Code(s)The appropriate Macintosh file type code is TEXT.
Person and Email Address to Contact For Further InformationJim Melton, Oracle Corp.,
jim.melton@oracle.com
Intended UsageCOMMON
Restrictions on usageThe intended usage of this media type is for interchange
of XQueryX expressions.
Author/Change ControllerXQuery was produced by, and is maintained by, the World Wide Web
Consortium's XML Query Working Group. The W3C has change
control over this specification.
Fragment IdentifiersFor documents labeled as "application/xquery+xml",
the fragment identifier notation is exactly that for
"application/xml", as specified in [RFC 3023].
Change logThis appendix lists the changes that have been made to this specification
since the publication of the XQueryX 3.0 Recommendation on 24 April 2014.
IncompatibilitiesThe
Recommendation
of
21 March 2017,
contains the following incompatibilities with XQueryX 3.0.
The changes made to this document are described below.
The rationale for each change is explained in the corresponding Bugzilla database entry (if any).
The following table summarizes the changes that have been applied.
Incompatibilities introduced during the Working Draft periodNone.
None.
In the
Recommendation
of
21 March 2017,
the following substantive changes have been made relative to XQueryX 3.0.
The changes made to this document are described below.
The rationale for each change is explained in the corresponding Bugzilla database entry (if any).
The following table summarizes the changes that have been applied.
Substantive changes introduced during the Last Call periodNone.
Added support for map tests (anyMapTest and typedMapTest) and array tests (anyArrayTest and typedArrayTest).
(Affects and .)
Modified definition of stepExpr to allow additional alternatives (besides "predicates") following the
primaryExpr; the new alternatives include a mixed sequence of "predicate", "lookup", and "arrowPostfix".
(Affects and .)
Added support for XQuery 3.0 new features Lookup, UnaryLookup, and ArrowPostfix.
This includes making UnaryLookup a new alternative of PrimaryExpr (in XQueryX, it becomes a new
alternative of filterExpr).
(Affects and .)
Added support for XQuery 3.0 new features MapConstructor and ArrayConstructor
(both SquareArrayConstructor and CurlyArrayConstructor).
This includes making both of those new alternatives of PrimaryExpr
(in XQueryX, they become new alternatives of filterExpr).
(Affects and .)
Added support for a new option ("*") to the alternatives for lookup (formerly mapLookup).
(Affects and .)
None.
In the
Recommendation
of
21 March 2017,
the following minor and editorial changes have been made relative to XQueryX 3.0.
The changes made to this document are described below.
The rationale for each change is explained in the corresponding Bugzilla database entry (if any).
The following table summarizes the changes that have been applied.
Minor and Editorial introduced during the Last Call periodNone.
Overhauled the manner in which is presented.
Updated several references, including a change from referencing XQueryX 1.0 to referencing XQueryX 3.0,
and a change from referencing XQuery 3.0 to referencing XQuery 3.1.