You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
6291 lines
263 KiB
6291 lines
263 KiB
<?xml version="1.0" encoding="utf-8"?>
|
|
<!--{xml-fix} XSLT Processor: SAXON 9.3.0.5 from Saxonica SAXON EE 9.3.0.5--><!--This document was created at 20111206 1709-->
|
|
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
|
|
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
|
|
<html xmlns="http://www.w3.org/1999/xhtml" lang="EN" xml:lang="EN">
|
|
<head>
|
|
<meta name="generator" content=
|
|
"HTML Tidy for Windows (vers 14 February 2006), see www.w3.org" />
|
|
<title>XQueryX 3.0</title>
|
|
|
|
<style type="text/css">
|
|
/*<![CDATA[*/
|
|
code { font-family: monospace; }
|
|
|
|
div.constraint,
|
|
div.issue,
|
|
div.note,
|
|
div.notice { margin-left: 2em; }
|
|
|
|
div.issue
|
|
p.title { margin-left: -2em; }
|
|
|
|
ol.enumar { list-style-type: decimal; }
|
|
ol.enumla { list-style-type: lower-alpha; }
|
|
ol.enumlr { list-style-type: lower-roman; }
|
|
ol.enumua { list-style-type: upper-alpha; }
|
|
ol.enumur { list-style-type: upper-roman; }
|
|
|
|
li p { margin-top: 0.3em;
|
|
margin-bottom: 0.3em; }
|
|
|
|
sup small { font-style: italic;
|
|
color: #8F8F8F;
|
|
}
|
|
|
|
div.exampleInner pre { margin-left: 1em;
|
|
margin-top: 0em; margin-bottom: 0em}
|
|
div.exampleOuter {border: 4px double gray;
|
|
margin: 0em; padding: 0em}
|
|
div.exampleInner { background-color: #d5dee3;
|
|
border-top-width: 4px;
|
|
border-top-style: double;
|
|
border-top-color: #d3d3d3;
|
|
border-bottom-width: 4px;
|
|
border-bottom-style: double;
|
|
border-bottom-color: #d3d3d3;
|
|
padding: 4px; margin: 0em }
|
|
div.exampleWrapper { margin: 4px }
|
|
div.exampleHeader { font-weight: bold;
|
|
margin: 4px}
|
|
|
|
div.issue { border-bottom-color: black;
|
|
border-bottom-style: solid;
|
|
border-bottom-width: 1pt;
|
|
margin-bottom: 20pt;
|
|
}
|
|
|
|
th.issue-toc-head { border-bottom-color: black;
|
|
border-bottom-style: solid;
|
|
border-bottom-width: 1pt;
|
|
}
|
|
|
|
|
|
table.small { font-size: x-small; }
|
|
a.judgment:visited, a.judgment:link { font-family: sans-serif;
|
|
color: black;
|
|
text-decoration: none }
|
|
a.processing:visited, a.processing:link { color: black;
|
|
text-decoration: none }
|
|
a.env:visited, a.env:link { color: black;
|
|
text-decoration: none }
|
|
/*]]>*/
|
|
</style>
|
|
<link rel="stylesheet" type="text/css" href=
|
|
"http://www.w3.org/StyleSheets/TR/W3C-WD.css" />
|
|
</head>
|
|
<body>
|
|
<div class="head">
|
|
<p><a href="http://www.w3.org/"><img src=
|
|
"http://www.w3.org/Icons/w3c_home" alt="W3C" height="48" width=
|
|
"72" /></a></p>
|
|
<h1><a name="title" id="title"></a>XQueryX 3.0</h1>
|
|
<h2><a name="w3c-doctype" id="w3c-doctype"></a>W3C Working Draft 13
|
|
December 2011</h2>
|
|
<dl>
|
|
<dt>This version:</dt>
|
|
<dd><a href=
|
|
"http://www.w3.org/TR/2011/WD-xqueryx-30-20111213/">http://www.w3.org/TR/2011/WD-xqueryx-30-20111213/</a></dd>
|
|
<dt>Latest version:</dt>
|
|
<dd><a href=
|
|
"http://www.w3.org/TR/xqueryx-30/">http://www.w3.org/TR/xqueryx-30/</a></dd>
|
|
<dt>Previous versions:</dt>
|
|
<dd><a href=
|
|
"http://www.w3.org/TR/2011/WD-xqueryx-30-20110614/">http://www.w3.org/TR/2011/WD-xqueryx-30-20110614/
|
|
,</a> <a href=
|
|
"http://www.w3.org/TR/2010/WD-xqueryx-30-20101214/">http://www.w3.org/TR/2010/WD-xqueryx-30-20101214/
|
|
,</a> <a href=
|
|
"http://www.w3.org/TR/2009/WD-xqueryx-11-20091215/">http://www.w3.org/TR/2009/WD-xqueryx-11-20091215/
|
|
,</a> <a href=
|
|
"http://www.w3.org/TR/2008/WD-xqueryx-11-20081203/">http://www.w3.org/TR/2008/WD-xqueryx-11-20081203/</a></dd>
|
|
<dt>Editor:</dt>
|
|
<dd>Jim Melton, Oracle <a href=
|
|
"mailto:jim.melton@oracle.com"><jim.melton@oracle.com></a></dd>
|
|
</dl>
|
|
<p>See also <a href=
|
|
"http://www.w3.org/2003/03/Translations/byTechnology?technology=xqueryx-30">
|
|
<strong>translations</strong></a>.</p>
|
|
<p>This document is also available in these non-normative formats:
|
|
<a href=
|
|
"http://www.w3.org/TR/2011/WD-xqueryx-30-20111213/xqueryx-30.xml">XML</a>,
|
|
<a href=
|
|
"http://www.w3.org/TR/2011/WD-xqueryx-30-20111213/xqueryx-30-diff.html">
|
|
Change markings relative to previous Working Draft</a>,
|
|
and <a href=
|
|
"http://www.w3.org/TR/2010/REC-xqueryx-20101214/">Most recent
|
|
XQueryX Recommendation</a>.</p>
|
|
<p class="copyright"><a href=
|
|
"http://www.w3.org/Consortium/Legal/ipr-notice#Copyright">Copyright</a> © 2011 <a href="http://www.w3.org/"><acronym title="World Wide Web Consortium">W3C</acronym></a><sup>®</sup>
|
|
(<a href="http://www.csail.mit.edu/"><acronym title=
|
|
"Massachusetts Institute of Technology">MIT</acronym></a>, <a href=
|
|
"http://www.ercim.eu/"><acronym title=
|
|
"European Research Consortium for Informatics and Mathematics">ERCIM</acronym></a>,
|
|
<a href="http://www.keio.ac.jp/">Keio</a>), All Rights Reserved.
|
|
W3C <a href=
|
|
"http://www.w3.org/Consortium/Legal/ipr-notice#Legal_Disclaimer">liability</a>,
|
|
<a href=
|
|
"http://www.w3.org/Consortium/Legal/ipr-notice#W3C_Trademarks">trademark</a>
|
|
and <a href=
|
|
"http://www.w3.org/Consortium/Legal/copyright-documents">document
|
|
use</a> rules apply.</p>
|
|
</div>
|
|
<hr />
|
|
<div>
|
|
<h2><a name="abstract" id="abstract"></a>Abstract</h2>
|
|
<p>This document defines an XML Syntax for <span><a href=
|
|
"#xquery-30">[XQuery 3.0: An XML Query Language]</a></span> .</p>
|
|
</div>
|
|
<div>
|
|
<h2><a name="status" id="status"></a>Status of this Document</h2>
|
|
<p><em>This section describes the status of this document at the
|
|
time of its publication. Other documents may supersede this
|
|
document. A list of current W3C publications and the latest
|
|
revision of this technical report can be found in the <a href=
|
|
"http://www.w3.org/TR/">W3C technical reports index</a> at
|
|
http://www.w3.org/TR/.</em></p>
|
|
<p>This is one document in a set of seven documents that are being
|
|
progressed to Recommendation together (XQuery 3.0, XQueryX 3.0,
|
|
XSLT 3.0, Data Model 3.0, Functions and Operators 3.0,
|
|
Serialization 3.0, XPath 3.0).</p>
|
|
<p>This is a <a href=
|
|
"http://www.w3.org/2005/10/Process-20051014/tr.html#last-call">Last
|
|
Call Working Draft</a> as described in the <a href=
|
|
"http://www.w3.org/2005/10/Process-20051014/tr.html">Process
|
|
Document</a>. It was developed by the W3C <a href=
|
|
"http://www.w3.org/XML/Query/">XML Query Working Group</a>, which
|
|
is part of the <a href="http://www.w3.org/XML/Activity">XML
|
|
Activity</a>. Comments on this document will be formally accepted
|
|
at least through 10 February 2012. The Working Group expects to
|
|
advance this specification to <a href=
|
|
"http://www.w3.org/2005/10/Process-20051014/tr.html#RecsW3C">Recommendation</a>
|
|
Status.</p>
|
|
<p>This Last Call Working Draft makes a small number of substantive
|
|
technical changes (as well as many editorial changes), including
|
|
new features, adopted since the previous Working Draft was
|
|
published. The Working Group especially solicits comments on this
|
|
Draft from other W3C Working Groups, as well as from the general
|
|
public. Please note that this Working Draft of XQueryX 3.0
|
|
represents the second version of <a href=
|
|
"http://www.w3.org/TR/2010/REC-xqueryx-20101214/">a previous W3C
|
|
Recommendation</a>.</p>
|
|
<p>No implementation report currently exists. However, a Test Suite
|
|
for XQueryX 3.0 is under development.</p>
|
|
<p>This document incorporates changes made against the previous
|
|
publication of the Working Draft. Changes to this document since
|
|
the previous publication of the Working Draft are detailed in
|
|
<a href="#changelog"><b>D Change log</b></a>.</p>
|
|
<p>Please report errors in this document using W3C's <a href=
|
|
"http://www.w3.org/Bugs/Public/">public Bugzilla system</a>
|
|
(instructions can be found at <a href=
|
|
"http://www.w3.org/XML/2005/04/qt-bugzilla">http://www.w3.org/XML/2005/04/qt-bugzilla</a>).
|
|
If access to that system is not feasible, you may send your
|
|
comments to the W3C XSLT/XPath/XQuery public comments mailing list,
|
|
<a href=
|
|
"mailto:public-qt-comments@w3.org">public-qt-comments@w3.org</a>.
|
|
It will be very helpful if you include the string “[XQueryX30 or
|
|
XQX30]” in the subject line of your report, whether made in
|
|
Bugzilla or in email. Please use multiple Bugzilla entries (or, if
|
|
necessary, multiple email messages) if you have more than one
|
|
comment to make. Archives of the comments and responses are
|
|
available at <a href=
|
|
"http://lists.w3.org/Archives/Public/public-qt-comments/">http://lists.w3.org/Archives/Public/public-qt-comments/</a>.</p>
|
|
<p>Publication as a Working Draft does not imply endorsement by the
|
|
W3C Membership. This is a draft document and may be updated,
|
|
replaced or obsoleted by other documents at any time. It is
|
|
inappropriate to cite this document as other than work in
|
|
progress.</p>
|
|
<p>This document was produced by a group operating under the
|
|
<a href="http://www.w3.org/Consortium/Patent-Policy-20040205/">5
|
|
February 2004 W3C Patent Policy</a>. W3C maintains a <a href=
|
|
"http://www.w3.org/2004/01/pp-impl/18797/status#disclosures">public
|
|
list of any patent disclosures</a> made in connection with the
|
|
deliverables of the group; that page also includes instructions for
|
|
disclosing a patent. An individual who has actual knowledge of a
|
|
patent which the individual believes contains <a href=
|
|
"http://www.w3.org/Consortium/Patent-Policy-20040205/#def-essential">
|
|
Essential Claim(s)</a> must disclose the information in accordance
|
|
with <a href=
|
|
"http://www.w3.org/Consortium/Patent-Policy-20040205/#sec-Disclosure">
|
|
section 6 of the W3C Patent Policy</a>.</p>
|
|
</div>
|
|
<div class="toc">
|
|
<h2><a name="contents" id="contents"></a>Table of Contents</h2>
|
|
<p class="toc">1 <a href="#Introduction">Introduction</a><br />
|
|
2 <a href="#Mapping">Mapping the XQuery Syntax</a><br />
|
|
3 <a href="#Examples">Examples from the XML Query Use Cases in XML
|
|
Syntax</a><br />
|
|
    3.1 <a href="#Example1">Example 1</a><br />
|
|
        3.1.1 <a href=
|
|
"#Example1-XQuery">XQuery solution in XQuery Use Cases:</a><br />
|
|
        3.1.2 <a href=
|
|
"#Example1-XQueryX">A Solution in XQueryX:</a><br />
|
|
        3.1.3 <a href=
|
|
"#Example1-Transformation">Transformation of XQueryX Solution into
|
|
XQuery</a><br />
|
|
        3.1.4 <a href=
|
|
"#Example1-Abstract">Corresponding Grammar Abstract Parse
|
|
Tree</a><br />
|
|
    3.2 <a href="#Example2">Example 2</a><br />
|
|
        3.2.1 <a href=
|
|
"#Example2-XQuery">XQuery solution in XQuery Use Cases:</a><br />
|
|
        3.2.2 <a href=
|
|
"#Example2-XQueryX">A solution in XQueryX:</a><br />
|
|
        3.2.3 <a href=
|
|
"#Example2-Transformation">Transformation of XQueryX Solution into
|
|
XQuery</a><br />
|
|
    3.3 <a href="#Example3">Example 3</a><br />
|
|
        3.3.1 <a href=
|
|
"#Example3-XQuery">XQuery solution in XQuery Use Cases:</a><br />
|
|
        3.3.2 <a href=
|
|
"#Example3-XQueryX">A solution in XQueryX:</a><br />
|
|
        3.3.3 <a href=
|
|
"#Example3-Transformation">Transformation of XQueryX Solution into
|
|
XQuery</a><br />
|
|
    3.4 <a href="#Example4">Example 4</a><br />
|
|
        3.4.1 <a href=
|
|
"#Example4-XQuery">XQuery solution in XQuery Use Cases:</a><br />
|
|
        3.4.2 <a href=
|
|
"#Example4-XQueryX">A solution in XQueryX:</a><br />
|
|
        3.4.3 <a href=
|
|
"#Example4-Transformation">Transformation of XQueryX Solution into
|
|
XQuery</a><br />
|
|
4 <a href="#Schema">An XML Schema for the XQuery XML
|
|
Syntax</a><br />
|
|
5 <a href="#xqx_conformance">Conformance</a><br /></p>
|
|
<h3><a name="appendices" id="appendices"></a>Appendices</h3>
|
|
<p class="toc">A <a href="#biblio">References</a><br />
|
|
B <a href="#Stylesheet">Transforming XQueryX to XQuery</a><br />
|
|
C <a href="#xqueryx-id-mime-type">The application/xquery+xml Media
|
|
Type</a><br />
|
|
    C.1 <a href=
|
|
"#xqueryx-mime-introduction">Introduction</a><br />
|
|
    C.2 <a href=
|
|
"#xqueryx-mime-registration">Registration of MIME Media Type
|
|
application/xquery+xml</a><br />
|
|
        C.2.1 <a href=
|
|
"#xqueryx-mime-encoding">Encoding Considerations</a><br />
|
|
        C.2.2 <a href=
|
|
"#xqueryx-mime-security">Security Considerations</a><br />
|
|
        C.2.3 <a href=
|
|
"#xqueryx-mime-interoperability">Interoperability
|
|
Considerations</a><br />
|
|
        C.2.4 <a href=
|
|
"#xqueryx-mime-pubspec">Published specification</a><br />
|
|
        C.2.5 <a href=
|
|
"#xqueryx-mime-applications">Applications That Use This Media
|
|
Type</a><br />
|
|
        C.2.6 <a href=
|
|
"#xqueryx-mime-additional">Additional Information</a><br />
|
|
            C.2.6.1
|
|
<a href="#xqueryx-mime-recognizing">Recognizing XQuery Files
|
|
("Magic Numbers")</a><br />
|
|
            C.2.6.2
|
|
<a href="#xqueryx-mime-extensions">File Extensions</a><br />
|
|
            C.2.6.3
|
|
<a href="#xqueryx-mime-macfiletype">Macintosh File Type
|
|
Code(s)</a><br />
|
|
        C.2.7 <a href=
|
|
"#xqueryx-mime-author">Person and Email Address to Contact For
|
|
Further Information</a><br />
|
|
        C.2.8 <a href=
|
|
"#xqueryx-mime-intended-usage">Intended Usage</a><br />
|
|
        C.2.9 <a href=
|
|
"#xqueryx-mime-restrictions">Restrictions on usage</a><br />
|
|
        C.2.10 <a href=
|
|
"#xqueryx-mime-owner">Author/Change Controller</a><br />
|
|
        C.2.11 <a href=
|
|
"#xqueryx-mime-fragments">Fragment Identifiers</a><br />
|
|
D <a href="#changelog">Change log</a> (Non-Normative)<br />
|
|
    D.1 <a href=
|
|
"#changelog_substantive">Substantive changes</a><br />
|
|
    D.2 <a href=
|
|
"#changelog_incompatibilities">Incompatibilities</a><br />
|
|
    D.3 <a href=
|
|
"#changelog_editorial">Editorial changes</a><br /></p>
|
|
</div>
|
|
<hr />
|
|
<div class="body">
|
|
<div class="div1">
|
|
<h2><a name="Introduction" id="Introduction"></a>1
|
|
Introduction</h2>
|
|
<p>The <span><a href="#xquery-30-requirements">[XQuery 3.0
|
|
Requirements]</a></span> 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."</p>
|
|
<p>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.</p>
|
|
<p>In this document, examples and material labeled as "Note" are
|
|
provided for explanatory purposes and are not normative.</p>
|
|
<div class="note">
|
|
<p class="prefix"><b>Note:</b></p>
|
|
<p>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 <span><a href=
|
|
"#xquery-30">[XQuery 3.0: An XML Query Language]</a></span> .</p>
|
|
</div>
|
|
<p>There are several environments in which XQueryX may be
|
|
useful:</p>
|
|
<ul>
|
|
<li>
|
|
<p><em>Parser Reuse.</em> In heterogeneous environments, a variety
|
|
of systems may be used to execute a query. One parser can generate
|
|
XQueryX for all of these systems.</p>
|
|
</li>
|
|
<li>
|
|
<p><em>Queries on Queries.</em> 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.</p>
|
|
</li>
|
|
<li>
|
|
<p><em>Generating Queries.</em> 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.</p>
|
|
</li>
|
|
<li>
|
|
<p><em>Embedding Queries in XML.</em> XQueryX can be embedded
|
|
directly in an XML document.</p>
|
|
</li>
|
|
</ul>
|
|
<p>This version of XQueryX is fully compatible with <span><a href=
|
|
"#xqueryx">[XML Syntax for XQuery 1.0 (XQueryX)]</a></span> . 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 <span><a href=
|
|
"#xqueryx">[XML Syntax for XQuery 1.0 (XQueryX)]</a></span>
|
|
continue to be valid, with the same meaning, when processed by an
|
|
implementation of this version of XQueryX.</p>
|
|
<p>The most recent versions of the XQueryX XML Schema and the
|
|
XQueryX XSLT stylesheet are available at <a href=
|
|
"http://www.w3.org/2011/12/XQueryX/xqueryx.xsd">http://www.w3.org/2011/12/XQueryX/xqueryx.xsd</a>
|
|
and <a href=
|
|
"http://www.w3.org/2011/12/XQueryX/xqueryx.xsl">http://www.w3.org/2011/12/XQueryX/xqueryx.xsl</a>,
|
|
respectively.</p>
|
|
<div class="note">
|
|
<p class="prefix"><b>Note:</b></p>
|
|
<p>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 <span><a href="#xqueryx">[XML
|
|
Syntax for XQuery 1.0 (XQueryX)]</a></span> .</p>
|
|
</div>
|
|
</div>
|
|
<div class="div1">
|
|
<h2><a name="Mapping" id="Mapping"></a>2 Mapping the XQuery
|
|
Syntax</h2>
|
|
<p>XQueryX is an XML representation of the abstract syntax found in
|
|
Appendix A of <span><a href="#xquery-30">[XQuery 3.0: An XML Query
|
|
Language]</a></span> . The XQueryX syntax is defined by the XQueryX
|
|
Schema, which is specified in <a href="#Schema"><b>4 An XML Schema
|
|
for the XQuery XML Syntax</b></a>. The XQueryX semantics are
|
|
defined by a stylesheet that maps an instance of XQueryX to an
|
|
instance of XQuery; see <a href="#Stylesheet"><b>B Transforming
|
|
XQueryX to XQuery</b></a>.</p>
|
|
<p>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.</p>
|
|
<p>Consider the following productions from the abstract syntax:</p>
|
|
<div class="exampleInner">
|
|
<pre>
|
|
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
|
|
</pre></div>
|
|
<div class="note">
|
|
<p class="prefix"><b>Note:</b></p>
|
|
<p>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.</p>
|
|
</div>
|
|
<p>The following XQueryX Schema definitions reflect the structure
|
|
of those productions from that abstract syntax:</p>
|
|
<div class="exampleInner">
|
|
<pre>
|
|
|
|
<!-- 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"/>
|
|
</pre></div>
|
|
<p>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.</p>
|
|
</div>
|
|
<div class="div1">
|
|
<h2><a name="Examples" id="Examples"></a>3 Examples from the XML
|
|
Query Use Cases in XML Syntax</h2>
|
|
<p>Three of following examples are based on the data and queries in
|
|
the XMP (Experiences and Exemplars) use case in <span><a href=
|
|
"#xquery-30-use-cases">[XQuery 3.0 Use Cases]</a></span> , 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
|
|
<span><a href="#xquery-30-use-cases">[XQuery 3.0 Use
|
|
Cases]</a></span> , an XQueryX solution, and the XQuery that
|
|
results from applying the XQueryX-to-XQuery transformation defined
|
|
by the stylesheet in <a href="#Stylesheet"><b>B Transforming
|
|
XQueryX to XQuery</b></a> to the XQueryX solution. That produced
|
|
XQuery is presented only as a sanity-check — the intent of the
|
|
stylesheet is not to create the identical XQuery expression given
|
|
in <span><a href="#xquery-30-use-cases">[XQuery 3.0 Use
|
|
Cases]</a></span> , but to produce <em>a</em> 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?</p>
|
|
<p>Comparison of the results of the XQueryX-to-XQuery
|
|
transformation given in this document with the XQuery solutions in
|
|
the <span><a href="#xquery-30-use-cases">[XQuery 3.0 Use
|
|
Cases]</a></span> may be helpful in evaluating the correctness of
|
|
the XQueryX solution in each example.</p>
|
|
<p>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.</p>
|
|
<p>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.</p>
|
|
<p>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.</p>
|
|
<div class="div2">
|
|
<h3><a name="Example1" id="Example1"></a>3.1 Example 1</h3>
|
|
<p>Here is Q1 from the <span><a href="#xquery-30-use-cases">[XQuery
|
|
3.0 Use Cases]</a></span> , use case XMP (Experiences and
|
|
Exemplars): "List books published by Addison-Wesley after 1991,
|
|
including their year and title."</p>
|
|
<div class="div3">
|
|
<h4><a name="Example1-XQuery" id="Example1-XQuery"></a>3.1.1 XQuery
|
|
solution in XQuery Use Cases:</h4>
|
|
<div class="exampleInner">
|
|
<pre>
|
|
<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>
|
|
</pre></div>
|
|
</div>
|
|
<div class="div3">
|
|
<h4><a name="Example1-XQueryX" id="Example1-XQueryX"></a>3.1.2 A
|
|
Solution in XQueryX:</h4>
|
|
<div class="exampleInner">
|
|
<pre>
|
|
<?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>
|
|
</pre></div>
|
|
</div>
|
|
<div class="div3">
|
|
<h4><a name="Example1-Transformation" id=
|
|
"Example1-Transformation"></a>3.1.3 Transformation of XQueryX
|
|
Solution into XQuery</h4>
|
|
<p>Application of the stylesheet in <a href="#Stylesheet"><b>B
|
|
Transforming XQueryX to XQuery</b></a> to the XQueryX solution
|
|
results in:</p>
|
|
<div class="exampleInner">
|
|
<pre>
|
|
|
|
<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>
|
|
</pre></div>
|
|
</div>
|
|
<div class="div3">
|
|
<h4><a name="Example1-Abstract" id="Example1-Abstract"></a>3.1.4
|
|
Corresponding Grammar Abstract Parse Tree</h4>
|
|
<p>For comparison, here is the abstract parse tree corresponding to
|
|
the XQuery for Example 1, as produced by the XQuery grammar applets
|
|
found at <a href=
|
|
"http://www.w3.org/2007/01/applets/">http://www.w3.org/2007/01/applets/</a>.</p>
|
|
<div class="exampleInner">
|
|
<pre>
|
|
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
|
|
</pre></div>
|
|
</div>
|
|
</div>
|
|
<div class="div2">
|
|
<h3><a name="Example2" id="Example2"></a>3.2 Example 2</h3>
|
|
<p>Here is Q4 from the <span><a href="#xquery-30-use-cases">[XQuery
|
|
3.0 Use Cases]</a></span> , 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."</p>
|
|
<div class="div3">
|
|
<h4><a name="Example2-XQuery" id="Example2-XQuery"></a>3.2.1 XQuery
|
|
solution in XQuery Use Cases:</h4>
|
|
<div class="exampleInner">
|
|
<pre>
|
|
<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>
|
|
</pre></div>
|
|
</div>
|
|
<div class="div3">
|
|
<h4><a name="Example2-XQueryX" id="Example2-XQueryX"></a>3.2.2 A
|
|
solution in XQueryX:</h4>
|
|
<div class="exampleInner">
|
|
<pre>
|
|
<?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>
|
|
</pre></div>
|
|
</div>
|
|
<div class="div3">
|
|
<h4><a name="Example2-Transformation" id=
|
|
"Example2-Transformation"></a>3.2.3 Transformation of XQueryX
|
|
Solution into XQuery</h4>
|
|
<p>Application of the stylesheet in <a href="#Stylesheet"><b>B
|
|
Transforming XQueryX to XQuery</b></a> to the XQueryX solution
|
|
results in:</p>
|
|
<div class="exampleInner">
|
|
<pre>
|
|
|
|
<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>
|
|
</pre></div>
|
|
</div>
|
|
</div>
|
|
<div class="div2">
|
|
<h3><a name="Example3" id="Example3"></a>3.3 Example 3</h3>
|
|
<p>Here is Q7 from the <span><a href="#xquery-30-use-cases">[XQuery
|
|
3.0 Use Cases]</a></span> , use case XMP (Experiences and
|
|
Exemplars): "List the titles and years of all books published by
|
|
Addison-Wesley after 1991, in alphabetic order."</p>
|
|
<div class="div3">
|
|
<h4><a name="Example3-XQuery" id="Example3-XQuery"></a>3.3.1 XQuery
|
|
solution in XQuery Use Cases:</h4>
|
|
<div class="exampleInner">
|
|
<pre>
|
|
<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>
|
|
</pre></div>
|
|
</div>
|
|
<div class="div3">
|
|
<h4><a name="Example3-XQueryX" id="Example3-XQueryX"></a>3.3.2 A
|
|
solution in XQueryX:</h4>
|
|
<div class="exampleInner">
|
|
<pre>
|
|
<?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>
|
|
</pre></div>
|
|
</div>
|
|
<div class="div3">
|
|
<h4><a name="Example3-Transformation" id=
|
|
"Example3-Transformation"></a>3.3.3 Transformation of XQueryX
|
|
Solution into XQuery</h4>
|
|
<p>Application of the stylesheet in <a href="#Stylesheet"><b>B
|
|
Transforming XQueryX to XQuery</b></a> to the XQueryX solution
|
|
results in:</p>
|
|
<div class="exampleInner">
|
|
<pre>
|
|
|
|
<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>
|
|
</pre></div>
|
|
</div>
|
|
</div>
|
|
<div class="div2">
|
|
<h3><a name="Example4" id="Example4"></a>3.4 Example 4</h3>
|
|
<p>Here is Q8 from the <span><a href="#xquery-30-use-cases">[XQuery
|
|
3.0 Use Cases]</a></span> , use case NS (Queries Using Namespaces):
|
|
"Select all traders (either seller or high bidder) without negative
|
|
comments."</p>
|
|
<div class="div3">
|
|
<h4><a name="Example4-XQuery" id="Example4-XQuery"></a>3.4.1 XQuery
|
|
solution in XQuery Use Cases:</h4>
|
|
<div class="exampleInner">
|
|
<pre>
|
|
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>
|
|
</pre></div>
|
|
</div>
|
|
<div class="div3">
|
|
<h4><a name="Example4-XQueryX" id="Example4-XQueryX"></a>3.4.2 A
|
|
solution in XQueryX:</h4>
|
|
<div class="exampleInner">
|
|
<pre>
|
|
<?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>
|
|
</pre></div>
|
|
</div>
|
|
<div class="div3">
|
|
<h4><a name="Example4-Transformation" id=
|
|
"Example4-Transformation"></a>3.4.3 Transformation of XQueryX
|
|
Solution into XQuery</h4>
|
|
<p>Application of the stylesheet in <a href="#Stylesheet"><b>B
|
|
Transforming XQueryX to XQuery</b></a> to the XQueryX solution
|
|
results in:</p>
|
|
<div class="exampleInner">
|
|
<pre>
|
|
|
|
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>
|
|
</pre></div>
|
|
</div>
|
|
</div>
|
|
</div>
|
|
<div class="div1">
|
|
<h2><a name="Schema" id="Schema"></a>4 An XML Schema for the XQuery
|
|
XML Syntax</h2>
|
|
<p>Here is the XML Schema against which XQueryX documents must be
|
|
valid.</p>
|
|
<div class="exampleInner">
|
|
<pre>
|
|
<?xml version="1.0"?>
|
|
<span><!-- ================================================================================ -->
|
|
<!-- NOTES TO READERS OF THIS SCHEMA: -->
|
|
<!-- The default value for both minOccurs and maxOccurs is "1". -->
|
|
<!-- The XQueryX schema has been designed to provide the ability to extend definitions -->
|
|
<!-- of top-level elements in extensions such as Full-Text and the Update Facility. -->
|
|
<!-- The nature of the modification is to define named complex types and redefine -->
|
|
<!-- those top-level elements in terms of the named complex types. -->
|
|
<!-- ================================================================================ -->
|
|
<!-- Changes from Recommendation (edition 1): -->
|
|
<!-- * Element defs using anon complex types changed to use named types (bug #4924) -->
|
|
<!-- * In Example 4, replaced xqx:parentheziedExpr with xqx:sequenceExpr (bug #4963) -->
|
|
<!-- * In XSLT stylesheet, deleted template for xqx:parenthesizedExpr (bug #4963) -->
|
|
<!-- * Replaced link to grammar applet with correct link (bug #5323) -->
|
|
<!-- * In XSLT stylesheet, corrected template for xqx:namespaceDeclaration (bug #5343) -->
|
|
<!-- Changes from Recommendation (edition 2): -->
|
|
<!-- * Added support for new Windowing clause in FLWOR expression -->
|
|
<!-- * Added support for new Group By Clause in FLWOR expression -->
|
|
<!-- * Added support for new Count Clause in FLWOR expression -->
|
|
<!-- * Added support for keyword "outer" on for expression -->
|
|
<!-- * Modified structure of FLWOR clause per "simplified FLWOR expressions" -->
|
|
<!-- * Modified validation syntax per Bugzilla Bug 5472 -->
|
|
<!-- * Modified function declaration so that external functions can be nondeterminstic -->
|
|
<!-- * Modified variable declaration so external variables can have an initial value -->
|
|
<!-- * Added support for new try-catch expression -->
|
|
<!-- * Added support for new decimal formatting declaration -->
|
|
<!-- * Added support for encoding in the version declaration -->
|
|
<!-- * Added support for new context item declaration -->
|
|
<!-- * Added support for computed namespace constructor -->
|
|
<!-- * Made changes triggered by Bugzilla Bugs 6309, 6310, and 6311 -->
|
|
<!-- * Modified errlist syntax per Bugzilla Bug 7053 -->
|
|
<!-- * Added support for public/private functions -->
|
|
<!-- * Replaced "outer for" support with support for "allowing empty" -->
|
|
<!-- * Added support for higher-order functions -->
|
|
<!-- * Added support for value-based "switch" expression -->
|
|
<!-- * Use pattern to prohibit "#)" in pragma contents per Bugzilla Bug 2711 -->
|
|
<!-- * Changed functionItemExpr child element QName to be functionName for consistency -->
|
|
<!-- * Replaced "public", "private", and "[non]deterministic" with %-annotations -->
|
|
<!-- * Added EQName to permit "URI-literal":NCNAME as alternative to NCName:NCName -->
|
|
<!-- * Changed type of atomicType to EQName, so it's really atomicOrUnionType -->
|
|
<!-- ================================================================================ -->
|
|
<!-- Errata applied: -->
|
|
<!-- XQX.E1 - Editorial (Bugzilla Bug 4924) -->
|
|
<!-- XQX.E7 - Substantive (Bugzilla Bug 2711) -->
|
|
<!-- ================================================================================ -->
|
|
<!-- Modifications: -->
|
|
<!-- 2008-07-30 - Add XQuery 1.1 grouping and windowing support -->
|
|
<!-- 2008-09-18 - Add XQuery 1.1 count and outer-for support, simplified FLWOR -->
|
|
<!-- 2008-09-27 - Add validation type, nondeterministic function declarations, -->
|
|
<!-- initial values for external variables, try-catch expression -->
|
|
<!-- 2008-11-25 - Add support for number formatting, Snelson's version declaration -->
|
|
<!-- proposal, context item declaration, computed namespace constructor,-->
|
|
<!-- fixes for validate expression, and change to allow the count -->
|
|
<!-- clause to only be an intermediate expression -->
|
|
<!-- 2009-01-13 - Bugs 6309 and 6310 (fixes to details of certain windowing clauses -->
|
|
<!-- 2009-03-03 - tumblingWindowClause syntax now matches slidingWindowClause syntax -->
|
|
<!-- 2009-09-06 - Modified errlist syntax per Bugzilla Bug 7053 -->
|
|
<!-- 2009-10-09 - Added support for private/public functions -->
|
|
<!-- Replace "outer for" with "allowing empty" -->
|
|
<!-- 2009-10-22 - Add support for higher-order functions & switch expression -->
|
|
<!-- 2010-04-06 - Changed functionItemExpr child QName -> functionName (consistency) -->
|
|
<!-- 2010-05-10 - Added %-annotation support for varDecl and functionDecl -->
|
|
<!-- 2010-06-23 - Added support for partial function application -->
|
|
<!-- 2011-02-02 - Added support for EQNames and atomicOrUnionType -->
|
|
<!-- 2011-05-04 - Updated structure of catch component of try-catch expression -->
|
|
<!-- 2011-05-04 - Updated validationexpr, mode/type alternatives, type is EQName -->
|
|
<!-- 2011-07-08 - Added support for concatenation operator || -->
|
|
<!-- * 2011-09-09 - Added support for simple mapping operator ! -->
|
|
<!-- * 2011-09-09 - Added support for sequenceTypeUnion in typeswitch -->
|
|
<!-- * 2011-09-09 - Added support for annotations on inline functions -->
|
|
<!-- 2011-09-14 - Added support for new group-by syntax -->
|
|
<!-- 2011-11-21 - Jim changed "literalFunctionItemExpr" to "namedFunctionRef" -->
|
|
<!-- 2011-11-21 - Jim changed "inlineFunctionItemExpr" to "inlineFunctionExpr" -->
|
|
<!-- ================================================================================ -->
|
|
</span>
|
|
<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>
|
|
|
|
<span> <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>
|
|
|
|
</span><!-- 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>
|
|
|
|
<span><!-- A list of expressions or placeholders -->
|
|
<!-- 2010-06-23 - Added support for partial function application -->
|
|
<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>
|
|
|
|
</span><!-- A type to be used by elements that comprise an optional expr -->
|
|
<xsd:complexType name="exprWrapperOptional">
|
|
<xsd:sequence>
|
|
<xsd:element ref="expr" minOccurs="0"/>
|
|
</xsd:sequence>
|
|
</xsd:complexType>
|
|
|
|
<!-- Simple wrapper class -->
|
|
<xsd:complexType name="exprWrapper">
|
|
<xsd:sequence>
|
|
<xsd:element ref="expr"/>
|
|
</xsd:sequence>
|
|
</xsd:complexType>
|
|
|
|
<!-- constant expressions. We have 4 different subclasses for this -->
|
|
<xsd:complexType name="constantExpr">
|
|
<xsd:complexContent>
|
|
<xsd:extension base="expr">
|
|
<xsd:sequence>
|
|
<xsd:element name="value" type="xsd:anyType"/>
|
|
</xsd:sequence>
|
|
</xsd:extension>
|
|
</xsd:complexContent>
|
|
</xsd:complexType>
|
|
|
|
<xsd:element name="constantExpr" type="constantExpr" abstract="true"
|
|
substitutionGroup="expr"/>
|
|
|
|
|
|
<xsd:complexType name="integerConstantExpr">
|
|
<xsd:complexContent>
|
|
<xsd:restriction base="constantExpr">
|
|
<xsd:sequence>
|
|
<xsd:element name="value" type="xsd:integer"/>
|
|
</xsd:sequence>
|
|
</xsd:restriction>
|
|
</xsd:complexContent>
|
|
</xsd:complexType>
|
|
|
|
<xsd:element name="integerConstantExpr" type="integerConstantExpr"
|
|
substitutionGroup="constantExpr"/>
|
|
|
|
|
|
<xsd:complexType name="decimalConstantExpr">
|
|
<xsd:complexContent>
|
|
<xsd:restriction base="constantExpr">
|
|
<xsd:sequence>
|
|
<xsd:element name="value" type="xsd:decimal"/>
|
|
</xsd:sequence>
|
|
</xsd:restriction>
|
|
</xsd:complexContent>
|
|
</xsd:complexType>
|
|
|
|
<xsd:element name="decimalConstantExpr" type="decimalConstantExpr"
|
|
substitutionGroup="constantExpr"/>
|
|
|
|
|
|
<xsd:complexType name="doubleConstantExpr">
|
|
<xsd:complexContent>
|
|
<xsd:restriction base="constantExpr">
|
|
<xsd:sequence>
|
|
<xsd:element name="value" type="xsd:double"/>
|
|
</xsd:sequence>
|
|
</xsd:restriction>
|
|
</xsd:complexContent>
|
|
</xsd:complexType>
|
|
|
|
<xsd:element name="doubleConstantExpr" type="doubleConstantExpr"
|
|
substitutionGroup="constantExpr"/>
|
|
|
|
|
|
<xsd:complexType name="stringConstantExpr">
|
|
<xsd:complexContent>
|
|
<xsd:restriction base="constantExpr">
|
|
<xsd:sequence>
|
|
<xsd:element name="value" type="xsd:string"/>
|
|
</xsd:sequence>
|
|
</xsd:restriction>
|
|
</xsd:complexContent>
|
|
</xsd:complexType>
|
|
|
|
<xsd:element name="stringConstantExpr" type="stringConstantExpr"
|
|
substitutionGroup="constantExpr"/>
|
|
|
|
|
|
<!-- Variables -->
|
|
<xsd:complexType name="varRef">
|
|
<xsd:complexContent>
|
|
<xsd:extension base="expr">
|
|
<xsd:sequence>
|
|
<span> <xsd:element name="name" type="EQName"/>
|
|
</span> </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>
|
|
<span> <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>
|
|
</span> </xsd:sequence>
|
|
</xsd:complexType>
|
|
|
|
<xsd:element name="pragma" type="pragma"/>
|
|
|
|
|
|
<xsd:complexType name="extensionExpr">
|
|
<xsd:complexContent>
|
|
<xsd:extension base="expr">
|
|
<xsd:sequence>
|
|
<xsd:element ref="pragma" maxOccurs="unbounded"/>
|
|
<xsd:element name="argExpr" type="exprWrapper" minOccurs="0"/>
|
|
</xsd:sequence>
|
|
</xsd:extension>
|
|
</xsd:complexContent>
|
|
</xsd:complexType>
|
|
|
|
<xsd:element name="extensionExpr" type="extensionExpr"
|
|
substitutionGroup="expr"/>
|
|
|
|
|
|
<!-- Function call expressions -->
|
|
<!-- 2010-06-23 - Added support for partial function application -->
|
|
<xsd:complexType name="functionCallExpr">
|
|
<xsd:complexContent>
|
|
<xsd:extension base="expr">
|
|
<xsd:sequence>
|
|
<span> <xsd:element name="functionName" type="EQName"/>
|
|
<xsd:element name="arguments" type="exprOrPlaceholderList" minOccurs="0"/>
|
|
</span> </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>
|
|
<span> <xsd:element name="typeName" type="EQName"/>
|
|
</span> <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"/>
|
|
|
|
<span><!-- String operator expressions -->
|
|
<xsd:element name="stringOp" type="operatorExpr"
|
|
abstract="true" substitutionGroup="operatorExpr"/>
|
|
|
|
<xsd:element name="stringConcatenateOp" type="binaryOperatorExpr"
|
|
substitutionGroup="stringOp"/>
|
|
|
|
</span><!-- 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 -->
|
|
<span><!-- 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"/>
|
|
</span>
|
|
|
|
<!-- Used in castable expression and cast expression -->
|
|
<xsd:complexType name="singleType">
|
|
<xsd:sequence>
|
|
<xsd:element ref="atomicType"/>
|
|
<xsd:element name="optional" type="emptyContent" minOccurs="0"/>
|
|
</xsd:sequence>
|
|
</xsd:complexType>
|
|
|
|
<xsd:element name="singleType" type="singleType"/>
|
|
|
|
|
|
<!-- Item type schema types and elements -->
|
|
<xsd:element name="itemType" abstract="true"/>
|
|
|
|
|
|
<xsd:complexType name="emptyItemTypeContent"/>
|
|
|
|
<xsd:element name="anyItemType" type="emptyItemTypeContent"
|
|
substitutionGroup="itemType"/>
|
|
|
|
|
|
<xsd:simpleType name="occurrenceIndicator">
|
|
<xsd:restriction base="xsd:string">
|
|
<xsd:enumeration value="?"/>
|
|
<xsd:enumeration value="*"/>
|
|
<xsd:enumeration value="+"/>
|
|
</xsd:restriction>
|
|
</xsd:simpleType>
|
|
|
|
|
|
<!-- Sequence type -->
|
|
<xsd:complexType name="sequenceType">
|
|
<xsd:choice>
|
|
<xsd:element name="voidSequenceType" type="emptyContent"/>
|
|
<xsd:sequence>
|
|
<xsd:element ref="itemType"/>
|
|
<xsd:element name="occurrenceIndicator" type="occurrenceIndicator"
|
|
minOccurs="0"/>
|
|
</xsd:sequence>
|
|
</xsd:choice>
|
|
</xsd:complexType>
|
|
|
|
<xsd:element name="sequenceType" type="sequenceType"/>
|
|
|
|
<xsd:element name="typeDeclaration" type="sequenceType"/>
|
|
|
|
|
|
<span><!-- Union of sequence types -->
|
|
<!-- 2011-09-09/JM - added a sequenceTypeUnion type -->
|
|
<xsd:complexType name="sequenceTypeUnion">
|
|
<xsd:sequence minOccurs="1" maxOccurs="unbounded">
|
|
<xsd:element ref="sequenceType"/>
|
|
</xsd:sequence>
|
|
</xsd:complexType>
|
|
|
|
<xsd:element name="sequenceTypeUnion" type="sequenceTypeUnion"/>
|
|
</span>
|
|
|
|
|
|
<!-- Represents a "typed" variable (for clause, let clause etc) -->
|
|
<xsd:complexType name="typedVariableBinding">
|
|
<xsd:sequence>
|
|
<span> <xsd:element name="varName" type="EQName"/>
|
|
</span> <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 -->
|
|
<span> <xsd:element name="positionalVariableBinding" type="EQName"/>
|
|
|
|
<xsd:element name="variableBinding" type="EQName"/>
|
|
</span>
|
|
|
|
<!-- 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"/>
|
|
<span> <xsd:element name="allowingEmpty" type="emptyContent"
|
|
minOccurs="0"/>
|
|
</span> <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"/>
|
|
|
|
|
|
<span><!-- 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"/>
|
|
|
|
|
|
</span><!-- whereClause (part of FLWOR expression) -->
|
|
<xsd:element name="whereClause" type="exprWrapper"/>
|
|
|
|
|
|
<span><!-- 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"/>
|
|
|
|
|
|
<!-- 2011-09-14/JM - added the ability to initialize a grouping variable, opt set type -->
|
|
<!-- 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"/>
|
|
|
|
|
|
</span><!-- 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"/>
|
|
|
|
|
|
<span><!-- This is the XQuery 3.0 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>
|
|
|
|
</span> <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"/>
|
|
|
|
|
|
<span><!-- 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"/>
|
|
|
|
|
|
</span><!-- handle the typeswitch expression -->
|
|
<!-- Note: no substitutionGroup as we cannot use this anywhere except within typeswitch -->
|
|
<!-- 2011-09-09/JM - replaced sequenceType with sequenceTypeUnion -->
|
|
<xsd:complexType name="typeswitchExprCaseClause">
|
|
<xsd:complexContent>
|
|
<xsd:extension base="expr">
|
|
<xsd:sequence>
|
|
<xsd:element ref="variableBinding" minOccurs="0"/>
|
|
<span> <xsd:choice>
|
|
<xsd:element ref="sequenceType"/>
|
|
<xsd:element ref="sequenceTypeUnion"/>
|
|
</xsd:choice>
|
|
</span> <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"/>
|
|
|
|
|
|
<span><!-- TryCatchExpression -->
|
|
<!-- Corresponds to the following XQuery syntax -->
|
|
<!-- TryCatchExpression ::= TryClause CatchClause+ -->
|
|
<!-- TryClause ::= "{" TryTargetExpr "}" -->
|
|
<!-- TryTargetExpr ::= Expr -->
|
|
<xsd:complexType name="tryCatchExpr">
|
|
<xsd:complexContent>
|
|
<xsd:extension base="expr">
|
|
<xsd:sequence>
|
|
<xsd:element name="tryClause" type="exprWrapper"/>
|
|
<xsd:element ref="catchClause" maxOccurs="unbounded"/>
|
|
</xsd:sequence>
|
|
</xsd:extension>
|
|
</xsd:complexContent>
|
|
</xsd:complexType>
|
|
|
|
<xsd:element name="tryCatchExpr" type="tryCatchExpr"
|
|
substitutionGroup="expr"/>
|
|
|
|
|
|
<!-- CatchClause (part of the TryCatchExpression) -->
|
|
<!-- Corresponds to the following XQuery syntax -->
|
|
<!-- CatchClause ::= "catch" CatchErrorList "{" Expr "}" -->
|
|
<xsd:complexType name="catchClause">
|
|
<xsd:sequence>
|
|
<xsd:element ref="catchErrorList"/>
|
|
<xsd:element name="catchExpr" type="exprWrapper"/>
|
|
</xsd:sequence>
|
|
</xsd:complexType>
|
|
|
|
<xsd:element name="catchClause" type="catchClause"/>
|
|
|
|
|
|
<!-- CatchErrorList (part of the TryCatchExpression) -->
|
|
<!-- Corresponds to the following XQuery syntax -->
|
|
<!-- CatchErrorList ::= NameTest ( "|" NameTest )* -->
|
|
<!-- (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"/>
|
|
|
|
|
|
</span><!-- instance-of expressions -->
|
|
<xsd:complexType name="instanceOfExpr">
|
|
<xsd:complexContent>
|
|
<xsd:extension base="expr">
|
|
<xsd:sequence>
|
|
<xsd:element name="argExpr" type="exprWrapper"/>
|
|
<xsd:element ref="sequenceType"/>
|
|
</xsd:sequence>
|
|
</xsd:extension>
|
|
</xsd:complexContent>
|
|
</xsd:complexType>
|
|
|
|
<xsd:element name="instanceOfExpr" type="instanceOfExpr"
|
|
substitutionGroup="expr"/>
|
|
|
|
|
|
<!-- treat-as expressions -->
|
|
<xsd:complexType name="treatExpr">
|
|
<xsd:complexContent>
|
|
<xsd:extension base="expr">
|
|
<xsd:sequence>
|
|
<xsd:element name="argExpr" type="exprWrapper"/>
|
|
<xsd:element ref="sequenceType"/>
|
|
</xsd:sequence>
|
|
</xsd:extension>
|
|
</xsd:complexContent>
|
|
</xsd:complexType>
|
|
|
|
<xsd:element name="treatExpr" type="treatExpr"
|
|
substitutionGroup="expr"/>
|
|
|
|
|
|
<!-- castable and cast expressions -->
|
|
<xsd:complexType name="castableExpr">
|
|
<xsd:complexContent>
|
|
<xsd:extension base="expr">
|
|
<xsd:sequence>
|
|
<xsd:element name="argExpr" type="exprWrapper"/>
|
|
<xsd:element ref="singleType"/>
|
|
</xsd:sequence>
|
|
</xsd:extension>
|
|
</xsd:complexContent>
|
|
</xsd:complexType>
|
|
|
|
<xsd:element name="castableExpr" type="castableExpr"
|
|
substitutionGroup="expr"/>
|
|
|
|
|
|
<xsd:complexType name="castExpr">
|
|
<xsd:complexContent>
|
|
<xsd:extension base="expr">
|
|
<xsd:sequence>
|
|
<xsd:element name="argExpr" type="exprWrapper"/>
|
|
<xsd:element ref="singleType"/>
|
|
</xsd:sequence>
|
|
</xsd:extension>
|
|
</xsd:complexContent>
|
|
</xsd:complexType>
|
|
|
|
<xsd:element name="castExpr" type="castExpr"
|
|
substitutionGroup="expr"/>
|
|
|
|
|
|
<!-- Validate expressions -->
|
|
<xsd:simpleType name="validationMode">
|
|
<xsd:restriction base="xsd:NMTOKEN">
|
|
<xsd:enumeration value="lax"/>
|
|
<xsd:enumeration value="strict"/>
|
|
</xsd:restriction>
|
|
</xsd:simpleType>
|
|
|
|
<xsd:complexType name="validateExpr">
|
|
<xsd:complexContent>
|
|
<xsd:extension base="expr">
|
|
<xsd:sequence>
|
|
<span> <xsd:choice>
|
|
<xsd:element name="validationMode" type="validationMode" minOccurs="0"/>
|
|
<xsd:element name="typeName" type="EQName" minOccurs="0"/>
|
|
</xsd:choice>
|
|
</span> <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>
|
|
<span> <xsd:element name="tagName" type="EQName"/>
|
|
</span> <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>
|
|
<span> <xsd:element name="tagName" type="EQName"/>
|
|
</span> <xsd:element name="tagNameExpr" type="exprWrapper"/>
|
|
</xsd:choice>
|
|
<xsd:element name="valueExpr" type="exprWrapper" minOccurs="0"/>
|
|
</xsd:sequence>
|
|
</xsd:extension>
|
|
</xsd:complexContent>
|
|
</xsd:complexType>
|
|
|
|
<xsd:element name="computedAttributeConstructor" type="computedAttributeConstructor"
|
|
substitutionGroup="expr"/>
|
|
|
|
|
|
<!-- computed document constructor -->
|
|
<xsd:complexType name="computedDocumentConstructor">
|
|
<xsd:complexContent>
|
|
<xsd:extension base="expr">
|
|
<xsd:sequence>
|
|
<xsd:element name="argExpr" type="exprWrapper"/>
|
|
</xsd:sequence>
|
|
</xsd:extension>
|
|
</xsd:complexContent>
|
|
</xsd:complexType>
|
|
|
|
<xsd:element name="computedDocumentConstructor" type="computedDocumentConstructor"
|
|
substitutionGroup="expr"/>
|
|
|
|
|
|
<!-- computed text constructor -->
|
|
<xsd:complexType name="computedTextConstructor">
|
|
<xsd:complexContent>
|
|
<xsd:extension base="expr">
|
|
<xsd:sequence>
|
|
<xsd:element name="argExpr" type="exprWrapper" minOccurs="0"/>
|
|
</xsd:sequence>
|
|
</xsd:extension>
|
|
</xsd:complexContent>
|
|
</xsd:complexType>
|
|
|
|
<xsd:element name="computedTextConstructor" type="computedTextConstructor"
|
|
substitutionGroup="expr"/>
|
|
|
|
|
|
<!-- computed comment constructor -->
|
|
<xsd:complexType name="computedCommentConstructor">
|
|
<xsd:complexContent>
|
|
<xsd:extension base="expr">
|
|
<xsd:sequence>
|
|
<xsd:element name="argExpr" type="exprWrapper"/>
|
|
</xsd:sequence>
|
|
</xsd:extension>
|
|
</xsd:complexContent>
|
|
</xsd:complexType>
|
|
|
|
<xsd:element name="computedCommentConstructor" type="computedCommentConstructor"
|
|
substitutionGroup="expr"/>
|
|
|
|
|
|
<span><!-- 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"/>
|
|
|
|
|
|
</span><!-- computed processing instruction constructor -->
|
|
<xsd:complexType name="computedPIConstructor">
|
|
<xsd:complexContent>
|
|
<xsd:extension base="expr">
|
|
<xsd:sequence>
|
|
<xsd:choice>
|
|
<xsd:element name="piTarget" type="xsd:NCName"/>
|
|
<xsd:element name="piTargetExpr" type="exprWrapper"/>
|
|
</xsd:choice>
|
|
<xsd:element name="piValueExpr" type="exprWrapper" minOccurs="0"/>
|
|
</xsd:sequence>
|
|
</xsd:extension>
|
|
</xsd:complexContent>
|
|
</xsd:complexType>
|
|
|
|
<xsd:element name="computedPIConstructor" type="computedPIConstructor"
|
|
substitutionGroup="expr"/>
|
|
|
|
|
|
<!-- ordered and unordered expressions -->
|
|
<xsd:complexType name="unorderedExpr">
|
|
<xsd:complexContent>
|
|
<xsd:extension base="expr">
|
|
<xsd:sequence>
|
|
<xsd:element name="argExpr" type="exprWrapper"/>
|
|
</xsd:sequence>
|
|
</xsd:extension>
|
|
</xsd:complexContent>
|
|
</xsd:complexType>
|
|
|
|
<xsd:element name="unorderedExpr" type="unorderedExpr" substitutionGroup="expr"/>
|
|
|
|
|
|
<xsd:complexType name="orderedExpr">
|
|
<xsd:complexContent>
|
|
<xsd:extension base="expr">
|
|
<xsd:sequence>
|
|
<xsd:element name="argExpr" type="exprWrapper"/>
|
|
</xsd:sequence>
|
|
</xsd:extension>
|
|
</xsd:complexContent>
|
|
</xsd:complexType>
|
|
|
|
<xsd:element name="orderedExpr" type="orderedExpr" substitutionGroup="expr"/>
|
|
|
|
|
|
<span><!-- function item expressions -->
|
|
<!-- literal function item expression -->
|
|
<!-- 2010-04-06: Jim changed child element QName to be functionName for consistency -->
|
|
<!-- 2011-11-21: Jim changed "literalFunctionItemExpr" to "namedFunctionRef" -->
|
|
<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 -->
|
|
<!-- 2011-09-09/JM - Added annotations to inline functions -->
|
|
<!-- 2011-11-21: Jim changed "inlineFunctionItemExpr" to "inlineFunctionExpr" -->
|
|
<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 -->
|
|
<!-- 2010-06-23 - Added support for partial function application -->
|
|
<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"/>
|
|
|
|
|
|
</span><!-- wildcards -->
|
|
<xsd:complexType name="simpleWildcard">
|
|
<xsd:choice>
|
|
<span> <xsd:element name="QName" type="EQName"/>
|
|
</span> <xsd:element name="star" type="emptyContent"/>
|
|
</xsd:choice>
|
|
</xsd:complexType>
|
|
|
|
<!-- 2011-06-10: Redesigned to allow "URliteral:*" -->
|
|
<!-- Corresponds to the following XQuery syntax: -->
|
|
<!-- [44] Wildcard ::= "*" -->
|
|
<!-- | (NCName ":" "*") -->
|
|
<!-- | ("*" ":" NCName) -->
|
|
<!-- | (URILiteral ":" "*") -->
|
|
|
|
<xsd:complexType name="Wildcard">
|
|
<span> <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>
|
|
</span> </xsd:complexType>
|
|
|
|
<xsd:element name="Wildcard" type="Wildcard"/>
|
|
|
|
|
|
<!-- tests (name and/or type) -->
|
|
<span> <xsd:element name="schemaAttributeTest" type="EQName"
|
|
substitutionGroup="kindTest"/>
|
|
</span>
|
|
|
|
<xsd:complexType name="attributeTest">
|
|
<xsd:complexContent>
|
|
<xsd:extension base="emptyItemTypeContent">
|
|
<xsd:sequence minOccurs="0">
|
|
<xsd:element name="attributeName" type="simpleWildcard"/>
|
|
<span> <xsd:element name="typeName" type="EQName" minOccurs="0"/>
|
|
</span> </xsd:sequence>
|
|
</xsd:extension>
|
|
</xsd:complexContent>
|
|
</xsd:complexType>
|
|
|
|
<xsd:element name="attributeTest" type="attributeTest"
|
|
substitutionGroup="kindTest"/>
|
|
|
|
|
|
<xsd:element name="anyElementTest" abstract="true"
|
|
substitutionGroup="kindTest"/>
|
|
|
|
|
|
<span> <xsd:element name="schemaElementTest" type="EQName"
|
|
substitutionGroup="anyElementTest"/>
|
|
</span>
|
|
|
|
<xsd:complexType name="elementTest">
|
|
<xsd:complexContent>
|
|
<xsd:extension base="emptyItemTypeContent">
|
|
<xsd:sequence minOccurs="0">
|
|
<xsd:element name="elementName" type="simpleWildcard"/>
|
|
<xsd:sequence minOccurs="0">
|
|
<span> <xsd:element name="typeName" type="EQName"/>
|
|
</span> <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"/>
|
|
|
|
|
|
<span> <xsd:element name="nameTest" type="EQName"/>
|
|
|
|
</span> <xsd:element name="kindTest" substitutionGroup="itemType"/>
|
|
|
|
<xsd:element name="textTest" type="emptyItemTypeContent"
|
|
substitutionGroup="kindTest"/>
|
|
|
|
<xsd:element name="commentTest" type="emptyItemTypeContent"
|
|
substitutionGroup="kindTest"/>
|
|
|
|
<span> <xsd:element name="namespaceTest" type="emptyItemTypeContent"
|
|
substitutionGroup="kindTest"/>
|
|
|
|
</span> <xsd:element name="anyKindTest" type="emptyItemTypeContent"
|
|
substitutionGroup="kindTest"/>
|
|
|
|
|
|
<span><!-- functionTest variations -->
|
|
<xsd:element name="anyFunctionTest" type="emptyItemTypeContent" substitutionGroup="itemType"/>
|
|
|
|
<xsd:complexType name="typedFunctionTest">
|
|
<xsd:complexContent>
|
|
<xsd:extension base="emptyItemTypeContent">
|
|
<xsd:sequence>
|
|
<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"/>
|
|
|
|
|
|
<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"/>
|
|
|
|
|
|
</span><!-- 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 -->
|
|
<!-- added literalFunctionItemExpr, inlineFunctionItemExpr, and -->
|
|
<!-- dynamicFunctionInvocation for higher-order functions -->
|
|
<span><!-- 2011-11-21: Jim changed "literalFunctionItemExpr" to "namedFunctionRef" -->
|
|
<!-- 2011-11-21: Jim changed "inlineFunctionItemExpr" to "inlineFunctionExpr" -->
|
|
</span> <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"/>
|
|
<span> <xsd:element ref="namedFunctionRef"/>
|
|
<xsd:element ref="inlineFunctionExpr"/>
|
|
<xsd:element ref="dynamicFunctionInvocationExpr"/>
|
|
</span> </xsd:choice>
|
|
</xsd:group>
|
|
|
|
|
|
<!-- step expression -->
|
|
<!-- removed nameTest and Wildcard outer choices per Bugzilla Bug #2523 -->
|
|
<!-- replaced element "predicates" with choice of "predicates" & "dynamicfunctioninv'n" -->
|
|
<xsd:complexType name="stepExpr">
|
|
<xsd:sequence>
|
|
<xsd:choice>
|
|
<xsd:sequence>
|
|
<xsd:element ref="xpathAxis"/>
|
|
<xsd:choice>
|
|
<xsd:element ref="kindTest"/>
|
|
<xsd:element ref="nameTest"/>
|
|
<xsd:element ref="Wildcard"/>
|
|
</xsd:choice>
|
|
</xsd:sequence>
|
|
<xsd:element name="filterExpr">
|
|
<xsd:complexType>
|
|
<xsd:sequence>
|
|
<xsd:group ref="filterExpr"/>
|
|
</xsd:sequence>
|
|
</xsd:complexType>
|
|
</xsd:element>
|
|
</xsd:choice>
|
|
<xsd:element name="predicates" type="exprList" minOccurs="0"/>
|
|
</xsd:sequence>
|
|
</xsd:complexType>
|
|
|
|
<xsd:element name="stepExpr" type="stepExpr"/>
|
|
|
|
<span> <!-- 2011-09-09/JM - Added mapStepExpr -->
|
|
<xsd:element name="mapStepExpr" type="stepExpr"/>
|
|
|
|
|
|
</span><!-- path expression -->
|
|
<!-- rewrote pathExpr definition per Bugzilla Bug #2523 -->
|
|
<!-- 2011-09-09/JM - Added mapStepExpr -->
|
|
<xsd:complexType name="pathExpr">
|
|
<xsd:complexContent>
|
|
<xsd:extension base="expr">
|
|
<xsd:choice>
|
|
<xsd:sequence>
|
|
<xsd:element name="rootExpr" type="emptyContent"/>
|
|
<span> <xsd:choice minOccurs="0" maxOccurs="unbounded">
|
|
<xsd:element ref="stepExpr"/>
|
|
<xsd:element ref="mapStepExpr"/>
|
|
</xsd:choice>
|
|
</xsd:sequence>
|
|
<xsd:choice maxOccurs="unbounded">
|
|
<xsd:element ref="stepExpr"/>
|
|
<xsd:element ref="mapStepExpr"/>
|
|
</xsd:choice>
|
|
</span> </xsd:choice>
|
|
</xsd:extension>
|
|
</xsd:complexContent>
|
|
</xsd:complexType>
|
|
|
|
<xsd:element name="pathExpr" type="pathExpr" substitutionGroup="expr"/>
|
|
|
|
|
|
<!-- The following constructs deal with the query prolog -->
|
|
<xsd:complexType name="module">
|
|
<xsd:sequence>
|
|
<xsd:element ref="versionDecl" minOccurs="0"/>
|
|
<xsd:choice>
|
|
<xsd:element ref="mainModule"/>
|
|
<xsd:element ref="libraryModule"/>
|
|
</xsd:choice>
|
|
</xsd:sequence>
|
|
</xsd:complexType>
|
|
|
|
<xsd:element name="module" type="module"/>
|
|
|
|
|
|
<xsd:complexType name="mainModule">
|
|
<xsd:sequence>
|
|
<xsd:element ref="prolog" minOccurs="0"/>
|
|
<xsd:element name="queryBody" type="exprWrapper"/>
|
|
</xsd:sequence>
|
|
</xsd:complexType>
|
|
|
|
<xsd:element name="mainModule" type="mainModule"/>
|
|
|
|
|
|
<xsd:complexType name="libraryModule">
|
|
<xsd:sequence>
|
|
<xsd:element ref="moduleDecl"/>
|
|
<xsd:element ref="prolog" minOccurs="0"/>
|
|
</xsd:sequence>
|
|
</xsd:complexType>
|
|
|
|
<xsd:element name="libraryModule" type="libraryModule"/>
|
|
|
|
|
|
<xsd:complexType name="versionDecl">
|
|
<xsd:sequence>
|
|
<xsd:element name="version" type="xsd:string" minOccurs="0"/>
|
|
<span> <xsd:element name="encoding" type="xsd:string" minOccurs="0"/>
|
|
</span> </xsd:sequence>
|
|
</xsd:complexType>
|
|
|
|
<xsd:element name="versionDecl" type="versionDecl"/>
|
|
|
|
|
|
<xsd:complexType name="prolog">
|
|
<xsd:sequence>
|
|
<xsd:element ref="prologPartOneItem" minOccurs="0" maxOccurs="unbounded"/>
|
|
<xsd:element ref="prologPartTwoItem" minOccurs="0" maxOccurs="unbounded"/>
|
|
</xsd:sequence>
|
|
</xsd:complexType>
|
|
|
|
<xsd:element name="prolog" type="prolog"/>
|
|
|
|
|
|
<xsd:element name="prologPartOneItem" abstract="true"/>
|
|
|
|
|
|
<xsd:element name="prologPartTwoItem" abstract="true"/>
|
|
|
|
|
|
<span> <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"/>
|
|
|
|
|
|
</span> <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"/>
|
|
|
|
|
|
<span> <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:restriction>
|
|
</xsd:simpleType>
|
|
</xsd:element>
|
|
<xsd:element name="decimalFormatParamValue" type="xsd:string"/>
|
|
</xsd:sequence>
|
|
</xsd:complexType>
|
|
</xsd:element>
|
|
</xsd:sequence>
|
|
<xsd:attribute name="default" default="false">
|
|
<xsd:simpleType>
|
|
<xsd:restriction base="xsd:NMTOKEN">
|
|
<xsd:enumeration value="true"/>
|
|
<xsd:enumeration value="false"/>
|
|
</xsd:restriction>
|
|
</xsd:simpleType>
|
|
</xsd:attribute>
|
|
</xsd:complexType>
|
|
|
|
<xsd:element name="decimalFormatDecl" type="decimalFormatDeclType"
|
|
substitutionGroup="prologPartOneItem"/>
|
|
|
|
|
|
</span> <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"/>
|
|
|
|
|
|
<span> <xsd:complexType name="contextItemDecl">
|
|
<xsd:sequence>
|
|
<xsd:element ref="typeDeclaration" minOccurs="0"/>
|
|
<xsd:choice>
|
|
<xsd:element name="varValue" type="exprWrapper"/>
|
|
<xsd:sequence>
|
|
<xsd:element name="external">
|
|
<xsd:complexType>
|
|
<xsd:sequence>
|
|
<xsd:element name="varValue" type="exprWrapper" minOccurs="0"/>
|
|
</xsd:sequence>
|
|
</xsd:complexType>
|
|
</xsd:element>
|
|
</xsd:sequence>
|
|
</xsd:choice>
|
|
</xsd:sequence>
|
|
</xsd:complexType>
|
|
|
|
<xsd:element name="contextItemDecl" type="contextItemDecl"
|
|
substitutionGroup="prologPartTwoItem"/>
|
|
|
|
|
|
<!-- For %-annotations -->
|
|
<xsd:complexType name="annotation">
|
|
<xsd:sequence>
|
|
<xsd:element name="annotationName" type="EQName"/>
|
|
<xsd:element name="arguments" type="exprList" minOccurs="0"/>
|
|
</xsd:sequence>
|
|
</xsd:complexType>
|
|
|
|
|
|
</span> <xsd:complexType name="varDecl">
|
|
<xsd:sequence>
|
|
<span> <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>
|
|
</span> </xsd:sequence>
|
|
</xsd:complexType>
|
|
|
|
<xsd:element name="varDecl" type="varDecl"
|
|
substitutionGroup="prologPartTwoItem"/>
|
|
|
|
|
|
<xsd:complexType name="optionDecl">
|
|
<xsd:sequence>
|
|
<span> <xsd:element name="optionName" type="EQName"/>
|
|
</span> <xsd:element name="optionContents" type="xsd:string"/>
|
|
</xsd:sequence>
|
|
</xsd:complexType>
|
|
|
|
<xsd:element name="optionDecl" type="optionDecl"
|
|
substitutionGroup="prologPartTwoItem"/>
|
|
|
|
|
|
<xsd:complexType name="functionDecl">
|
|
<xsd:sequence>
|
|
<span> <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:attribute name="nondeterministic" use="optional"
|
|
type="xsd:boolean" default="false"/>
|
|
<xsd:attribute name="private" use="optional"
|
|
type="xsd:boolean" default="false"/>
|
|
</span> </xsd:complexType>
|
|
|
|
<xsd:element name="functionDecl" type="functionDecl"
|
|
substitutionGroup="prologPartTwoItem"/>
|
|
|
|
|
|
<xsd:complexType name="param">
|
|
<xsd:sequence>
|
|
<span> <xsd:element name="varName" type="EQName"/>
|
|
</span> <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>
|
|
</pre></div>
|
|
</div>
|
|
<div class="div1">
|
|
<h2><a name="xqx_conformance" id="xqx_conformance"></a>5
|
|
Conformance</h2>
|
|
<p>This section defines the conformance criteria for an XQueryX
|
|
processor (see Figure 1, "Processing Model Overview", in
|
|
<span><a href="#xquery-30">[XQuery 3.0: An XML Query
|
|
Language]</a></span> , <a href=
|
|
"http://www.w3.org/TR/xquery-30/#id-processing-model">Section 2.2
|
|
Processing Model</a> <sup><small>XQ30</small></sup>.</p>
|
|
<p>In this section, the following terms are used to indicate the
|
|
requirement levels defined in <a href="#RFC2119">[RFC 2119]</a>.
|
|
[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.]</p>
|
|
<p>An XQueryX processor that claims to conform to this
|
|
specification MUST implement the XQueryX syntax as defined in
|
|
<a href="#Schema"><b>4 An XML Schema for the XQuery XML
|
|
Syntax</b></a> of this specification and include a claim of Minimal
|
|
Conformance as defined in <span><a href="#xquery-30">[XQuery 3.0:
|
|
An XML Query Language]</a></span> , <a href=
|
|
"http://www.w3.org/TR/xquery-30/#id-minimal-conformance">Section
|
|
5.1 Minimal Conformance</a> <sup><small>XQ30</small></sup>. In
|
|
addition to a claim of Minimal Conformance, it MAY claim
|
|
conformance to one or more optional features defined in
|
|
<span><a href="#xquery-30">[XQuery 3.0: An XML Query
|
|
Language]</a></span> , <a href=
|
|
"http://www.w3.org/TR/xquery-30/#id-conform-optional-features">Section
|
|
5.2 Optional Features</a> <sup><small>XQ30</small></sup>.</p>
|
|
</div>
|
|
</div>
|
|
<div class="back">
|
|
<div class="div1">
|
|
<h2><a name="biblio" id="biblio"></a>A References</h2>
|
|
<dl>
|
|
<dt class="label"><span><a name="xqueryx" id="xqueryx"></a>XML
|
|
Syntax for XQuery 1.0 (XQueryX)</span></dt>
|
|
<dd>
|
|
<div><a href="http://www.w3.org/TR/xqueryx/"><cite>XML Syntax for
|
|
XQuery 1.0 (XQueryX) (Second Edition)</cite></a>, Jim Melton and
|
|
Subramanian Muralidhar, Editors. World Wide Web Consortium, 14
|
|
December 2010. This version is
|
|
http://www.w3.org/TR/2010/REC-xqueryx-20101214/. The <a href=
|
|
"http://www.w3.org/TR/xqueryx/">latest version</a> is available at
|
|
http://www.w3.org/TR/xqueryx/.</div>
|
|
</dd>
|
|
<dt class="label"><span><a name="xquery-30-requirements" id=
|
|
"xquery-30-requirements"></a>XQuery 3.0 Requirements</span></dt>
|
|
<dd>
|
|
<div><a href=
|
|
"http://www.w3.org/TR/xquery-30-requirements/"><cite>XQuery 3.0
|
|
Requirements</cite></a>, Daniel Engovatov, Jonathan Robie, Editors.
|
|
World Wide Web Consortium, 16 September 2010. This
|
|
version is
|
|
http://www.w3.org/TR/2010/WD-xquery-30-requirements-20100916/. The
|
|
<a href="http://www.w3.org/TR/xquery-30-requirements/">latest
|
|
version</a> is available at
|
|
http://www.w3.org/TR/xquery-30-requirements/.</div>
|
|
</dd>
|
|
<dt class="label"><span><a name="xquery-30" id=
|
|
"xquery-30"></a>XQuery 3.0: An XML Query Language</span></dt>
|
|
<dd>
|
|
<div><a href="http://www.w3.org/TR/xquery-30/"><cite>XQuery 3.0: An
|
|
XML Query Language</cite></a>, Jonathan Robie, Don Chamberlin,
|
|
Michael Dyck, John Snelson, Editors. World Wide Web Consortium, 13
|
|
December 2011. This version is
|
|
http://www.w3.org/TR/2011/WD-xquery-30-20111213/. The <a href=
|
|
"http://www.w3.org/TR/xquery-30/">latest version</a> is available
|
|
at http://www.w3.org/TR/xquery-30/.</div>
|
|
</dd>
|
|
<dt class="label"><span><a name="xquery-30-use-cases" id=
|
|
"xquery-30-use-cases"></a>XQuery 3.0 Use Cases</span></dt>
|
|
<dd>
|
|
<div><a href=
|
|
"http://www.w3.org/TR/xquery-30-use-cases/"><cite>XQuery 3.0 Use
|
|
Cases</cite></a>, Tim Kraska, Editor. World Wide Web Consortium, 30
|
|
March 2011. This version is
|
|
http://www.w3.org/TR/2011/WD-xquery-30-use-cases-20110330/. The
|
|
<a href="http://www.w3.org/TR/xquery-30-use-cases/">latest
|
|
version</a> is available at
|
|
http://www.w3.org/TR/xquery-30-use-cases/.</div>
|
|
</dd>
|
|
<dt class="label"><span><a name="xquery-semantics" id=
|
|
"xquery-semantics"></a>XQuery 1.0 and XPath 2.0 Formal
|
|
Semantics</span></dt>
|
|
<dd>
|
|
<div><a href="http://www.w3.org/TR/xquery-semantics/"><cite>XQuery
|
|
1.0 and XPath 2.0 Formal Semantics (Second Edition)</cite></a>,
|
|
Jérôme Siméon, Denise Draper, Peter Frankhauser, <em>et. al.</em>,
|
|
Editors. World Wide Web Consortium, 14 December 2010. This version
|
|
is http://www.w3.org/TR/2010/REC-xquery-semantics-20101214/. The
|
|
<a href="http://www.w3.org/TR/xquery-semantics/">latest version</a>
|
|
is available at http://www.w3.org/TR/xquery-semantics/.</div>
|
|
</dd>
|
|
<dt class="label"><span><a name="RFC2119" id="RFC2119"></a>RFC
|
|
2119</span></dt>
|
|
<dd>
|
|
<div>S. Bradner. <em>Key Words for use in RFCs to Indicate
|
|
Requirement Levels.</em> IETF RFC 2119. See <a href=
|
|
"http://www.ietf.org/rfc/rfc2119.txt">http://www.ietf.org/rfc/rfc2119.txt</a>.</div>
|
|
</dd>
|
|
<dt class="label"><span><a name="RFC3023" id="RFC3023"></a>RFC
|
|
3023</span></dt>
|
|
<dd>
|
|
<div>M. Murata, S. St. Laurent, and D. Kohn. <em>XML Media
|
|
Types</em> IETF RFC 3023 or its successors. See <a href=
|
|
"http://www.ietf.org/rfc/rfc3023.txt">http://www.ietf.org/rfc/rfc3023.txt</a>.</div>
|
|
</dd>
|
|
</dl>
|
|
</div>
|
|
<div class="div1">
|
|
<h2><a name="Stylesheet" id="Stylesheet"></a>B Transforming XQueryX
|
|
to XQuery</h2>
|
|
<p>The following stylesheet converts from XQueryX syntax to XML
|
|
Query syntax. Note the intent of the stylesheet is to produce
|
|
<em>a</em> valid XQuery with the same semantics (see <a href=
|
|
"#xquery-semantics">[XQuery 1.0 and XPath 2.0 Formal
|
|
Semantics]</a>) as the input XQueryX.</p>
|
|
<div class="exampleInner">
|
|
<pre>
|
|
<?xml version="1.0"?>
|
|
<span><!-- ================================================================================ -->
|
|
<!-- Changes from Recommendation (edition 1): -->
|
|
<!-- * In XSLT stylesheet, deleted template for xqx:parenthesizedExpr (bug #4963) -->
|
|
<!-- * In XSLT stylesheet, corrected template for xqx:namespaceDeclaration (bug #5343) -->
|
|
<!-- Changes from Recommendation (edition 2): -->
|
|
<!-- * Added support for new Windowing clause in FLWOR expression -->
|
|
<!-- * Added support for new Group By Clause in FLWOR expression -->
|
|
<!-- * Added support for new Count Clause in FLWOR expression -->
|
|
<!-- * Added support for keyword "outer" on for expression -->
|
|
<!-- * Modified structure of FLWOR clause per "simplified FLWOR expressions" -->
|
|
<!-- * Modified validation syntax per Bugzilla Bug 5472 -->
|
|
<!-- * Modified function declaration so that external functions can be nondeterminstic -->
|
|
<!-- * Modified variable declaration so external variables can have an initial value -->
|
|
<!-- * Added support for new try-catch expression -->
|
|
<!-- * Made changes triggered by Bugzilla Bugs 6309, 6310, and 6311 -->
|
|
<!-- * Modified errlist syntax per Bugzilla Bug 7053 -->
|
|
<!-- * Added support for public/private functions -->
|
|
<!-- * Replaced "outer for" support with support for "allowing empty" -->
|
|
<!-- * Added support for higher-order functions -->
|
|
<!-- * Added support for value-based "switch" expression -->
|
|
<!-- * Changed functionItemExpr child element QName to be functionName for consistency -->
|
|
<!-- ================================================================================ -->
|
|
<!-- Errata applied: -->
|
|
<!-- XQX.E3 - Editorial (Bugzilla Bug 4963) -->
|
|
<!-- XQX.E5 - Editorial (Bugzilla Bug 5343) -->
|
|
<!-- XQX.E9 - Minor technical (Bugzilla Bug 6733) -->
|
|
<!-- ================================================================================ -->
|
|
<!-- Modifications: -->
|
|
<!-- 2008-07-30 - Add XQuery 1.1 grouping and windowing support -->
|
|
<!-- 2008-09-18 - Add XQuery 1.1 count and outer-for support, simplified FLWOR -->
|
|
<!-- 2008-09-27 - Add validation type, nondeterministic function declarations, -->
|
|
<!-- initial values for external variables, try-catch expressions -->
|
|
<!-- 2008-11-14 - Add decimal formatting decl, encoding for version decl, -->
|
|
<!-- context item decl, computed namespace constructor -->
|
|
<!-- 2008-11-25 - Add support for fixes for validate expression, and change to allow -->
|
|
<!-- the count clause to only be an intermediate expression -->
|
|
<!-- 2009-01-13 - Bugs 6309 and 6310 (fixes to details of certain windowing clauses -->
|
|
<!-- 2009-03-03 - tumblingWindowClause syntax now matches slidingWindowClause syntax -->
|
|
<!-- 2009-09-06 - Modified errlist syntax per Bugzilla Bug 7053 -->
|
|
<!-- 2009-10-09 - Added support for private/public functions -->
|
|
<!-- Replace "outer for" with "allowing empty" -->
|
|
<!-- 2009-10-22 - Add support for higher-order functions & switch expression -->
|
|
<!-- 2010-01-06 - Omit parens when following-sibling of rootExpr is stepExpr -->
|
|
<!-- 2010-04-06 - Changed functionItemExpr child QName -> functionName (consistency) -->
|
|
<!-- 2010-06-23 - Added support for partial function application -->
|
|
<!-- 2011-05-04 - Updated structure of catch component of try-catch expression -->
|
|
<!-- 2011-05-04 - Updated validationexpr, mode/type alternatives, type is EQName -->
|
|
<!-- 2011-05-31 - Fixed functionItemExpr and functionCallExpr re: unqualified names -->
|
|
<!-- 2011-07-08 - Added support for concatenation operator || -->
|
|
<!-- 2011-09-09 - Added support for simple mapping operator ! -->
|
|
<!-- 2011-09-09 - Added support for sequenceTypeUnion in typeswitch -->
|
|
<!-- 2011-09-09 - Added support for annotations on inline functions -->
|
|
<!-- 2011-09-14 - Added support for new group-by syntax -->
|
|
<!-- 2011-11-21 - Jim changed "literalFunctionItemExpr" to "namedFunctionRef" -->
|
|
<!-- 2011-11-21 - Jim changed "inlineFunctionItemExpr" to "inlineFunctionExpr" -->
|
|
<!-- ================================================================================ -->
|
|
</span><xsl:stylesheet version="1.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"/>
|
|
|
|
<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="'&lt;'"/>
|
|
<xsl:variable name="GREATERTHAN" select="'&gt;'"/>
|
|
<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="'?'"/>
|
|
<span> <xsl:variable name="EXCLAMATIONMARK" select="'!'"/>
|
|
<xsl:variable name="PERCENT" select="'%'"/>
|
|
</span> <xsl:variable name="ASSIGN" select="':='"/>
|
|
<xsl:variable name="SEPARATOR" select="';'"/>
|
|
<xsl:variable name="PRAGMA_BEGIN" select="'(# '"/>
|
|
<xsl:variable name="PRAGMA_END" select="' #)'"/>
|
|
<span> <xsl:variable name="CONCATENATE" select="'||'"/>
|
|
|
|
|
|
</span> <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>
|
|
|
|
|
|
<!-- To resolve Bugzilla bug #3446, we now escape CR (#xD), NEL (#x85),
|
|
and LINE SEPARATOR (#x2028) characters in text nodes and attribute values.
|
|
Note that this template is invoked for a number of other purposes (e.g.,
|
|
xqx:collation, xqx:namespaceDeclaration) where the presence of such
|
|
characters would be invalid and thus are highly unlikely to appear.
|
|
If they do, then this template will happily escape them, deferring the
|
|
error until the resulting XQuery expression is processed. -->
|
|
<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">&amp;</xsl:with-param>
|
|
<xsl:with-param name="replacement">&amp;amp;</xsl:with-param>
|
|
</xsl:call-template>
|
|
</xsl:with-param>
|
|
<xsl:with-param name="toBeReplaced">&lt;</xsl:with-param>
|
|
<xsl:with-param name="replacement">&amp;lt;</xsl:with-param>
|
|
</xsl:call-template>
|
|
</xsl:with-param>
|
|
<xsl:with-param name="toBeReplaced" select="'&#x85;'"/>
|
|
<xsl:with-param name="replacement">&amp;#x85;</xsl:with-param>
|
|
</xsl:call-template>
|
|
</xsl:with-param>
|
|
<xsl:with-param name="toBeReplaced" select="'&#xD;'"/>
|
|
<xsl:with-param name="replacement">&amp;#xD;</xsl:with-param>
|
|
</xsl:call-template>
|
|
</xsl:with-param>
|
|
<xsl:with-param name="toBeReplaced" select="'&#x2028;'"/>
|
|
<xsl:with-param name="replacement">&amp;#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>
|
|
|
|
|
|
<span> <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>
|
|
|
|
</span>
|
|
<span> <xsl:template name="renderEQName"
|
|
match="xqx:QName | 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:value-of select="$DOUBLEQUOTE"/>
|
|
<xsl:value-of select="@xqx:URI"/>
|
|
<xsl:value-of select="$DOUBLEQUOTE"/>
|
|
<xsl:value-of select="$COLON"/>
|
|
<xsl:value-of select="."/>
|
|
</xsl:when>
|
|
<xsl:otherwise>
|
|
<xsl:value-of select="."/>
|
|
</xsl:otherwise>
|
|
</xsl:choose>
|
|
</xsl:otherwise>
|
|
</xsl:choose>
|
|
</xsl:template>
|
|
|
|
|
|
</span> <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>
|
|
<span> <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>
|
|
</span> </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>
|
|
|
|
|
|
<span><!-- 2010-06-23 - Added support for partial function application -->
|
|
<xsl:template match="xqx:argumentPlaceholder">
|
|
<xsl:value-of select="$QUESTIONMARK"/>
|
|
</xsl:template>
|
|
|
|
|
|
<!-- To resolve Bugzilla bug #6733, we now treat a
|
|
rootExpr child of pathExpr distinctly from a
|
|
rootExpr that occurs in other contexts,
|
|
transforming it to "(/)" as proper
|
|
XQuery grammar. There is an additional consideration
|
|
on this: If the immediately following sibling of
|
|
rootExpr is a stepExpr, then the parens must be
|
|
omitted. -->
|
|
<xsl:template match="xqx:pathExpr/xqx:rootExpr">
|
|
<xsl:if test="not(following-sibling::xqx:stepExpr or following-sibling::xqx:mapStepExpr)">
|
|
<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 or following-sibling::xqx:mapStepExpr)">
|
|
<xsl:value-of select="$RPAREN"/>
|
|
</xsl:if>
|
|
</xsl:template>
|
|
|
|
|
|
</span> <xsl:template match="xqx:contextItemExpr">
|
|
<xsl:value-of select="$DOT"/>
|
|
</xsl:template>
|
|
|
|
|
|
<xsl:template match="xqx:stringConstantExpr">
|
|
<xsl:call-template name="quote">
|
|
<xsl:with-param name="item" select="xqx:value"/>
|
|
</xsl:call-template>
|
|
</xsl:template>
|
|
|
|
|
|
<xsl:template match="xqx:integerConstantExpr |
|
|
xqx:decimalConstantExpr |
|
|
xqx:doubleConstantExpr">
|
|
<xsl:value-of select="xqx:value"/>
|
|
</xsl:template>
|
|
|
|
|
|
<xsl:template match="xqx:varRef">
|
|
<xsl:value-of select="$DOLLAR"/>
|
|
<span> <xsl:apply-templates select="xqx:name"/>
|
|
</span> </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>
|
|
|
|
<!-- Response to Bugzilla bug #2528 -->
|
|
<!-- Response to Bugzilla bug #12788 -->
|
|
<xsl:template match="xqx:functionCallExpr">
|
|
<span> <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"/>
|
|
</span> <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>
|
|
|
|
|
|
<span> <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>
|
|
|
|
|
|
</span> <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>
|
|
|
|
<span> <xsl:template match="xqx:allowingEmpty">
|
|
<xsl:text> allowing empty </xsl:text>
|
|
</xsl:template>
|
|
|
|
</span> <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>
|
|
|
|
|
|
<span> <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="@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>
|
|
|
|
|
|
</span> <xsl:template match="xqx:whereClause">
|
|
<xsl:text> where </xsl:text>
|
|
<xsl:apply-templates select="*"/>
|
|
<xsl:value-of select="$NEWLINE"/>
|
|
</xsl:template>
|
|
|
|
|
|
<span> <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>
|
|
|
|
|
|
<!-- 2011-09-14/JM - added the ability to initialize a grouping variable, opt set type -->
|
|
<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>
|
|
|
|
|
|
</span> <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"/>
|
|
<span> <xsl:call-template name="renderQName"/>
|
|
</span> </xsl:template>
|
|
|
|
|
|
<xsl:template match="xqx:variableBinding">
|
|
<xsl:value-of select="$DOLLAR"/>
|
|
<span> <xsl:call-template name="renderEQName"/>
|
|
</span> <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>
|
|
|
|
|
|
<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>
|
|
|
|
|
|
<span> <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>
|
|
|
|
|
|
</span><!-- 2011-09-09/JM - augmented sequenceType with sequenceTypeUnion -->
|
|
<xsl:template match="xqx:typeswitchExprCaseClause">
|
|
<xsl:text> case </xsl:text>
|
|
<xsl:apply-templates select="xqx:variableBinding"/>
|
|
<span> <xsl:apply-templates select="xqx:sequenceType | xqx:sequenceTypeUnion"/>
|
|
</span> <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>
|
|
|
|
|
|
<span> <xsl:template match="xqx:tryCatchExpr">
|
|
<xsl:value-of select="$NEWLINE"/>
|
|
<xsl:text>try </xsl:text>
|
|
<xsl:apply-templates select="xqx:tryClause"/>
|
|
<xsl:apply-templates select="xqx:catchClause"/>
|
|
</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>
|
|
|
|
|
|
</span> <xsl:template match="xqx:validateExpr">
|
|
<xsl:value-of select="$LPAREN"/>
|
|
<xsl:text> validate </xsl:text>
|
|
<span> <xsl:if test="xqx:validationMode">
|
|
<xsl:value-of select="xqx:validationMode"/>
|
|
<xsl:value-of select="$SPACE"/>
|
|
</xsl:if>
|
|
<xsl:if test="xqx:sequenceType">
|
|
<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"/>
|
|
</span> <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>
|
|
|
|
|
|
<span> <!-- 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>
|
|
|
|
|
|
</span> <xsl:template match="xqx:star">
|
|
<xsl:value-of select="$STAR"/>
|
|
</xsl:template>
|
|
|
|
|
|
<xsl:template match="xqx:Wildcard[*]">
|
|
<span> <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:call-template name="quote">
|
|
<xsl:with-param name="item" select="xqx:uri"/>
|
|
</xsl:call-template>
|
|
<xsl:value-of select="$COLON"/>
|
|
<xsl:apply-templates select="xqx:star"/>
|
|
</xsl:when>
|
|
</xsl:choose>
|
|
</span> </xsl:template>
|
|
|
|
|
|
<xsl:template match="xqx:Wildcard[not(*)]">
|
|
<xsl:value-of select="$STAR"/>
|
|
</xsl:template>
|
|
|
|
|
|
<!-- select="xqx:EQname" fixed to be select="xqx"QName"; bug 12674 -->
|
|
<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>
|
|
|
|
|
|
<span> <xsl:template match="xqx:namespaceTest">
|
|
<xsl:text>namespace-node()</xsl:text>
|
|
</xsl:template>
|
|
|
|
|
|
</span> <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>
|
|
|
|
<!-- // THIS IS WRONG!! A nameText is a QName *OR* a Wildcard!!! -->
|
|
<xsl:template match="xqx:nameTest">
|
|
<span> <xsl:call-template name="renderEQName"/>
|
|
</span> </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"/>
|
|
<span> <xsl:call-template name="renderEQName"/>
|
|
</span> <xsl:value-of select="$RPAREN"/>
|
|
</xsl:template>
|
|
|
|
|
|
<xsl:template match="xqx:schemaAttributeTest">
|
|
<xsl:text>schema-attribute</xsl:text>
|
|
<xsl:value-of select="$LPAREN"/>
|
|
<span> <xsl:call-template name="renderEQName"/>
|
|
</span> <xsl:value-of select="$RPAREN"/>
|
|
</xsl:template>
|
|
|
|
|
|
<span> <!-- anyFunctionTest, part of higher-order functions -->
|
|
<xsl:template match="xqx:anyFunctionTest">
|
|
<xsl:text> function(*)</xsl:text>
|
|
</xsl:template>
|
|
|
|
|
|
<!-- typedFunctionTest, part of higher-order functions -->
|
|
<xsl:template match="xqx:typedFunctionTest">
|
|
<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>
|
|
|
|
|
|
<!-- parenthesizedItemType, part of higher-order functions -->
|
|
<xsl:template match="xqx:parenthesizedItemType">
|
|
<xsl:text> ( </xsl:text>
|
|
<xsl:apply-templates/>
|
|
<xsl:text> ) </xsl:text>
|
|
</xsl:template>
|
|
|
|
|
|
</span> <!-- rewrote test expression per Bugzilla Bug #2523 -->
|
|
<!-- 2011-09-09/JM - Added mapStepExpr -->
|
|
<xsl:template match="xqx:stepExpr">
|
|
<span> <xsl:if test="preceding-sibling::xqx:stepExpr or preceding-sibling::xqx:mapStepExpr">
|
|
</span> <xsl:value-of select="$SLASH"/>
|
|
</xsl:if>
|
|
<xsl:apply-templates select="*"/>
|
|
</xsl:template>
|
|
|
|
|
|
<span> <!-- 2011-09-09/JM - Added mapStepExpr -->
|
|
<xsl:template match="xqx:mapStepExpr">
|
|
<xsl:if test="preceding-sibling::xqx:stepExpr or preceding-sibling::xqx:mapStepExpr">
|
|
<xsl:value-of select="$EXCLAMATIONMARK"/>
|
|
</xsl:if>
|
|
<xsl:apply-templates select="*"/>
|
|
</xsl:template>
|
|
|
|
|
|
</span> <!-- deleted xqx:parenthesizedExpr per Bugzilla Bug #4963 -->
|
|
<xsl:template match="xqx:filterExpr">
|
|
<xsl:apply-templates/>
|
|
</xsl:template>
|
|
|
|
|
|
<span> <!-- part of higher-order functions -->
|
|
<!-- Response to Bugzilla bug #12788 -->
|
|
<!-- 2011-11-21 - Jim changed "literalFunctionItemExpr" to "namedFunctionRef" -->
|
|
<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 -->
|
|
<!-- 2011-09-09/JM - Added annotations to inline functions -->
|
|
<!-- 2011-11-21 - Jim changed "inlineFunctionItemExpr" to "inlineFunctionExpr" -->
|
|
<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>
|
|
|
|
</span> <!-- rewrote pathExpr template per Bugzilla Bug #2523 -->
|
|
<!-- 2011-09-09/JM - Added mapStepExpr as an alternative -->
|
|
<xsl:template match="xqx:pathExpr">
|
|
<span> <xsl:apply-templates select="xqx:rootExpr | xqx:stepExpr | xqx:mapStepExpr"/>
|
|
</span> </xsl:template>
|
|
|
|
|
|
<!-- To resolve Bugzilla bug #3446, we now escape NL (#xA) and TAB (#x9)
|
|
characters in attribute values -->
|
|
<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="'&#xA;'"/>
|
|
<xsl:with-param name="replacement">&amp;#xA;</xsl:with-param>
|
|
</xsl:call-template>
|
|
</xsl:with-param>
|
|
<xsl:with-param name="toBeReplaced" select="'&#x9;'"/>
|
|
<xsl:with-param name="replacement">&amp;#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>
|
|
|
|
|
|
<!-- replaced xqx:namespaceDeclaration per Bugzilla Bug #5343 -->
|
|
<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>
|
|
|
|
|
|
<span> <xsl:template match="xqx:contentExpr">
|
|
<xsl:apply-templates/>
|
|
</xsl:template>
|
|
|
|
</span> <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>
|
|
|
|
|
|
<span> <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>
|
|
|
|
|
|
</span> <xsl:template match="xqx:piTargetExpr">
|
|
<xsl:value-of select="$LBRACE"/>
|
|
<xsl:apply-templates select="*"/>
|
|
<xsl:value-of select="$RBRACE"/>
|
|
</xsl:template>
|
|
|
|
|
|
<!-- Move value braces into computedPIConstructor template from this template, Bugzilla bug #3442 -->
|
|
<xsl:template match="xqx:piValueExpr">
|
|
<xsl:apply-templates select="*"/>
|
|
</xsl:template>
|
|
|
|
|
|
<!-- Move value braces into this template from piValueExpr template, Bugzilla bug #3442 -->
|
|
<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>
|
|
<span> <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>
|
|
</span> <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>
|
|
|
|
|
|
<span> <xsl:template match="xqx:boundarySpaceDecl">
|
|
<xsl:text>declare boundary-space </xsl:text>
|
|
<xsl:value-of select="."/>
|
|
</xsl:template>
|
|
|
|
|
|
</span> <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>
|
|
|
|
|
|
<span> <xsl:template match="xqx:decimalFormatDecl">
|
|
<xsl:if test="@xqx:default = 'true' and xqx:decimalFormatName">
|
|
<xsl:message terminate="yes">Incorrect XQueryX: xqx:decimalFormatDecl does not allow both @default=true and xqx:decimalFormatName</xsl:message>
|
|
</xsl:if>
|
|
<xsl:text>declare </xsl:text>
|
|
<xsl:if test="@xqx:default = 'true'">
|
|
<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>
|
|
|
|
|
|
</span> <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>
|
|
|
|
|
|
<span><!-- 2011-09-09/JM - added a sequenceTypeUnion type -->
|
|
<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>
|
|
|
|
|
|
</span> <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>
|
|
|
|
|
|
<span> <xsl:template match="xqx:contextItemDecl">
|
|
<xsl:text>declare context item </xsl:text>
|
|
<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: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>
|
|
|
|
|
|
</span> <xsl:template match="xqx:varDecl">
|
|
<span> <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>
|
|
</span> </xsl:if>
|
|
</xsl:template>
|
|
|
|
|
|
<!-- Part of fix for Bugzilla bug #3520 -->
|
|
<xsl:template match="xqx:targetLocation">
|
|
<xsl:choose>
|
|
<xsl:when test="position()=1"> at </xsl:when>
|
|
<xsl:otherwise>,&#xD; </xsl:otherwise>
|
|
</xsl:choose>
|
|
<xsl:call-template name="quote">
|
|
<xsl:with-param name="item" select="."/>
|
|
</xsl:call-template>
|
|
</xsl:template>
|
|
|
|
|
|
<!-- Modified to fix Bugzilla bug #3520 -->
|
|
<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>
|
|
|
|
|
|
<!-- Modified to fix Bugzilla bug #3520 -->
|
|
<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">
|
|
<span> <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>
|
|
</span> </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>
|
|
|
|
|
|
<xsl:template match="xqx:module" priority="2">
|
|
<xsl:apply-templates select="*"/>
|
|
</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>
|
|
</pre></div>
|
|
</div>
|
|
<div class="div1">
|
|
<h2><a name="xqueryx-id-mime-type" id="xqueryx-id-mime-type"></a>C
|
|
The <code>application/xquery+xml</code> Media Type</h2>
|
|
<p>This Appendix specifies the media type for XQueryX Version 3.0.
|
|
XQueryX is the XML syntax of a language, XQuery, for querying over
|
|
data from XML data sources, as specified in <a href=
|
|
"#xquery-30">[XQuery 3.0: An XML Query Language]</a>.</p>
|
|
<div class="note">
|
|
<p class="prefix"><b>Note:</b></p>
|
|
<p>Specification of media types is described in <a href=
|
|
"#RFC3023">[RFC 3023]</a>.</p>
|
|
</div>
|
|
<div class="div2">
|
|
<h3><a name="xqueryx-mime-introduction" id=
|
|
"xqueryx-mime-introduction"></a>C.1 Introduction</h3>
|
|
<p>This document, together with its normative references, defines
|
|
the XML syntax for the XML Query language XQuery Version 3.0. This
|
|
Appendix specifies the <code>application/xquery+xml</code> media
|
|
type, which is intended to be used for transmitting queries
|
|
expressed in the XQueryX syntax.</p>
|
|
<p>This media type is being submitted to the IESG for review,
|
|
approval, and registration with IANA.</p>
|
|
<p>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 <a href=
|
|
"http://lists.w3.org/Archives/Public/public-qt-comments">http://lists.w3.org/Archives/Public/public-qt-comments</a>.</p>
|
|
</div>
|
|
<div class="div2">
|
|
<h3><a name="xqueryx-mime-registration" id=
|
|
"xqueryx-mime-registration"></a>C.2 Registration of MIME Media Type
|
|
<code>application/xquery+xml</code></h3>
|
|
<p>MIME media type name: <code>application</code></p>
|
|
<p>MIME subtype name: <code>xquery+xml</code></p>
|
|
<p>Required parameters: none</p>
|
|
<p>Optional parameters: <code>charset</code></p>
|
|
<p>This parameter has identical semantics to the
|
|
<code>charset</code> parameter of the <code>application/xml</code>
|
|
media type as specified in [RFC 3023].</p>
|
|
<div class="div3">
|
|
<h4><a name="xqueryx-mime-encoding" id=
|
|
"xqueryx-mime-encoding"></a>C.2.1 Encoding Considerations</h4>
|
|
<p>By virtue of XSLT content being XML, it has the same
|
|
considerations when sent as "<code>application/xquery+xml</code>"
|
|
as does XML. See [RFC 3023], section 3.2.</p>
|
|
</div>
|
|
<div class="div3">
|
|
<h4><a name="xqueryx-mime-security" id=
|
|
"xqueryx-mime-security"></a>C.2.2 Security Considerations</h4>
|
|
<p>Queries written in XQuery may cause arbitrary URIs or IRIs to be
|
|
dereferenced. Therefore, the security issues of [RFC3987] Section 8
|
|
should be considered. In addition, the contents of resources
|
|
identified by <code>file:</code> URIs can in some cases be
|
|
accessed, processed and returned as results. XQuery expressions can
|
|
invoke any of the functions defined in XQuery 1.0 and XPath 2.0
|
|
Functions and Operators, including <code>file-exists()</code>; a
|
|
<code>doc()</code> function also allows local filesystem probes as
|
|
well as access to any URI-defined resource accessible from the
|
|
system evaluating the XQuery expression.</p>
|
|
<p>XQuery is a full declarative programming language, and supports
|
|
user-defined functions, external function libraries (modules)
|
|
referenced by URI, and system-specific "native" functions.</p>
|
|
<p>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.</p>
|
|
<p>The XML Query Working group is working on a facility to allow
|
|
XQuery expressions to be used to create and update persistent data.
|
|
Untrusted queries should not be given write access to data.</p>
|
|
<p>Furthermore, because the XQuery language permits extensions, it
|
|
is possible that application/xquery may describe content that has
|
|
security implications beyond those described here.</p>
|
|
</div>
|
|
<div class="div3">
|
|
<h4><a name="xqueryx-mime-interoperability" id=
|
|
"xqueryx-mime-interoperability"></a>C.2.3 Interoperability
|
|
Considerations</h4>
|
|
<p>See <a href=
|
|
"http://www.w3.org/TR/xquery-30/#id-xquery-conformance">Section 5
|
|
Conformance</a> <sup><small>XQ30</small></sup>.</p>
|
|
</div>
|
|
<div class="div3">
|
|
<h4><a name="xqueryx-mime-pubspec" id=
|
|
"xqueryx-mime-pubspec"></a>C.2.4 Published specification</h4>
|
|
<p>This media type registration is for XQueryX documents as
|
|
described by the XQueryX 3.0 specification, which is located at
|
|
<a href=
|
|
"http://www.w3.org/TR/xqueryx-30/">http://www.w3.org/TR/xqueryx-30/</a>.
|
|
It is also appropriate to use this media type with later versions
|
|
of the XQueryX language.</p>
|
|
</div>
|
|
<div class="div3">
|
|
<h4><a name="xqueryx-mime-applications" id=
|
|
"xqueryx-mime-applications"></a>C.2.5 Applications That Use This
|
|
Media Type</h4>
|
|
<p>The public <a href="http://www.w3.org/XML/Query/">XQuery Web
|
|
page</a> lists more than two dozen implementations of the XQuery
|
|
language, both proprietary and open source. Some of these are known
|
|
to support XQueryX.</p>
|
|
<p>This new media type is being registered to allow for deployment
|
|
of XQueryX on the World Wide Web.</p>
|
|
<p>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.0 on the World Wide Web, as a first class XML application.</p>
|
|
</div>
|
|
<div class="div3">
|
|
<h4><a name="xqueryx-mime-additional" id=
|
|
"xqueryx-mime-additional"></a>C.2.6 Additional Information</h4>
|
|
<div class="div4">
|
|
<h5><a name="xqueryx-mime-recognizing" id=
|
|
"xqueryx-mime-recognizing"></a>C.2.6.1 Recognizing XQuery Files
|
|
("Magic Numbers")</h5>
|
|
<p>Although no byte sequences can be counted 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.</p>
|
|
</div>
|
|
<div class="div4">
|
|
<h5><a name="xqueryx-mime-extensions" id=
|
|
"xqueryx-mime-extensions"></a>C.2.6.2 File Extensions</h5>
|
|
<p>The most common file extension in use for XQueryX is
|
|
<code>.xqx</code>.</p>
|
|
</div>
|
|
<div class="div4">
|
|
<h5><a name="xqueryx-mime-macfiletype" id=
|
|
"xqueryx-mime-macfiletype"></a>C.2.6.3 Macintosh File Type
|
|
Code(s)</h5>
|
|
<p>The appropriate Macintosh file type code is
|
|
<code>TEXT</code>.</p>
|
|
</div>
|
|
</div>
|
|
<div class="div3">
|
|
<h4><a name="xqueryx-mime-author" id=
|
|
"xqueryx-mime-author"></a>C.2.7 Person and Email Address to Contact
|
|
For Further Information</h4>
|
|
<p>Jim Melton, Oracle Corp., <a href=
|
|
"mailto:jim.melton@oracle.com">jim.melton@oracle.com</a></p>
|
|
</div>
|
|
<div class="div3">
|
|
<h4><a name="xqueryx-mime-intended-usage" id=
|
|
"xqueryx-mime-intended-usage"></a>C.2.8 Intended Usage</h4>
|
|
<p>COMMON</p>
|
|
</div>
|
|
<div class="div3">
|
|
<h4><a name="xqueryx-mime-restrictions" id=
|
|
"xqueryx-mime-restrictions"></a>C.2.9 Restrictions on usage</h4>
|
|
<p>The intended usage of this media type is for interchange of
|
|
XQueryX expressions.</p>
|
|
</div>
|
|
<div class="div3">
|
|
<h4><a name="xqueryx-mime-owner" id="xqueryx-mime-owner"></a>C.2.10
|
|
Author/Change Controller</h4>
|
|
<p>XQuery 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.</p>
|
|
</div>
|
|
<div class="div3">
|
|
<h4><a name="xqueryx-mime-fragments" id=
|
|
"xqueryx-mime-fragments"></a>C.2.11 Fragment Identifiers</h4>
|
|
<p>For documents labeled as "<code>application/xquery+xml</code>",
|
|
the fragment identifier notation is exactly that for
|
|
"<code>application/xml</code>", as specified in [RFC 3023].</p>
|
|
</div>
|
|
</div>
|
|
</div>
|
|
<div class="div1">
|
|
<h2><a name="changelog" id="changelog"></a>D Change log
|
|
(Non-Normative)</h2>
|
|
<p>This appendix lists the changes that have been made to this
|
|
specification since the publication of the XQueryX 1.0
|
|
Recommendation on 23 January 2007.</p>
|
|
<div class="div2">
|
|
<h3><a name="changelog_substantive" id=
|
|
"changelog_substantive"></a>D.1 Substantive changes</h3>
|
|
<p>In the Working Draft of 13 December 2011, the following
|
|
substantive changes have been made relative to XQueryX 1.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.</p>
|
|
<table border="1" cellpadding="5" width="100%">
|
|
<thead>
|
|
<tr>
|
|
<td>Change</td>
|
|
<td>Bugzilla</td>
|
|
<td>Category</td>
|
|
<td>Description</td>
|
|
</tr>
|
|
</thead>
|
|
<tbody>
|
|
<tr>
|
|
<td>Group By clause in FLWOR expression.</td>
|
|
<td>None.</td>
|
|
<td>Substantive.</td>
|
|
<td>A new clause was added to the FLWOR expression to allow query
|
|
writers to cause groups of tuples to be created based on the values
|
|
of some expression.</td>
|
|
</tr>
|
|
<tr>
|
|
<td>Window clause in FLWOR expression.</td>
|
|
<td>None.</td>
|
|
<td>Substantive.</td>
|
|
<td>A new clause was added to the FLWOR expression to allow query
|
|
writers to create sliding and tumbling windows of tuples based on a
|
|
number of criteria.</td>
|
|
</tr>
|
|
<tr>
|
|
<td>Simplification of FLWOR expression.</td>
|
|
<td>None.</td>
|
|
<td>Substantive.</td>
|
|
<td>The syntax of the FLWOR expression was considerably relaxed,
|
|
permitting most clauses (other than the return clause) to be used
|
|
at almost any position (only a few clauses are allowed to be the
|
|
first clause) within a FLWOR expression.</td>
|
|
</tr>
|
|
<tr>
|
|
<td>Outer for supported in FLWOR expressions.</td>
|
|
<td>None.</td>
|
|
<td>Substantive.</td>
|
|
<td>The syntax of the for clause in FLWOR expressions was extended
|
|
to allow the use of "outer for".</td>
|
|
</tr>
|
|
<tr>
|
|
<td>Count clause in FLWOR expression.</td>
|
|
<td>None.</td>
|
|
<td>Substantive.</td>
|
|
<td>A new clause was added to the FLWOR expression to allow query
|
|
writers to capture the total number of items that are returned by a
|
|
(portion of a) FLWOR expression.</td>
|
|
</tr>
|
|
<tr>
|
|
<td>Declaration of decimal number formats.</td>
|
|
<td>None.</td>
|
|
<td>Substantive.</td>
|
|
<td>A new option was added to the query prologue, allowing query
|
|
authors to specify a named (or an unnamed default) format for
|
|
decimal numbers. This allows the specification of such items as the
|
|
decimal separator, the minus sign, the percent and per mille signs,
|
|
and even the class of Unicode digits.</td>
|
|
</tr>
|
|
<tr>
|
|
<td>Query version and encoding declaration.</td>
|
|
<td>None.</td>
|
|
<td>Substantive.</td>
|
|
<td>Allows specification of either or both of the version of XQuery
|
|
to which a query adheres and the encoding of the query (e.g., UTF8,
|
|
ISO8859-1).</td>
|
|
</tr>
|
|
<tr>
|
|
<td>Enhanced validation expression.</td>
|
|
<td><a href=
|
|
"http://www.w3.org/Bugs/Public/show_bug.cgi?id=5472">[XQuery 1.1]
|
|
Requirement: validation by type</a></td>
|
|
<td>Substantive.</td>
|
|
<td>Permits query authors to validate an expression against a
|
|
specified XML Schema type.</td>
|
|
</tr>
|
|
<tr>
|
|
<td>Nondeterministic external functions.</td>
|
|
<td>None.</td>
|
|
<td>Substantive.</td>
|
|
<td>Functions declared to be external functions can also be
|
|
specified to be deterministic or nondeterministic.</td>
|
|
</tr>
|
|
<tr>
|
|
<td>Syntax used to provide default value for external
|
|
variables.</td>
|
|
<td>None.</td>
|
|
<td>Minor.</td>
|
|
<td>The declaration of external variables now uses ":=" to indicate
|
|
the default value given to such variables, instead of the keyword
|
|
"default".</td>
|
|
</tr>
|
|
<tr>
|
|
<td>Try/catch for error handling.</td>
|
|
<td>None.</td>
|
|
<td>Substantive.</td>
|
|
<td>A try/catch facility is provided that allows query authors to
|
|
control how errors are handled when raised by evaluation of
|
|
queries.</td>
|
|
</tr>
|
|
<tr>
|
|
<td>Context item declaration.</td>
|
|
<td>None.</td>
|
|
<td>Substantive.</td>
|
|
<td>It is now possible to declare both the type of and the default
|
|
initial value of the context item of a query, and to specify
|
|
whether its value may be provided by the external environment.</td>
|
|
</tr>
|
|
<tr>
|
|
<td>Computed namespace constructor.</td>
|
|
<td>None.</td>
|
|
<td>Substantive.</td>
|
|
<td>Added new complex type and element to XQueryX schema, and new
|
|
template to XQueryX stylesheet, in support of computed namespace
|
|
constructors in XQuery 1.1.</td>
|
|
</tr>
|
|
<tr>
|
|
<td>Generate proper syntax for variable names in positional
|
|
variable bindings.</td>
|
|
<td><a href=
|
|
"http://www.w3.org/Bugs/Public/show_bug.cgi?id=6309">[XQX30]
|
|
template for positionalVariableBinding</a></td>
|
|
<td>Substantive.</td>
|
|
<td>Modified XQueryX stylesheet template to correctly generate a
|
|
"$" preceding the variable name.</td>
|
|
</tr>
|
|
<tr>
|
|
<td>Allow positional variable bindings to be optional in window
|
|
variables.</td>
|
|
<td><a href=
|
|
"http://www.w3.org/Bugs/Public/show_bug.cgi?id=6310">[XQX30]
|
|
positionalVariableBinding should be optional in windowVars</a></td>
|
|
<td>Substantive.</td>
|
|
<td>Modified XQueryX schema to add minOccurs="0" on element
|
|
positionalVariableBinding in windowVars complex type
|
|
definition.</td>
|
|
</tr>
|
|
<tr>
|
|
<td>XQueryX syntax must allow wildcards in the try/catch error
|
|
list.</td>
|
|
<td><a href=
|
|
"http://www.w3.org/Bugs/Public/show_bug.cgi?id=7053">[XQX30] cannot
|
|
represent a catchErrorList wildcard in XQueryX</a></td>
|
|
<td>Substantive.</td>
|
|
<td>In XQueryX schema, modified catchErrorList complex type
|
|
definition to allow a choice between a nameText (essentially a
|
|
QName) and a Wildcard. In XQueryX stylesheet, modified
|
|
catchErrorList template to support Wildcard as well as
|
|
nameText.</td>
|
|
</tr>
|
|
<tr>
|
|
<td>Private functions.</td>
|
|
<td>None.</td>
|
|
<td>Substantive.</td>
|
|
<td>In XQueryX schema, added new attribute "private" in
|
|
functionDecl complex type. In XQUeryX stylesheet, template for
|
|
functionDecl, added support for @private (generate "private" for
|
|
private functions and "public" for others)</td>
|
|
</tr>
|
|
<tr>
|
|
<td>Replace "outer for" with "allowing empty".</td>
|
|
<td>None.</td>
|
|
<td>Substantive.</td>
|
|
<td>In XQueryX schema, forClause complex type, delete attribute
|
|
"outer"; in forClauseItem complex type, add new element
|
|
allowingEmpty. In XQueryX stylesheet template for forClause, remove
|
|
generation of "outer"; in template for forClauseItem, generate
|
|
"allowing empty".</td>
|
|
</tr>
|
|
<tr>
|
|
<td>Higher-order functions.</td>
|
|
<td>None.</td>
|
|
<td>Substantive.</td>
|
|
<td>Made changes to XQueryX schema and stylesheet corresponding to
|
|
new higher-order function syntax in XQuery 1.1.</td>
|
|
</tr>
|
|
<tr>
|
|
<td>New "switch" expression ("value switch", analogous to
|
|
typeswitch).</td>
|
|
<td>None.</td>
|
|
<td>Substantive.</td>
|
|
<td>Made changes to XQueryX schema and stylesheet corresponding to
|
|
new switch syntax in XQuery 3.0.</td>
|
|
</tr>
|
|
<tr>
|
|
<td>Support for partial function application.</td>
|
|
<td>None.</td>
|
|
<td>Substantive.</td>
|
|
<td>Made changes to XQueryX schema and stylesheet to support the
|
|
partial function application capability of XQuery 3.0.</td>
|
|
</tr>
|
|
<tr>
|
|
<td>XML Schema and XSLT Stylesheet</td>
|
|
<td><a href=
|
|
"http://www.w3.org/Bugs/Public/show_bug.cgi?id=11792#c3">lack of
|
|
syntactic symmetry between the control flow expressions</a></td>
|
|
<td>Substantive.</td>
|
|
<td>Eliminated the possibility of defining three "error variables"
|
|
as part of the catch clause; those variables (and others) are now
|
|
implicitly defined, and may be used without explicit definition. At
|
|
the same time, fixed a bug in the schema and stylesheet that
|
|
recognized and produced invalid syntax for the validation
|
|
expression.</td>
|
|
</tr>
|
|
</tbody>
|
|
</table>
|
|
<p>In the Working Draft of 13 December 2011, the following
|
|
substantive changes have been made relative to the preceding draft
|
|
of this document. 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.</p>
|
|
<table border="1" cellpadding="5" width="100%">
|
|
<thead>
|
|
<tr>
|
|
<td>Change</td>
|
|
<td>Bugzilla</td>
|
|
<td>Category</td>
|
|
<td>Description</td>
|
|
</tr>
|
|
</thead>
|
|
<tbody>
|
|
<tr>
|
|
<td>XML Schema and XSLT Stylesheet</td>
|
|
<td>None.</td>
|
|
<td>Substantive.</td>
|
|
<td>Added support for the string concatenation operator
|
|
("||").</td>
|
|
</tr>
|
|
<tr>
|
|
<td>XML Schema and XSLT Stylesheet</td>
|
|
<td>None.</td>
|
|
<td>Substantive.</td>
|
|
<td>Added support for the simple mapping operator ("!").</td>
|
|
</tr>
|
|
<tr>
|
|
<td>XML Schema and XSLT Stylesheet</td>
|
|
<td>None.</td>
|
|
<td>Substantive.</td>
|
|
<td>Added support for the sequenceTypeUnion in the typeswitch
|
|
expression.</td>
|
|
</tr>
|
|
<tr>
|
|
<td>XML Schema and XSLT Stylesheet</td>
|
|
<td>None.</td>
|
|
<td>Substantive.</td>
|
|
<td>Added support for the annotations on inline functions.</td>
|
|
</tr>
|
|
<tr>
|
|
<td>XML Schema and XSLT Stylesheet</td>
|
|
<td>None.</td>
|
|
<td>Substantive.</td>
|
|
<td>Added support for new group-by syntax.</td>
|
|
</tr>
|
|
<tr>
|
|
<td>XML Schema and XSLT Stylesheet</td>
|
|
<td>None.</td>
|
|
<td>Substantive.</td>
|
|
<td>Replaced the element named "literalFunctionItemExpr" with an
|
|
identical element named "namedFunctionRef"; Replaced the element
|
|
named "inlineFunctionItemExpr" with an identical element named
|
|
"inlineFunctionExpr"</td>
|
|
</tr>
|
|
</tbody>
|
|
</table>
|
|
</div>
|
|
<div class="div2">
|
|
<h3><a name="changelog_incompatibilities" id=
|
|
"changelog_incompatibilities"></a>D.2 Incompatibilities</h3>
|
|
<p>The Working Draft of 13 December 2011, contains the following
|
|
incompatibilities with XQueryX 1.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.</p>
|
|
<table border="1" cellpadding="5" width="100%">
|
|
<thead>
|
|
<tr>
|
|
<td>Change</td>
|
|
<td>Bugzilla</td>
|
|
<td>Category</td>
|
|
<td>Description</td>
|
|
</tr>
|
|
</thead>
|
|
<tbody>
|
|
<tr>
|
|
<td>(none)</td>
|
|
<td>—</td>
|
|
<td>—</td>
|
|
<td>—</td>
|
|
</tr>
|
|
</tbody>
|
|
</table>
|
|
</div>
|
|
<div class="div2">
|
|
<h3><a name="changelog_editorial" id="changelog_editorial"></a>D.3
|
|
Editorial changes</h3>
|
|
<p>In the Working Draft of 13 December 2011, the following
|
|
editorial changes have been made relative to XQueryX 1.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.</p>
|
|
<table border="1" cellpadding="5" width="100%">
|
|
<thead>
|
|
<tr>
|
|
<td>Change</td>
|
|
<td>Bugzilla</td>
|
|
<td>Category</td>
|
|
<td>Description</td>
|
|
</tr>
|
|
</thead>
|
|
<tbody>
|
|
<tr>
|
|
<td>Erratum XQX.E1</td>
|
|
<td><a href=
|
|
"http://www.w3.org/Bugs/Public/show_bug.cgi?id=4924">Arguably
|
|
incorrect element definition in XQueryX's Schema.</a></td>
|
|
<td>Editorial.</td>
|
|
<td>The published XQueryX 1.0 schema defined many elements using
|
|
anonymous complex types. That made it infeasible to extend the
|
|
content model of those elements in other specifications that define
|
|
XQueryX extensions corresponding perhaps to XQuery extensions.
|
|
While conceptually simple, a number of changes were required to
|
|
ensure that all elements are defined using named complex
|
|
types.</td>
|
|
</tr>
|
|
<tr>
|
|
<td>Erratum XQX.E2 and Erratum XQX.E3</td>
|
|
<td><a href=
|
|
"http://www.w3.org/Bugs/Public/show_bug.cgi?id=4963">Removed
|
|
element xqx:parenthesizedExpr used in example.</a></td>
|
|
<td>Editorial.</td>
|
|
<td>The XQueryX solution to Example 4 incorrectly contained an
|
|
<xqx:parenthesizedExpr> element. That element was changed to
|
|
an <xqx:sequenceExpr> element. The XSLT stylesheet in
|
|
Appendix B contained a template for the transformation of
|
|
<xqx:parenthesizedExpr> elements that was unnecessary and
|
|
confusing; that template was deleted.</td>
|
|
</tr>
|
|
<tr>
|
|
<td>Erratum XQX.E4</td>
|
|
<td><a href=
|
|
"http://www.w3.org/Bugs/Public/show_bug.cgi?id=5323">Bug in XQueryX
|
|
applet</a></td>
|
|
<td>Editorial.</td>
|
|
<td>The XQueryX 1.0 Recommendation linked to an obsolete version of
|
|
the XQuery 1.0 grammar applet. The proper link has now been
|
|
used.</td>
|
|
</tr>
|
|
<tr>
|
|
<td>Erratum XQX.E5</td>
|
|
<td><a href=
|
|
"http://www.w3.org/Bugs/Public/show_bug.cgi?id=5343">Problem with
|
|
{{ and }} in a Namespace Declaration Attribute</a></td>
|
|
<td>Editorial.</td>
|
|
<td>The XSLT stylsheet in Appendix B contained a template for the
|
|
transformation of <xqx:namespaceDeclaration> elements that
|
|
failed to correctly "escape" curly braces in the same manner as
|
|
does the template for the transformation of
|
|
<xqx:attributeConstructor> elements. That template has been
|
|
corrected.</td>
|
|
</tr>
|
|
<tr>
|
|
<td>Introduction.</td>
|
|
<td><a href=
|
|
"http://www.w3.org/Bugs/Public/show_bug.cgi?id=6377">[XQX]
|
|
non-normative notes</a></td>
|
|
<td>Editorial.</td>
|
|
<td>Added text in <a href="#Introduction"><b>1 Introduction</b></a>
|
|
to clarify that Notes are non-normative.</td>
|
|
</tr>
|
|
<tr>
|
|
<td>This appendix.</td>
|
|
<td>None.</td>
|
|
<td>Editorial.</td>
|
|
<td>Reorganized this appendix to more clearly distinguish between
|
|
substantive and editorial changes and to clearly identify
|
|
incompatibilities with the previous Recommendation.</td>
|
|
</tr>
|
|
<tr>
|
|
<td>Version number.</td>
|
|
<td>None.</td>
|
|
<td>Editorial.</td>
|
|
<td>Changed the version number of the spec from 1.1 to 3.0.</td>
|
|
</tr>
|
|
</tbody>
|
|
</table>
|
|
<p>In the Working Draft of 13 December 2011, the following
|
|
editorial changes have been made relative to the preceding draft of
|
|
this document. 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.</p>
|
|
<table border="1" cellpadding="5" width="100%">
|
|
<thead>
|
|
<tr>
|
|
<td>Change</td>
|
|
<td>Bugzilla</td>
|
|
<td>Category</td>
|
|
<td>Description</td>
|
|
</tr>
|
|
</thead>
|
|
<tbody>
|
|
<tr>
|
|
<td>Introduction.<sup>[<a name="FN-ANCH-d2e1458" id=
|
|
"FN-ANCH-d2e1458" href="#d2e1458">1</a>]</sup></td>
|
|
<td><a href=
|
|
"http://www.w3.org/Bugs/Public/show_bug.cgi?id=14045">section 1:
|
|
schema and stylesheet URLs</a></td>
|
|
<td>Editorial.</td>
|
|
<td>Corrected the URI of the XQueryX schema document and
|
|
stylesheet.</td>
|
|
</tr>
|
|
<tr>
|
|
<td>Introduction.</td>
|
|
<td><a href=
|
|
"http://www.w3.org/Bugs/Public/show_bug.cgi?id=14044">section 1:
|
|
version typo</a></td>
|
|
<td>Editorial.</td>
|
|
<td>Corrected the version number of the previous version of
|
|
XQueryX. Also removed normative reference to "this" document and
|
|
replaced it with a reference to the XQueryX 1.0 document.</td>
|
|
</tr>
|
|
</tbody>
|
|
<tbody>
|
|
<tr>
|
|
<td>
|
|
<p class="table.footnote"><sup><a name="d2e1458" id="d2e1458" href=
|
|
"#FN-ANCH-d2e1458">1.</a></sup> This row and all following rows
|
|
were added after the previously-published draft.</p>
|
|
</td>
|
|
</tr>
|
|
</tbody>
|
|
</table>
|
|
</div>
|
|
</div>
|
|
</div>
|
|
</body>
|
|
</html>
|