Copyright © 2005 W3C® (MIT, ERCIM, Keio), All Rights Reserved. W3C liability, trademark and document use rules apply.
This document presents an XML Syntax for [XQuery 1.0: An XML Query Language].
This section describes the status of this document at the time of its publication. Other documents may supersede this document. A list of current W3C publications and the latest revision of this technical report can be found in the W3C technical reports index at http://www.w3.org/TR/.
This is a public W3C Working Draft for review by W3C Members and other interested parties. Publication as a Working Draft does not imply endorsement by the W3C Membership. This is a draft document and may be updated, replaced or obsoleted by other documents at any time. It is inappropriate to cite this document as other than work in progress.
This document specifies an XML syntax for XQuery. The XML Query WG is supplying this document as the resolution of XQuery Issue 153. The XML Query WG anticipates that XQueryX will be an optional conformance feature for XQuery 1.0. The WG invites feedback on the approaches for representing XQuery 1.0 in XML in this Working Draft.
This document has been produced following the procedures set out for the W3C Process. This document was produced through the efforts of the W3C XML Query Working Group (part of the W3C XML Activity). It is designed to be read in conjunction with the following documents: [XQuery 1.0: An XML Query Language] and [XQuery 1.0 and XPath 2.0 Formal Semantics].
Public comments on this document and its open issues are invited. Comments should be sent to the W3C XPath/XQuery mailing list, public-qt-comments@w3.org(archived at http://lists.w3.org/Archives/Public/public-qt-comments/). Commenters are requested to put the string "[XQueryX]" at the beginning of the subject line of email messages involving such comments.
The patent policy for this document is specified in 5 February 2004 W3C Patent Policy. Patent disclosures relevant to this specification may be found on the XML Query Working Group's patent disclosure page. An individual who has actual knowledge of a patent which the individual believes contains Essential Claim(s) with respect to this specification should disclose the information in accordance with section 6 of the W3C Patent Policy.
1 Introduction
2 Mapping the XQuery Syntax
3 Examples from the XML Query Use Cases in XML Syntax
3.1 Example 1
3.1.1 Solution in XQuery:
3.1.2 The Same Solution in XQueryX:
3.1.3 Test:
3.1.4 Corresponding Grammar Abstract Parse Tree
3.2 Example 2
3.2.1 Solution in XQuery:
3.2.2 The same solution in XQueryX:
3.2.3 Test:
3.3 Example 3
3.3.1 Solution in XQuery:
3.3.2 The same solution in XQueryX:
3.3.3 Test:
4 An XML Schema for the XQuery XML Syntax
5 A Trivial Embedding of XQuery
A References
B Transforming XQueryX to XQuery
C The application/xquery+xml Media Type (Non-Normative)
C.1 Introduction
C.2 Registration of MIME Media Type application/xquery+xml
C.2.1 Encoding Considerations
C.2.2 Fragment Identifiers
C.2.3 Restrictions on usage
C.2.4 Security Considerations
C.2.5 Interoperability Considerations
C.2.6 Applications That Use This Media Type
C.2.7 Additional Information
C.2.7.1 Recognizing XQuery Files ("Magic Numbers")
C.2.7.2 File Extensions
C.2.7.3 Macintosh File Type Code(s)
C.2.8 Person and Email Address to Contact For Further Information
C.2.9 Intended Usage
C.2.10 Author/Change Controller
D XQueryX Issues (Non-Normative)
D.1 XQueryX Issue Summary
D.2 XQueryX Issues
The [XML Query 1.0 Requirements] states that "The XML Query Language MAY have more than one syntax binding. One query language syntax MUST be convenient for humans to read and write. One query language syntax MUST be expressed in XML in a way that reflects the underlying structure of the query."
XQueryX is an XML representation of an XQuery. It was created by mapping the productions of the XQuery grammar into XML productions. The result is not particularly convenient for humans to read and write, but it is easy for programs to parse, and because XQueryX is represented in XML, standard XML tools can be used to create, interpret, or modify queries.
There are several environments in which XQueryX may be useful:
Parser Reuse. In heterogeneous environments, a variety of systems may be used to execute a query. One parser can generate XQueryX for all of these systems.
Queries on Queries. Because XQueryX is represented in XML, queries can be queried and can be transformed into new queries. For instance, a query can be performed against a set of XQueryX queries to determine which queries use FLWOR expressions to range over a set of invoices.
Generating Queries. In some XML-oriented programming environments, it may be more convenient to build a query in its XQueryX representation than in the corresponding XQuery representation, since ordinary XML tools can be used.
Embedding Queries in XML. XQueryX can be embedded directly in an XML document.
XQueryX is an XML representation of the abstract syntax found in Appendix A of the [XQuery 1.0: An XML Query Language]. The XQueryX syntax is defined by the XQueryX Schema; see 4 An XML Schema for the XQuery XML Syntax. The XQueryX semantics are defined by a stylesheet that maps an instance of XQueryX to an instance of XQuery; see B Transforming XQueryX to XQuery.
The main data structure in the XQueryX Schema is the set of types that describe expressions. We have chosen to model expressions as an inheritance hierarchy, with an "expr" abstract base class. An alternate approach could be to use groups instead of inheritance hierarchies. This specification does not provide any such alternate approach.
Consider the following productions from the abstract syntax:
FLWORExpr ::= (ForClause | LetClause)+ WhereClause? OrderByClause? "return" ExprSingle ForClause ::= <"for" "$"> VarName TypeDeclaration? PositionalVar? "in" ExprSingle ("," "$" VarName TypeDeclaration? PositionalVar? "in" ExprSingle)* LetClause ::= <"let" "$"> VarName TypeDeclaration? ":=" ExprSingle ("," "$" VarName TypeDeclaration? ":=" ExprSingle)* WhereClause ::= "where" ExprSingle
The following XQueryX Schema definitions reflect the structure of the above productions:
<!-- The base class --> <xsd:complexType name="expr"/> <xsd:element name="expr" type="expr"/> <!-- Simple wrapper class --> <xsd:complexType name="exprWrapper"> <xsd:sequence> <xsd:element ref="expr"/> </xsd:sequence> </xsd:complexType> <xsd:element name="exprWrapper" type="exprWrapper"/> <xsd:complexType name="flworExpr"> <xsd:complexContent> <xsd:extension base="expr"> <xsd:sequence> <xsd:choice maxOccurs="unbounded"> <xsd:element ref="forClause"/> <xsd:element ref="letClause"/> </xsd:choice> <xsd:element name="whereClause" minOccurs="0"/> <xsd:element name="orderByClause" minOccurs="0"/> <xsd:element name="returnClause"/> </xsd:sequence> </xsd:extension> </xsd:complexContent> </xsd:complexType> <xsd:element name="forClauseItem"> <xsd:complexType> <xsd:sequence> <xsd:element ref="typedVariableBinding"/> <xsd:element ref="positionalVariableBinding" minOccurs="0"/> <xsd:element name="forExpr" type="exprWrapper"/> </xsd:sequence> </xsd:complexType> </xsd:element> <xsd:element name="forClause"> <xsd:complexType> <xsd:sequence> <xsd:element ref="forClauseItem" maxOccurs="unbounded"/> </xsd:sequence> </xsd:complexType> </xsd:element> <xsd:element name="letClauseItem"> <xsd:complexType> <xsd:sequence> <xsd:element ref="typedVariableBinding"/> <xsd:element name="letExpr" type="exprWrapper"/> </xsd:sequence> </xsd:complexType> </xsd:element> <xsd:element name="letClause"> <xsd:complexType> <xsd:sequence> <xsd:element ref="letClauseItem" maxOccurs="unbounded"/> </xsd:sequence> </xsd:complexType> </xsd:element> <xsd:element name="whereClause" type="exprWrapper"/> <xsd:element name="returnClause" type="exprWrapper"/>
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.
The following examples are based on the data and queries in the XMP (Experiences and Exemplars) use case in [XML Query Use Cases]. For each example we show the English description of the query, the XQuery solution, the same solution in XQueryX, and the XQuery result of the XQueryX-to-XQuery transformation. The latter is a result of applying the stylesheet in B Transforming XQueryX to XQuery to the XQueryX. It is presented as a sanity-check - the intent of the stylesheet is not to create the identical XQuery that was initially compiled into the given XQueryX, but to produce a valid XQuery with the same semantics.
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. XQueryX is not designed as a convenient syntax for humans to read and write, but instead as a language that is convenient for machine production and modification. The representation is thus oriented toward the use of software that generates XQueries.
Here is Q1 from the [XML Query Use Cases], use case XMP (Experiences and Exemplars): "List books published by Addison-Wesley after 1991, including their year and title."
<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>
<?xml version="1.0" encoding="UTF-8"?> <?xml-stylesheet type="text/xsl" href="xqueryx.xsl"?> <xqx:module xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xqx="http://www.w3.org/2005/02/XQueryX" xsi:schemaLocation="http://www.w3.org/2005/02/XQueryX xqueryx.xsd"> <xqx:mainModule> <xqx:queryBody> <xqx:expr xsi:type="xqx:elementConstructor"> <xqx:tagName>bib</xqx:tagName> <xqx:elementContent> <xqx:exprWrapper> <xqx:expr xsi:type="xqx:flworExpr"> <xqx:forClause> <xqx:forClauseItem> <xqx:typedVariableBinding> <xqx:varName>b</xqx:varName> </xqx:typedVariableBinding> <xqx:forExpr> <xqx:expr xsi:type="xqx:pathExpr"> <xqx:argExpr> <xqx:expr xsi:type="xqx:functionCallExpr"> <xqx:functionName>doc</xqx:functionName> <xqx:parameters> <xqx:exprWrapper> <xqx:expr xsi:type="xqx:stringConstantExpr"> <xqx:value>http://bstore1.example.com/bib.xml</xqx:value> </xqx:expr> </xqx:exprWrapper> </xqx:parameters> </xqx:expr> </xqx:argExpr> <xqx:stepExpr> <xqx:xpathAxis>child</xqx:xpathAxis> <xqx:nameTest>bib</xqx:nameTest> </xqx:stepExpr> <xqx:stepExpr> <xqx:xpathAxis>child</xqx:xpathAxis> <xqx:nameTest>book</xqx:nameTest> </xqx:stepExpr> </xqx:expr> </xqx:forExpr> </xqx:forClauseItem> </xqx:forClause> <xqx:whereClause> <xqx:expr xsi:type="xqx:operatorExpr"> <xqx:infixOp/> <xqx:opType>and</xqx:opType> <xqx:parameters> <xqx:exprWrapper> <xqx:expr xsi:type="xqx:operatorExpr"> <xqx:infixOp/> <xqx:opType>=</xqx:opType> <xqx:parameters> <xqx:exprWrapper> <xqx:expr xsi:type="xqx:pathExpr"> <xqx:argExpr> <xqx:expr xsi:type="xqx:varRef"> <xqx:name>b</xqx:name> </xqx:expr> </xqx:argExpr> <xqx:stepExpr> <xqx:xpathAxis>child</xqx:xpathAxis> <xqx:nameTest>publisher</xqx:nameTest> </xqx:stepExpr> </xqx:expr> </xqx:exprWrapper> <xqx:exprWrapper> <xqx:expr xsi:type="xqx:stringConstantExpr"> <xqx:value>Addison-Wesley</xqx:value> </xqx:expr> </xqx:exprWrapper> </xqx:parameters> </xqx:expr> </xqx:exprWrapper> <xqx:exprWrapper> <xqx:expr xsi:type="xqx:operatorExpr"> <xqx:infixOp/> <xqx:opType>></xqx:opType> <xqx:parameters> <xqx:exprWrapper> <xqx:expr xsi:type="xqx:pathExpr"> <xqx:argExpr> <xqx:expr xsi:type="xqx:varRef"> <xqx:name>b</xqx:name> </xqx:expr> </xqx:argExpr> <xqx:stepExpr> <xqx:xpathAxis>attribute</xqx:xpathAxis> <xqx:nameTest>year</xqx:nameTest> </xqx:stepExpr> </xqx:expr> </xqx:exprWrapper> <xqx:exprWrapper> <xqx:expr xsi:type="xqx:integerConstantExpr"> <xqx:value>1991</xqx:value> </xqx:expr> </xqx:exprWrapper> </xqx:parameters> </xqx:expr> </xqx:exprWrapper> </xqx:parameters> </xqx:expr> </xqx:whereClause> <xqx:returnClause> <xqx:expr xsi:type="xqx:elementConstructor"> <xqx:tagName>book</xqx:tagName> <xqx:attributeList> <xqx:attributeConstructor> <xqx:attributeName>year</xqx:attributeName> <xqx:attributeValueExpr> <xqx:expr xsi:type="xqx:pathExpr"> <xqx:argExpr> <xqx:expr xsi:type="xqx:varRef"> <xqx:name>b</xqx:name> </xqx:expr> </xqx:argExpr> <xqx:stepExpr> <xqx:xpathAxis>attribute</xqx:xpathAxis> <xqx:nameTest>year</xqx:nameTest> </xqx:stepExpr> </xqx:expr> </xqx:attributeValueExpr> </xqx:attributeConstructor> </xqx:attributeList> <xqx:elementContent> <xqx:exprWrapper> <xqx:expr xsi:type="xqx:pathExpr"> <xqx:argExpr> <xqx:expr xsi:type="xqx:varRef"> <xqx:name>b</xqx:name> </xqx:expr> </xqx:argExpr> <xqx:stepExpr> <xqx:xpathAxis>child</xqx:xpathAxis> <xqx:nameTest>title</xqx:nameTest> </xqx:stepExpr> </xqx:expr> </xqx:exprWrapper> </xqx:elementContent> </xqx:expr> </xqx:returnClause> </xqx:expr> </xqx:exprWrapper> </xqx:elementContent> </xqx:expr> </xqx:queryBody> </xqx:mainModule> </xqx:module>
Applying the stylesheet in B Transforming XQueryX to XQuery to the XQueryX solution, we get:
<bib>{ for $b in doc("http://bstore1.example.com/bib.xml")/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>
For comparison, here is the abstract parse tree corresponding to the XQuery for Example 1, as produced by the XQuery grammar applets found at http://www.w3.org/2004/08/applets/xqueryApplet.html.
XPath2 QueryList Module MainModule Prolog QueryBody Expr PathExpr Constructor DirectConstructor DirElemConstructor StartTagOpenRoot < TagQName bib DirAttributeList StartTagClose > DirElemContent ElementContentChar DirElemContent ElementContentChar DirElemContent CommonContent EnclosedExpr Lbrace { Expr FLWORExpr VarName b In in PathExpr FunctionCall QNameLpar doc( PathExpr StringLiteral "http://bstore1.example.com/bib.xml" StepExpr NodeTest NameTest QName bib StepExpr NodeTest NameTest QName book WhereClause Where where AndExpr and ComparisonExpr = PathExpr VarName b StepExpr NodeTest NameTest QName publisher PathExpr StringLiteral "Addison-Wesley" ComparisonExpr > PathExpr VarName b StepExpr At @ NodeTest NameTest QName year PathExpr IntegerLiteral 1991 PathExpr Constructor DirectConstructor DirElemConstructor StartTagOpenRoot < TagQName book DirAttributeList S TagQName year ValueIndicator = DirAttributeValue OpenQuot " QuotAttrValueContent CommonContent EnclosedExpr Lbrace { Expr PathExpr VarName b StepExpr At @ NodeTest NameTest QName year Rbrace } CloseQuot " StartTagClose > DirElemContent ElementContentChar DirElemContent ElementContentChar DirElemContent ElementContentChar DirElemContent ElementContentChar DirElemContent ElementContentChar DirElemContent ElementContentChar DirElemContent CommonContent EnclosedExpr Lbrace { Expr PathExpr VarName b StepExpr NodeTest NameTest QName title Rbrace } DirElemContent ElementContentChar DirElemContent ElementContentChar DirElemContent ElementContentChar DirElemContent ElementContentChar DirElemContent ElementContentChar EndTagOpen </ TagQName book EndTagClose > Rbrace } DirElemContent ElementContentChar EndTagOpen </ TagQName bib EndTagClose >
Here is Q4 from the [XML Query Use Cases], use case XMP (Experiences and Exemplars): "For each author in the bibliography, list the author's name and the titles of all books by that author, grouped inside a "result" element."
<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>
<?xml version="1.0" encoding="UTF-8"?> <?xml-stylesheet type="text/xsl" href="xqueryx.xsl"?> <xqx:module xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xqx="http://www.w3.org/2005/02/XQueryX" xsi:schemaLocation="http://www.w3.org/2005/02/XQueryX xqueryx.xsd"> <xqx:mainModule> <xqx:queryBody> <xqx:expr xsi:type="xqx:elementConstructor"> <xqx:tagName>results</xqx:tagName> <xqx:elementContent> <xqx:exprWrapper> <xqx:expr xsi:type="xqx:flworExpr"> <xqx:letClause> <xqx:letClauseItem> <xqx:typedVariableBinding> <xqx:varName>a</xqx:varName> </xqx:typedVariableBinding> <xqx:letExpr> <xqx:expr xsi:type="xqx:pathExpr"> <xqx:argExpr> <xqx:expr xsi:type="xqx:functionCallExpr"> <xqx:functionName>doc</xqx:functionName> <xqx:parameters> <xqx:exprWrapper> <xqx:expr xsi:type="xqx:stringConstantExpr"> <xqx:value>http://bstore1.example.com/bib/bib.xml</xqx:value> </xqx:expr> </xqx:exprWrapper> </xqx:parameters> </xqx:expr> </xqx:argExpr> <xqx:stepExpr> <xqx:xpathAxis>descendant-or-self</xqx:xpathAxis> <xqx:nameTest>author</xqx:nameTest> </xqx:stepExpr> </xqx:expr> </xqx:letExpr> </xqx:letClauseItem> </xqx:letClause> <xqx:forClause> <xqx:forClauseItem> <xqx:typedVariableBinding> <xqx:varName>last</xqx:varName> </xqx:typedVariableBinding> <xqx:forExpr> <xqx:expr xsi:type="xqx:functionCallExpr"> <xqx:functionName>distinct-values</xqx:functionName> <xqx:parameters> <xqx:exprWrapper> <xqx:expr xsi:type="xqx:pathExpr"> <xqx:argExpr> <xqx:expr xsi:type="xqx:varRef"> <xqx:name>a</xqx:name> </xqx:expr> </xqx:argExpr> <xqx:stepExpr> <xqx:xpathAxis>child</xqx:xpathAxis> <xqx:nameTest>last</xqx:nameTest> </xqx:stepExpr> </xqx:expr> </xqx:exprWrapper> </xqx:parameters> </xqx:expr> </xqx:forExpr> </xqx:forClauseItem> <xqx:forClauseItem> <xqx:typedVariableBinding> <xqx:varName>first</xqx:varName> </xqx:typedVariableBinding> <xqx:forExpr> <xqx:expr xsi:type="xqx:functionCallExpr"> <xqx:functionName>distinct-values</xqx:functionName> <xqx:parameters> <xqx:exprWrapper> <xqx:expr xsi:type="xqx:pathExpr"> <xqx:argExpr> <xqx:expr xsi:type="xqx:varRef"> <xqx:name>a</xqx:name> </xqx:expr> </xqx:argExpr> <xqx:predicates> <xqx:exprWrapper> <xqx:expr xsi:type="xqx:operatorExpr"> <xqx:infixOp/> <xqx:opType>=</xqx:opType> <xqx:parameters> <xqx:exprWrapper> <xqx:expr xsi:type="xqx:pathExpr"> <xqx:argExpr> <xqx:expr xsi:type="xqx:contextItemExpr"/> </xqx:argExpr> <xqx:stepExpr> <xqx:xpathAxis>child</xqx:xpathAxis> <xqx:nameTest>last</xqx:nameTest> </xqx:stepExpr> </xqx:expr> </xqx:exprWrapper> <xqx:exprWrapper> <xqx:expr xsi:type="xqx:varRef"> <xqx:name>last</xqx:name> </xqx:expr> </xqx:exprWrapper> </xqx:parameters> </xqx:expr> </xqx:exprWrapper> </xqx:predicates> <xqx:stepExpr> <xqx:xpathAxis>child</xqx:xpathAxis> <xqx:nameTest>first</xqx:nameTest> </xqx:stepExpr> </xqx:expr> </xqx:exprWrapper> </xqx:parameters> </xqx:expr> </xqx:forExpr> </xqx:forClauseItem> </xqx:forClause> <xqx:orderByClause> <xqx:orderBySpec> <xqx:orderByExpr> <xqx:expr xsi:type="xqx:varRef"> <xqx:name>last</xqx:name> </xqx:expr> </xqx:orderByExpr> </xqx:orderBySpec> <xqx:orderBySpec> <xqx:orderByExpr> <xqx:expr xsi:type="xqx:varRef"> <xqx:name>first</xqx:name> </xqx:expr> </xqx:orderByExpr> </xqx:orderBySpec> </xqx:orderByClause> <xqx:returnClause> <xqx:expr xsi:type="xqx:elementConstructor"> <xqx:tagName>result</xqx:tagName> <xqx:elementContent> <xqx:exprWrapper> <xqx:expr xsi:type="xqx:elementConstructor"> <xqx:tagName>author</xqx:tagName> <xqx:elementContent> <xqx:exprWrapper> <xqx:expr xsi:type="xqx:elementConstructor"> <xqx:tagName>last</xqx:tagName> <xqx:elementContent> <xqx:exprWrapper> <xqx:expr xsi:type="xqx:varRef"> <xqx:name>last</xqx:name> </xqx:expr> </xqx:exprWrapper> </xqx:elementContent> </xqx:expr> </xqx:exprWrapper> <xqx:exprWrapper> <xqx:expr xsi:type="xqx:elementConstructor"> <xqx:tagName>first</xqx:tagName> <xqx:elementContent> <xqx:exprWrapper> <xqx:expr xsi:type="xqx:varRef"> <xqx:name>first</xqx:name> </xqx:expr> </xqx:exprWrapper> </xqx:elementContent> </xqx:expr> </xqx:exprWrapper> </xqx:elementContent> </xqx:expr> </xqx:exprWrapper> <xqx:exprWrapper> <xqx:expr xsi:type="xqx:flworExpr"> <xqx:forClause> <xqx:forClauseItem> <xqx:typedVariableBinding> <xqx:varName>b</xqx:varName> </xqx:typedVariableBinding> <xqx:forExpr> <xqx:expr xsi:type="xqx:pathExpr"> <xqx:argExpr> <xqx:expr xsi:type="xqx:functionCallExpr"> <xqx:functionName>doc</xqx:functionName> <xqx:parameters> <xqx:exprWrapper> <xqx:expr xsi:type="xqx:stringConstantExpr"> <xqx:value>http://bstore1.example.com/bib.xml</xqx:value> </xqx:expr> </xqx:exprWrapper> </xqx:parameters> </xqx:expr> </xqx:argExpr> <xqx:stepExpr> <xqx:xpathAxis>child</xqx:xpathAxis> <xqx:nameTest>bib</xqx:nameTest> </xqx:stepExpr> <xqx:stepExpr> <xqx:xpathAxis>child</xqx:xpathAxis> <xqx:nameTest>book</xqx:nameTest> </xqx:stepExpr> </xqx:expr> </xqx:forExpr> </xqx:forClauseItem> </xqx:forClause> <xqx:whereClause> <xqx:expr xsi:type="xqx:quantifiedExpr"> <xqx:quantifier>some</xqx:quantifier> <xqx:quantifiedExprInClause> <xqx:typedVariableBinding> <xqx:varName>ba</xqx:varName> </xqx:typedVariableBinding> <xqx:sourceExpr> <xqx:expr xsi:type="xqx:pathExpr"> <xqx:argExpr> <xqx:expr xsi:type="xqx:varRef"> <xqx:name>b</xqx:name> </xqx:expr> </xqx:argExpr> <xqx:stepExpr> <xqx:xpathAxis>child</xqx:xpathAxis> <xqx:nameTest>author</xqx:nameTest> </xqx:stepExpr> </xqx:expr> </xqx:sourceExpr> </xqx:quantifiedExprInClause> <xqx:predicateExpr> <xqx:expr xsi:type="xqx:operatorExpr"> <xqx:infixOp/> <xqx:opType> and </xqx:opType> <xqx:parameters> <xqx:exprWrapper> <xqx:expr xsi:type="xqx:operatorExpr"> <xqx:infixOp/> <xqx:opType>=</xqx:opType> <xqx:parameters> <xqx:exprWrapper> <xqx:expr xsi:type="xqx:pathExpr"> <xqx:argExpr> <xqx:expr xsi:type="xqx:varRef"> <xqx:name>ba</xqx:name> </xqx:expr> </xqx:argExpr> <xqx:stepExpr> <xqx:xpathAxis>child</xqx:xpathAxis> <xqx:nameTest>last</xqx:nameTest> </xqx:stepExpr> </xqx:expr> </xqx:exprWrapper> <xqx:exprWrapper> <xqx:expr xsi:type="xqx:varRef"> <xqx:name>last</xqx:name> </xqx:expr> </xqx:exprWrapper> </xqx:parameters> </xqx:expr> </xqx:exprWrapper> <xqx:exprWrapper> <xqx:expr xsi:type="xqx:operatorExpr"> <xqx:infixOp/> <xqx:opType>=</xqx:opType> <xqx:parameters> <xqx:exprWrapper> <xqx:expr xsi:type="xqx:pathExpr"> <xqx:argExpr> <xqx:expr xsi:type="xqx:varRef"> <xqx:name>ba</xqx:name> </xqx:expr> </xqx:argExpr> <xqx:stepExpr> <xqx:xpathAxis>child</xqx:xpathAxis> <xqx:nameTest>first</xqx:nameTest> </xqx:stepExpr> </xqx:expr> </xqx:exprWrapper> <xqx:exprWrapper> <xqx:expr xsi:type="xqx:varRef"> <xqx:name>first</xqx:name> </xqx:expr> </xqx:exprWrapper> </xqx:parameters> </xqx:expr> </xqx:exprWrapper> </xqx:parameters> </xqx:expr> </xqx:predicateExpr> </xqx:expr> </xqx:whereClause> <xqx:returnClause> <xqx:expr xsi:type="xqx:pathExpr"> <xqx:argExpr> <xqx:expr xsi:type="xqx:varRef"> <xqx:name>b</xqx:name> </xqx:expr> </xqx:argExpr> <xqx:stepExpr> <xqx:xpathAxis>child</xqx:xpathAxis> <xqx:nameTest>title</xqx:nameTest> </xqx:stepExpr> </xqx:expr> </xqx:returnClause> </xqx:expr> </xqx:exprWrapper> </xqx:elementContent> </xqx:expr> </xqx:returnClause> </xqx:expr> </xqx:exprWrapper> </xqx:elementContent> </xqx:expr> </xqx:queryBody> </xqx:mainModule> </xqx:module>
Applying the stylesheet in B Transforming XQueryX to XQuery to the XQueryX solution, we get:
<results>{ let $a:=doc("http://bstore1.example.com/bib/bib.xml")/descendant-or-self::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>
Here is Q7 from the [XML Query Use Cases], use case XMP (Experiences and Exemplars): "List the titles and years of all books published by Addison-Wesley after 1991, in alphabetic order."
<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>
<?xml version="1.0" encoding="UTF-8"?> <?xml-stylesheet type="text/xsl" href="xqueryx.xsl"?> <xqx:module xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xqx="http://www.w3.org/2005/02/XQueryX" xsi:schemaLocation="http://www.w3.org/2005/02/XQueryX xqueryx.xsd"> <xqx:mainModule> <xqx:queryBody> <xqx:expr xsi:type="xqx:elementConstructor"> <xqx:tagName>bib</xqx:tagName> <xqx:elementContent> <xqx:exprWrapper> <xqx:expr xsi:type="xqx:flworExpr"> <xqx:forClause> <xqx:forClauseItem> <xqx:typedVariableBinding> <xqx:varName>b</xqx:varName> </xqx:typedVariableBinding> <xqx:forExpr> <xqx:expr xsi:type="xqx:pathExpr"> <xqx:argExpr> <xqx:expr xsi:type="xqx:functionCallExpr"> <xqx:functionName>doc</xqx:functionName> <xqx:parameters> <xqx:exprWrapper> <xqx:expr xsi:type="xqx:stringConstantExpr"> <xqx:value>http://bstore1.example.com/bib.xml</xqx:value> </xqx:expr> </xqx:exprWrapper> </xqx:parameters> </xqx:expr> </xqx:argExpr> <xqx:stepExpr> <xqx:xpathAxis>descendant-or-self</xqx:xpathAxis> <xqx:nameTest>book</xqx:nameTest> </xqx:stepExpr> </xqx:expr> </xqx:forExpr> </xqx:forClauseItem> </xqx:forClause> <xqx:whereClause> <xqx:expr xsi:type="xqx:operatorExpr"> <xqx:infixOp/> <xqx:opType>and</xqx:opType> <xqx:parameters> <xqx:exprWrapper> <xqx:expr xsi:type="xqx:operatorExpr"> <xqx:infixOp/> <xqx:opType>=</xqx:opType> <xqx:parameters> <xqx:exprWrapper> <xqx:expr xsi:type="xqx:pathExpr"> <xqx:argExpr> <xqx:expr xsi:type="xqx:varRef"> <xqx:name>b</xqx:name> </xqx:expr> </xqx:argExpr> <xqx:stepExpr> <xqx:xpathAxis>child</xqx:xpathAxis> <xqx:nameTest>publisher</xqx:nameTest> </xqx:stepExpr> </xqx:expr> </xqx:exprWrapper> <xqx:exprWrapper> <xqx:expr xsi:type="xqx:stringConstantExpr"> <xqx:value>Addison-Wesley</xqx:value> </xqx:expr> </xqx:exprWrapper> </xqx:parameters> </xqx:expr> </xqx:exprWrapper> <xqx:exprWrapper> <xqx:expr xsi:type="xqx:operatorExpr"> <xqx:infixOp/> <xqx:opType>></xqx:opType> <xqx:parameters> <xqx:exprWrapper> <xqx:expr xsi:type="xqx:pathExpr"> <xqx:argExpr> <xqx:expr xsi:type="xqx:varRef"> <xqx:name>b</xqx:name> </xqx:expr> </xqx:argExpr> <xqx:stepExpr> <xqx:xpathAxis>attribute</xqx:xpathAxis> <xqx:nameTest>year</xqx:nameTest> </xqx:stepExpr> </xqx:expr> </xqx:exprWrapper> <xqx:exprWrapper> <xqx:expr xsi:type="xqx:integerConstantExpr"> <xqx:value>1991</xqx:value> </xqx:expr> </xqx:exprWrapper> </xqx:parameters> </xqx:expr> </xqx:exprWrapper> </xqx:parameters> </xqx:expr> </xqx:whereClause> <xqx:orderByClause> <xqx:orderBySpec> <xqx:orderByExpr> <xqx:expr xsi:type="xqx:pathExpr"> <xqx:argExpr> <xqx:expr xsi:type="xqx:varRef"> <xqx:name>b</xqx:name> </xqx:expr> </xqx:argExpr> <xqx:stepExpr> <xqx:xpathAxis>child</xqx:xpathAxis> <xqx:nameTest>title</xqx:nameTest> </xqx:stepExpr> </xqx:expr> </xqx:orderByExpr> </xqx:orderBySpec> </xqx:orderByClause> <xqx:returnClause> <xqx:expr xsi:type="xqx:elementConstructor"> <xqx:tagName>book</xqx:tagName> <xqx:elementContent> <xqx:exprWrapper> <xqx:expr xsi:type="xqx:pathExpr"> <xqx:argExpr> <xqx:expr xsi:type="xqx:varRef"> <xqx:name>b</xqx:name> </xqx:expr> </xqx:argExpr> <xqx:stepExpr> <xqx:xpathAxis>attribute</xqx:xpathAxis> <xqx:nameTest>year</xqx:nameTest> </xqx:stepExpr> </xqx:expr> </xqx:exprWrapper> <xqx:exprWrapper> <xqx:expr xsi:type="xqx:pathExpr"> <xqx:argExpr> <xqx:expr xsi:type="xqx:varRef"> <xqx:name>b</xqx:name> </xqx:expr> </xqx:argExpr> <xqx:stepExpr> <xqx:xpathAxis>child</xqx:xpathAxis> <xqx:nameTest>title</xqx:nameTest> </xqx:stepExpr> </xqx:expr> </xqx:exprWrapper> </xqx:elementContent> </xqx:expr> </xqx:returnClause> </xqx:expr> </xqx:exprWrapper> </xqx:elementContent> </xqx:expr> </xqx:queryBody> </xqx:mainModule> </xqx:module>
Applying the stylesheet in B Transforming XQueryX to XQuery to the XQueryX solution, we get:
<bib>{ for $b in doc("http://bstore1.example.com/bib.xml")/descendant-or-self::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>
Here is the XML Schema for the proposed syntax.
Editorial note | |
In this Working Draft, the XML Schema for the XQuery XML syntax has been hand-crafted. The XML Query Working Group is working towards automatic generation of the Schema from the XQuery grammar. |
<?xml version="1.0" encoding="UTF-8"?> <xsd:schema xmlns="http://www.w3.org/2005/02/XQueryX" xmlns:xsd="http://www.w3.org/2001/XMLSchema" targetNamespace="http://www.w3.org/2005/02/XQueryX" elementFormDefault="qualified" attributeFormDefault="qualified"> <!-- Version 1.2 of the XQueryX schema. Authors: Jim Melton (Oracle Corp.), S. Muralidhar (Microsoft) Modification date: Jan 4, 2004 - Bring inline with xquery language W3C Working Draft 10/29/04 - More uniform naming conventions - Some stylistic issues The main data structure in this schema is the set of types that describe expressions. I've chosen to model expressions as an inheritance hierarchy, with an "expr" abstract base class. All expression instances are elements with the name "expr" and the type attribute set to the most-specific type. The different types for expressions correspond to the different kinds of expressions that we support - constants, variables, functions, builtins, flwor expressions and so on. I've tried to avoid attributes as far as possible (modulo the "type" attribute for expressions), and model these as elements - this is a perfectly arbitrary decision, and can be reversed. I've attempted to create an "exprWrapper" type/element. In most embedded cases, we use this construct, instead of the "expr" element itself - just because I might want to name the element differently. I've also chosen to model the set of builtin operator types as an inheritance hierarchy - mainly because it tended to group things nicely. I don't see a problem with making this simply a large union. --> <!-- A few helper declarations --> <xsd:complexType name="emptyContent"/> <xsd:element name="QName" type="xsd:QName"/> <xsd:element name="NCName" type="xsd:NCName"/> <!-- The base class --> <xsd:complexType name="expr"/> <xsd:element name="expr" type="expr"/> <!-- A list of expressions --> <xsd:complexType name="exprList"> <xsd:sequence> <xsd:element ref="exprWrapper" minOccurs="0" maxOccurs="unbounded"/> </xsd:sequence> </xsd:complexType> <xsd:element name="exprList" type="exprList"/> <!-- Simple wrapper class --> <xsd:complexType name="exprWrapper"> <xsd:sequence> <xsd:element ref="expr"/> </xsd:sequence> </xsd:complexType> <xsd:element name="exprWrapper" type="exprWrapper"/> <!-- 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: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: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: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: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> <!-- Variables --> <xsd:complexType name="varRef"> <xsd:complexContent> <xsd:extension base="expr"> <xsd:sequence> <xsd:element name="name" type="xsd:QName"/> </xsd:sequence> </xsd:extension> </xsd:complexContent> </xsd:complexType> <!-- root and context-item expressions --> <xsd:complexType name="rootExpr"> <xsd:complexContent> <xsd:extension base="expr"/> </xsd:complexContent> </xsd:complexType> <xsd:complexType name="contextItemExpr"> <xsd:complexContent> <xsd:extension base="expr"/> </xsd:complexContent> </xsd:complexType> <!-- Pragmas and extension expressions --> <xsd:element name="pragma"> <xsd:complexType> <xsd:sequence> <xsd:element name="pragmaName" type="xsd:QName"/> <xsd:element name="pragmaContents" type="xsd:string"/> </xsd:sequence> </xsd:complexType> </xsd:element> <xsd:complexType name="extensionExpr"> <xsd:complexContent> <xsd:extension base="expr"> <xsd:sequence> <xsd:element ref="pragma" maxOccurs="unbounded"/> <xsd:element name="argExpr" type="exprWrapper"/> </xsd:sequence> </xsd:extension> </xsd:complexContent> </xsd:complexType> <xsd:complexType name="functionCallExpr"> <xsd:complexContent> <xsd:extension base="expr"> <xsd:sequence> <xsd:element name="functionName" type="xsd:QName"/> <xsd:element name="parameters" type="exprList" minOccurs="0"/> </xsd:sequence> </xsd:extension> </xsd:complexContent> </xsd:complexType> <!-- Constructor functions --> <xsd:complexType name="constructorFunctionExpr"> <xsd:complexContent> <xsd:extension base="expr"> <xsd:sequence> <xsd:element name="typeName" type="xsd:QName"/> <xsd:element name="argExpr" type="exprWrapper"/> </xsd:sequence> </xsd:extension> </xsd:complexContent> </xsd:complexType> <xsd:complexType name="sequenceExpr"> <xsd:complexContent> <xsd:extension base="expr"> <xsd:sequence> <xsd:element ref="exprList"/> </xsd:sequence> </xsd:extension> </xsd:complexContent> </xsd:complexType> <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> <!-- Inheritance hierarchy for operator types --> <xsd:simpleType name="opTypes"> <xsd:restriction base="xsd:string"/> </xsd:simpleType> <!-- All comparison operators --> <xsd:simpleType name="comparisonOpTypes"> <xsd:restriction base="opTypes"/> </xsd:simpleType> <!-- All arithmetic operators --> <xsd:simpleType name="arithmeticOpTypes"> <xsd:restriction base="opTypes"> <xsd:enumeration value="+"/> <xsd:enumeration value="-"/> <xsd:enumeration value="div"/> <xsd:enumeration value="idiv"/> <xsd:enumeration value="mod"/> <xsd:enumeration value="unaryMinus"/> <xsd:enumeration value="unaryPlus"/> </xsd:restriction> </xsd:simpleType> <xsd:simpleType name="valueComparisonOpTypes"> <xsd:restriction base="comparisonOpTypes"> <xsd:enumeration value="eq"/> <xsd:enumeration value="ne"/> <xsd:enumeration value="gt"/> <xsd:enumeration value="ge"/> <xsd:enumeration value="lt"/> <xsd:enumeration value="le"/> </xsd:restriction> </xsd:simpleType> <xsd:simpleType name="generalComparisonOpTypes"> <xsd:restriction base="comparisonOpTypes"> <xsd:enumeration value="="/> <xsd:enumeration value="!="/> <xsd:enumeration value="<"/> <xsd:enumeration value="<="/> <xsd:enumeration value=">="/> <xsd:enumeration value=">="/> </xsd:restriction> </xsd:simpleType> <xsd:simpleType name="nodeComparisonOpTypes"> <xsd:restriction base="comparisonOpTypes"> <xsd:enumeration value="is"/> </xsd:restriction> </xsd:simpleType> <xsd:simpleType name="orderComparisonOpTypes"> <xsd:restriction base="comparisonOpTypes"> <xsd:enumeration value="<<"/> <xsd:enumeration value=">>"/> </xsd:restriction> </xsd:simpleType> <xsd:simpleType name="logicalOpTypes"> <xsd:restriction base="opTypes"> <xsd:enumeration value="and"/> <xsd:enumeration value="or"/> </xsd:restriction> </xsd:simpleType> <xsd:simpleType name="miscOpTypes"> <xsd:restriction base="opTypes"> <xsd:enumeration value="union"/> <xsd:enumeration value="intersect"/> <xsd:enumeration value="except"/> </xsd:restriction> </xsd:simpleType> <!-- This class describes all builtin-operators --> <xsd:complexType name="operatorExpr"> <xsd:complexContent> <xsd:extension base="expr"> <xsd:sequence> <xsd:element name="infixOp" type="emptyContent" minOccurs="0"/> <xsd:element name="opType" type="opTypes"/> <xsd:element name="parameters" type="exprList"/> </xsd:sequence> </xsd:extension> </xsd:complexContent> </xsd:complexType> <!-- Basic typenames --> <xsd:element name="atomicType" type="xsd:QName"/> <!-- Used in castable expression --> <xsd:element name="singleType"> <xsd:complexType> <xsd:sequence> <xsd:element ref="atomicType"/> <xsd:element name="optional" type="emptyContent" minOccurs="0"/> </xsd:sequence> </xsd:complexType> </xsd:element> <xsd:group name="itemType"> <xsd:choice> <xsd:element ref="atomicType"/> <xsd:group ref="kindTest"/> <xsd:element name="anyItemType" type="emptyContent"/> </xsd:choice> </xsd:group> <xsd:simpleType name="occurrenceIndicator"> <xsd:restriction base="xsd:string"> <xsd:enumeration value="?"/> <xsd:enumeration value="*"/> <xsd:enumeration value="+"/> </xsd:restriction> </xsd:simpleType> <xsd:complexType name="sequenceType"> <xsd:choice> <xsd:element name="emptySequenceType" type="emptyContent"/> <xsd:sequence> <xsd:group ref="itemType"/> <xsd:element name="occurrenceIndicator" type="occurrenceIndicator" minOccurs="0"/> </xsd:sequence> </xsd:choice> </xsd:complexType> <xsd:element name="sequenceType" type="sequenceType"/> <xsd:element name="typeDeclaration" type="sequenceType"/> <!-- Represents a "typed" variable (for clause, let clause etc) --> <xsd:element name="typedVariableBinding"> <xsd:complexType> <xsd:sequence> <xsd:element name="varName" type="xsd:QName"/> <xsd:element ref="typeDeclaration" minOccurs="0"/> </xsd:sequence> </xsd:complexType> </xsd:element> <xsd:element name="positionalVariableBinding" type="xsd:QName"/> <xsd:element name="variableBinding" type="xsd:QName"/> <xsd:element name="forClauseItem"> <xsd:complexType> <xsd:sequence> <xsd:element ref="typedVariableBinding"/> <xsd:element ref="positionalVariableBinding" minOccurs="0"/> <xsd:element name="forExpr" type="exprWrapper"/> </xsd:sequence> </xsd:complexType> </xsd:element> <xsd:element name="forClause"> <xsd:complexType> <xsd:sequence> <xsd:element ref="forClauseItem" maxOccurs="unbounded"/> </xsd:sequence> </xsd:complexType> </xsd:element> <xsd:element name="letClauseItem"> <xsd:complexType> <xsd:sequence> <xsd:element ref="typedVariableBinding"/> <xsd:element name="letExpr" type="exprWrapper"/> </xsd:sequence> </xsd:complexType> </xsd:element> <xsd:element name="letClause"> <xsd:complexType> <xsd:sequence> <xsd:element ref="letClauseItem" maxOccurs="unbounded"/> </xsd:sequence> </xsd:complexType> </xsd:element> <xsd:element name="whereClause" type="exprWrapper"/> <xsd:element name="returnClause" type="exprWrapper"/> <xsd:simpleType name="emptyOrderingMode"> <xsd:restriction base="xsd:string"> <xsd:enumeration value="empty greatest"/> <xsd:enumeration value="empty least"/> </xsd:restriction> </xsd:simpleType> <xsd:simpleType name="orderingKind"> <xsd:restriction base="xsd:string"> <xsd:enumeration value="ascending"/> <xsd:enumeration value="descending"/> </xsd:restriction> </xsd:simpleType> <xsd:element name="orderModifier"> <xsd:complexType> <xsd:sequence> <xsd:element name="orderingKind" type="orderingKind" minOccurs="0" maxOccurs="unbounded"> </xsd:element> <xsd:element name="emptyOrderingMode" type="emptyOrderingMode" minOccurs="0" maxOccurs="unbounded"/> <xsd:element name="collation" type="xsd:string" minOccurs="0"/> </xsd:sequence> </xsd:complexType> </xsd:element> <xsd:element name="orderBySpec"> <xsd:complexType> <xsd:sequence> <xsd:element name="orderByExpr" type="exprWrapper"/> <xsd:element ref="orderModifier" minOccurs="0"/> </xsd:sequence> </xsd:complexType> </xsd:element> <xsd:element name="orderByClause"> <xsd:complexType> <xsd:sequence> <xsd:element name="stable" type="emptyContent" minOccurs="0"/> <xsd:element ref="orderBySpec" maxOccurs="unbounded"/> </xsd:sequence> </xsd:complexType> </xsd:element> <!-- This is the flwor expression --> <xsd:complexType name="flworExpr"> <xsd:complexContent> <xsd:extension base="expr"> <xsd:sequence> <xsd:choice maxOccurs="unbounded"> <xsd:element ref="forClause"/> <xsd:element ref="letClause"/> </xsd:choice> <xsd:element ref="whereClause" minOccurs="0"/> <xsd:element ref="orderByClause" minOccurs="0"/> <xsd:element ref="returnClause"/> </xsd:sequence> </xsd:extension> </xsd:complexContent> </xsd:complexType> <!-- 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> <!-- The following clauses describe quantified expressions --> <xsd:simpleType name="quantifier"> <xsd:restriction base="xsd:NMTOKEN"> <xsd:enumeration value="some"/> <xsd:enumeration value="every"/> </xsd:restriction> </xsd:simpleType> <xsd:element name="quantifiedExprInClause"> <xsd:complexType> <xsd:sequence> <xsd:element ref="typedVariableBinding"/> <xsd:element name="sourceExpr" type="exprWrapper"/> </xsd:sequence> </xsd:complexType> </xsd:element> <xsd:complexType name="quantifiedExpr"> <xsd:complexContent> <xsd:extension base="expr"> <xsd:sequence> <xsd:element name="quantifier" type="quantifier"/> <xsd:element ref="quantifiedExprInClause" maxOccurs="unbounded"/> <xsd:element name="predicateExpr" type="exprWrapper"/> </xsd:sequence> </xsd:extension> </xsd:complexContent> </xsd:complexType> <!-- handle the typeswitch construct --> <xsd:complexType name="typeswitchExprCaseClause"> <xsd:complexContent> <xsd:extension base="expr"> <xsd:sequence> <xsd:element ref="variableBinding" minOccurs="0"/> <xsd:element ref="typeDeclaration"/> <xsd:element name="resultExpr" type="exprWrapper"/> </xsd:sequence> </xsd:extension> </xsd:complexContent> </xsd:complexType> <xsd: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:complexType name="typeswitchExpr"> <xsd:complexContent> <xsd:extension base="expr"> <xsd:sequence> <xsd:element name="argExpr" type="exprWrapper"/> <xsd:element name="typeswitchExprCaseClause" type="typeswitchExprCaseClause" maxOccurs="unbounded"/> <xsd:element name="typeswitchExprDefaultClause" type="typeswitchExprDefaultClause"/> </xsd:sequence> </xsd:extension> </xsd:complexContent> </xsd:complexType> <!-- 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> <!-- 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> <!-- 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: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> <!-- Validate expressions --> <xsd:simpleType name="validationMode"> <xsd:restriction base="xsd:NMTOKEN"> <xsd:enumeration value="lax"/> <xsd:enumeration value="strict"/> </xsd:restriction> </xsd:simpleType> <xsd:complexType name="validateExpr"> <xsd:complexContent> <xsd:extension base="expr"> <xsd:sequence> <xsd:element name="validationMode" type="validationMode" minOccurs="0"/> <xsd:element name="argExpr" type="exprWrapper"/> </xsd:sequence> </xsd:extension> </xsd:complexContent> </xsd:complexType> <!-- 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="xsd:QName"/> <xsd:choice> <xsd:element name="attributeValueExpr" type="exprWrapper"/> <xsd:element name="attributeValue" type="xsd:string"/> </xsd:choice> </xsd:sequence> </xsd:complexType> <xsd:element name="attributeList"> <xsd:complexType> <xsd:sequence> <xsd:element name="attributeConstructor" type="attributeConstructor" maxOccurs="unbounded"/> </xsd:sequence> </xsd:complexType> </xsd:element> <xsd:element name="elementContent" type="exprList"/> <xsd:complexType name="elementConstructor"> <xsd:complexContent> <xsd:extension base="expr"> <xsd:sequence> <xsd:element name="tagName" type="xsd:QName"/> <xsd:element ref="attributeList" minOccurs="0"/> <xsd:element ref="elementContent" minOccurs="0"/> </xsd:sequence> </xsd:extension> </xsd:complexContent> </xsd:complexType> <!-- computed constructors --> <xsd:complexType name="computedElementConstructor"> <xsd:complexContent> <xsd:extension base="expr"> <xsd:sequence> <xsd:choice> <xsd:element name="tagName" type="xsd:QName"/> <xsd:element name="tagNameExpr" type="exprWrapper"/> </xsd:choice> <xsd:element name="contentExpr" type="exprWrapper" minOccurs="0"/> </xsd:sequence> </xsd:extension> </xsd:complexContent> </xsd:complexType> <xsd:complexType name="computedAttributeConstructor"> <xsd:complexContent> <xsd:extension base="expr"> <xsd:sequence> <xsd:choice> <xsd:element name="tagName" type="xsd:QName"/> <xsd:element name="tagNameExpr" type="exprWrapper"/> </xsd:choice> <xsd:element name="valueExpr" type="exprWrapper" minOccurs="0"/> </xsd:sequence> </xsd:extension> </xsd:complexContent> </xsd:complexType> <xsd: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: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: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: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> <!-- 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: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:complexType name="simpleWildcard"> <xsd:choice> <xsd:element name="QName" type="xsd:QName"/> <xsd:element name="star" type="emptyContent"/> </xsd:choice> </xsd:complexType> <xsd:element name="Wildcard"> <xsd:complexType> <xsd:all> <xsd:element name="star" type="emptyContent" minOccurs="0"/> <xsd:element ref="NCName" minOccurs="0"/> </xsd:all> </xsd:complexType> </xsd:element> <xsd:element name="attributeTest"> <xsd:complexType> <xsd:sequence minOccurs="0"> <xsd:element name="attributeName" type="simpleWildcard"/> <xsd:element name="typeName" type="xsd:QName" minOccurs="0"/> </xsd:sequence> </xsd:complexType> </xsd:element> <xsd:element name="schemaElementTest" type="xsd:QName"/> <xsd:element name="schemaAttributeTest" type="xsd:QName"/> <xsd:element name="elementTest"> <xsd:complexType> <xsd:sequence minOccurs="0"> <xsd:element name="elementName" type="simpleWildcard"/> <xsd:sequence minOccurs="0"> <xsd:element name="typeName" type="xsd:QName"/> <xsd:element name="nillable" type="emptyContent" minOccurs="0"/> </xsd:sequence> </xsd:sequence> </xsd:complexType> </xsd:element> <xsd:element name="documentTest"> <xsd:complexType> <xsd:choice minOccurs="0"> <xsd:element ref="elementTest"/> <xsd:element ref="schemaElementTest"/> </xsd:choice> </xsd:complexType> </xsd:element> <xsd:element name="piTest"> <xsd:complexType> <xsd:choice minOccurs="0"> <xsd:element name="piTarget" type="xsd:NCName"/> <xsd:element name="piValue" type="xsd:string"/> </xsd:choice> </xsd:complexType> </xsd:element> <xsd:element name="nameTest" type="xsd:QName"/> <xsd:group name="kindTest"> <xsd:choice> <xsd:element ref="elementTest"/> <xsd:element ref="schemaElementTest"/> <xsd:element ref="attributeTest"/> <xsd:element ref="schemaAttributeTest"/> <xsd:element name="textTest" type="emptyContent"/> <xsd:element name="commentTest" type="emptyContent"/> <xsd:element name="anyKindTest" type="emptyContent"/> <xsd:element ref="documentTest"/> <xsd:element ref="piTest"/> </xsd:choice> </xsd:group> <xsd:element name="xpathAxis"> <xsd:simpleType> <xsd:restriction base="xsd:NMTOKEN"> <xsd:enumeration value="child"/> <xsd:enumeration value="attribute"/> <xsd:enumeration value="self"/> <xsd:enumeration value="parent"/> <xsd:enumeration value="descendant-or-self"/> <xsd:enumeration value="descendant"/> <xsd:enumeration value="following"/> <xsd:enumeration value="following-sibling"/> <xsd:enumeration value="ancestor"/> <xsd:enumeration value="ancestor-or-self"/> <xsd:enumeration value="preceding"/> <xsd:enumeration value="preceding-sibling"/> </xsd:restriction> </xsd:simpleType> </xsd:element> <xsd:element name="stepExpr"> <xsd:complexType> <xsd:sequence> <xsd:element ref="xpathAxis"/> <xsd:choice> <xsd:group ref="kindTest"/> <xsd:element ref="nameTest"/> <xsd:element ref="Wildcard"/> </xsd:choice> <xsd:element name="predicates" type="exprList" minOccurs="0"/> </xsd:sequence> </xsd:complexType> </xsd:element> <xsd:complexType name="pathExpr"> <xsd:complexContent> <xsd:extension base="expr"> <xsd:sequence> <xsd:element name="argExpr" type="exprWrapper"/> <xsd:element name="predicates" type="exprList" minOccurs="0"/> <xsd:element ref="stepExpr" minOccurs="0" maxOccurs="unbounded"/> </xsd:sequence> </xsd:extension> </xsd:complexContent> </xsd:complexType> <!-- There isn't really a need for this in xqueryx. I think this is a trivial shortcut for pathExpr --> <xsd:complexType name="filterExpr"> <xsd:complexContent> <xsd:extension base="expr"> <xsd:sequence> <xsd:element name="argExpr" type="exprWrapper"/> <xsd:element name="predicates" type="exprList" minOccurs="0"/> </xsd:sequence> </xsd:extension> </xsd:complexContent> </xsd:complexType> <!-- The following constructs deal with the query prolog --> <xsd:element name="module"> <xsd:complexType> <xsd:sequence> <xsd:element ref="versionDecl" minOccurs="0"/> <xsd:choice> <xsd:element ref="mainModule"/> <xsd:element ref="libraryModule"/> </xsd:choice> </xsd:sequence> </xsd:complexType> </xsd:element> <xsd:element name="mainModule"> <xsd:complexType> <xsd:sequence> <xsd:element ref="prolog" minOccurs="0"/> <xsd:element name="queryBody" type="exprWrapper"/> </xsd:sequence> </xsd:complexType> </xsd:element> <xsd:complexType name="namespaceDeclType"> <xsd:sequence> <xsd:element name="prefix" type="xsd:NCName"/> <xsd:element name="uri" type="xsd:string"/> </xsd:sequence> </xsd:complexType> <xsd:element name="namespaceDecl" type="namespaceDeclType"/> <xsd:element name="moduleDecl" type="namespaceDeclType"/> <xsd:element name="libraryModule"> <xsd:complexType> <xsd:sequence> <xsd:element ref="moduleDecl"/> <xsd:element ref="prolog" minOccurs="0"/> </xsd:sequence> </xsd:complexType> </xsd:element> <xsd:element name="versionDecl"> <xsd:complexType> <xsd:sequence> <xsd:element name="version" type="xsd:string"/> <xsd:element name="encoding" type="xsd:string" minOccurs="0"/> </xsd:sequence> </xsd:complexType> </xsd:element> <xsd:element name="prolog"> <xsd:complexType> <xsd:sequence> <xsd:choice minOccurs="0" maxOccurs="unbounded"> <xsd:element ref="boundarySpaceDecl"/> <xsd:element ref="defaultCollationDecl"/> <xsd:element ref="baseUriDecl"/> <xsd:element ref="constructionDecl"/> <xsd:element ref="orderingModeDecl"/> <xsd:element ref="emptyOrderingDecl"/> <xsd:element ref="copyNamespacesDecl"/> </xsd:choice> <xsd:choice minOccurs="0" maxOccurs="unbounded"> <xsd:element ref="defaultNamespaceDecl"/> <xsd:element ref="namespaceDecl"/> <xsd:element ref="schemaImport"/> <xsd:element ref="moduleImport"/> </xsd:choice> <xsd:choice minOccurs="0" maxOccurs="unbounded"> <xsd:element ref="varDecl"/> <xsd:element ref="functionDecl"/> <xsd:element ref="optionDecl"/> </xsd:choice> </xsd:sequence> </xsd:complexType> </xsd:element> <xsd:element name="boundarySpaceDecl"> <xsd:simpleType> <xsd:restriction base="xsd:NMTOKEN"> <xsd:enumeration value="strip"/> <xsd:enumeration value="preserve"/> </xsd:restriction> </xsd:simpleType> </xsd:element> <xsd:element name="defaultCollationDecl" type="xsd:string"/> <xsd:element name="baseUriDecl" type="xsd:string"/> <xsd:element name="orderingModeDecl"> <xsd:simpleType> <xsd:restriction base="xsd:NMTOKEN"> <xsd:enumeration value="ordered"/> <xsd:enumeration value="unordered"/> </xsd:restriction> </xsd:simpleType> </xsd:element> <xsd:element name="emptyOrderingDecl" type="emptyOrderingMode"/> <xsd:element name="constructionDecl"> <xsd:simpleType> <xsd:restriction base="xsd:NMTOKEN"> <xsd:enumeration value="strip"/> <xsd:enumeration value="preserve"/> </xsd:restriction> </xsd:simpleType> </xsd:element> <xsd:element name="copyNamespacesDecl"> <xsd:complexType> <xsd:sequence> <xsd:element name="preserveMode"> <xsd:simpleType> <xsd:restriction base="xsd:NMTOKEN"> <xsd:enumeration value="preserve"/> <xsd:enumeration value="no-preserve"/> </xsd:restriction> </xsd:simpleType> </xsd:element> <xsd:element name="inheritMode"> <xsd:simpleType> <xsd:restriction base="xsd:NMTOKEN"> <xsd:enumeration value="inherit"/> <xsd:enumeration value="no-inherit"/> </xsd:restriction> </xsd:simpleType> </xsd:element> </xsd:sequence> </xsd:complexType> </xsd:element> <xsd:simpleType name="defaultNamespaceCategory"> <xsd:restriction base="xsd:NMTOKEN"> <xsd:enumeration value="function"/> <xsd:enumeration value="element"/> </xsd:restriction> </xsd:simpleType> <xsd:element name="defaultNamespaceDecl"> <xsd:complexType> <xsd:sequence> <xsd:element name="defaultNamespaceCategory" type="defaultNamespaceCategory"/> <xsd:element name="uri" type="xsd:string"/> </xsd:sequence> </xsd:complexType> </xsd:element> <xsd:element name="varDecl"> <xsd:complexType> <xsd:sequence> <xsd:element name="varName" type="xsd:QName"/> <xsd:element ref="typeDeclaration" minOccurs="0"/> <xsd:choice> <xsd:element name="varValue" type="exprWrapper"/> <xsd:element name="external" type="emptyContent"/> </xsd:choice> </xsd:sequence> </xsd:complexType> </xsd:element> <xsd:element name="optionDecl"> <xsd:complexType> <xsd:sequence> <xsd:element name="optionName" type="xsd:QName"/> <xsd:element name="optionContents" type="xsd:string"/> </xsd:sequence> </xsd:complexType> </xsd:element> <xsd:element name="param"> <xsd:complexType> <xsd:sequence> <xsd:element name="varName" type="xsd:QName"/> <xsd:element ref="typeDeclaration" minOccurs="0"/> </xsd:sequence> </xsd:complexType> </xsd:element> <xsd:element name="paramList"> <xsd:complexType> <xsd:sequence> <xsd:element ref="param" minOccurs="0" maxOccurs="unbounded"/> </xsd:sequence> </xsd:complexType> </xsd:element> <xsd:element name="functionDecl"> <xsd:complexType> <xsd:sequence> <xsd:element name="functionName" type="xsd:QName"/> <xsd:element ref="paramList"/> <xsd:element ref="typeDeclaration" minOccurs="0"/> <xsd:choice> <xsd:element name="functionBody" type="exprWrapper"/> <xsd:element name="externalDefinition" type="emptyContent"/> </xsd:choice> </xsd:sequence> </xsd:complexType> </xsd:element> <xsd:element name="moduleImport"> <xsd:complexType> <xsd:sequence> <xsd:element name="namespacePrefix" type="xsd:NCName" minOccurs="0"/> <xsd:element name="targetNamespace" type="xsd:string"/> <xsd:element name="targetLocation" type="xsd:string" minOccurs="0" maxOccurs="unbounded"/> </xsd:sequence> </xsd:complexType> </xsd:element> <xsd:element name="schemaImport"> <xsd:complexType> <xsd:sequence> <xsd:choice minOccurs="0"> <xsd:element name="namespacePrefix" type="xsd:NCName"/> <xsd:element name="defaultElementNamespace" type="emptyContent"/> </xsd:choice> <xsd:element name="targetNamespace" type="xsd:string"/> <xsd:element name="targetLocation" type="xsd:string" minOccurs="0" maxOccurs="unbounded"/> </xsd:sequence> </xsd:complexType> </xsd:element> </xsd:schema>
1 Introduction observed that the [XML Query 1.0 Requirements] says "The XML Query Language MAY have more than one syntax binding. One query language syntax MUST be convenient for humans to read and write. One query language syntax MUST be expressed in XML in a way that reflects the underlying structure of the query." There are many possible ways to define an XML syntax for XQuery. This document specifies two XML Syntaxes for XQuery: the one in 4 An XML Schema for the XQuery XML Syntax and the "trivial embedding" defined in this section. Of course, XQueries could be expressed in XML Syntax in other ways.
The trivial embedding specified here can be used when an XQuery is exchanged with other entities as XML or embedded in an XML document, and when it is not necessary to communicate the underying structure of the query.
The trivial embedding defined in this specification requires that the entire query be enclosed within an element named "XQuery", as illustrated here:
<XQuery>for $i... let $j...where $x = $y...return...</XQuery>
If the XQuery contains characters that are prohibited in XML text (such as < and &), they must be "escaped" as either character entity references or character references.
<XQuery>for $i... let $j...where $x < $y...return...</XQuery>
or
<XQuery>for $i... let $j...where $x &x003C; $y...return...</XQuery>
This limitation may require that user agents scan the XQuery text, escaping such prohibited characters, before transmitting or embedding the XQuery as XML.
The following stylesheet converts from XQueryX syntax to XML Query syntax. Note the intent of the stylesheet is to produce a valid XQuery with the same semantics as the input XQueryX.
<?xml version="1.0"?> <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/02/XQueryX" xmlns="http://www.w3.org/2005/02/XQueryXSL"> <xsl:output method="text"/> <xsl:strip-space elements="*"/> <xsl:variable name="DOT">.</xsl:variable> <xsl:variable name="SPACE"><xsl:text> </xsl:text></xsl:variable> <xsl:variable name="SLASH"><xsl:text>/</xsl:text></xsl:variable> <xsl:variable name="SLASH_SLASH"><xsl:text>//</xsl:text></xsl:variable> <xsl:variable name="LESSTHAN"><xsl:text><</xsl:text></xsl:variable> <xsl:variable name="GREATERTHAN"><xsl:text>></xsl:text></xsl:variable> <xsl:variable name="LPAREN">(</xsl:variable> <xsl:variable name="RPAREN">)</xsl:variable> <xsl:variable name="NEWLINE"><xsl:text> </xsl:text></xsl:variable> <xsl:variable name="COMMA">,</xsl:variable> <xsl:variable name="COMMA_SPACE">, </xsl:variable> <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="TRUE"><xsl:text>true</xsl:text></xsl:variable> <xsl:variable name="TO"><xsl:text> to </xsl:text></xsl:variable> <xsl:variable name="LBRACE"><xsl:text>{</xsl:text></xsl:variable> <xsl:variable name="RBRACE"><xsl:text>}</xsl:text></xsl:variable> <xsl:variable name="LBRACKET"><xsl:text>[</xsl:text></xsl:variable> <xsl:variable name="RBRACKET"><xsl:text>]</xsl:text></xsl:variable> <xsl:variable name="DOLLAR"><xsl:text>$</xsl:text></xsl:variable> <xsl:variable name="MINUS"><xsl:text>-</xsl:text></xsl:variable> <xsl:variable name="PLUS"><xsl:text>+</xsl:text></xsl:variable> <xsl:variable name="EQUAL"><xsl:text>=</xsl:text></xsl:variable> <xsl:variable name="COLON"><xsl:text>:</xsl:text></xsl:variable> <xsl:variable name="DOUBLE_COLON"><xsl:text>::</xsl:text></xsl:variable> <xsl:variable name="SEMICOLON"><xsl:text>;</xsl:text></xsl:variable> <xsl:variable name="AT"><xsl:text>@</xsl:text></xsl:variable> <xsl:variable name="STAR"><xsl:text>*</xsl:text></xsl:variable> <xsl:variable name="QUESTIONMARK"><xsl:text>?</xsl:text></xsl:variable> <xsl:variable name="ASSIGN"> <xsl:value-of select="$COLON"/> <xsl:value-of select="$EQUAL"/> </xsl:variable> <xsl:variable name="SEPARATOR"> <xsl:value-of select="$SEMICOLON"/> </xsl:variable> <xsl:variable name="COMMENT_BEGIN"> <xsl:text><!--</xsl:text> </xsl:variable> <xsl:variable name="COMMENT_END"> <xsl:text>--></xsl:text> </xsl:variable> <xsl:variable name="PI_BEGIN"> <xsl:text><?</xsl:text> </xsl:variable> <xsl:variable name="PI_END"> <xsl:text>?></xsl:text> </xsl:variable> <xsl:variable name="CDATA_BEGIN"> <xsl:text><![CDATA[</xsl:text> </xsl:variable> <xsl:variable name="CDATA_END"> <xsl:text>]></xsl:text> </xsl:variable> <xsl:variable name="PRAGMA_BEGIN"> <xsl:text>(# </xsl:text> </xsl:variable> <xsl:variable name="PRAGMA_END"> <xsl:text> #)</xsl:text> </xsl:variable> <xsl:template name="delimitedList"> <xsl:param name="delimiter" /> <xsl:param name="leftEncloser"/> <xsl:param name="rightEncloser" /> <xsl:param name="selector"></xsl:param> <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="paranthesizedList"> <xsl:param name="delimiter" select="$COMMA_SPACE"/> <xsl:call-template name="delimitedList"> <xsl:with-param name="delimiter" select="$delimiter" /> <xsl:with-param name="leftEncloser" select="$LPAREN"/> <xsl:with-param name="rightEncloser" select="$RPAREN"/> </xsl:call-template> </xsl:template> <xsl:template name="commaSeparatedList"> <xsl:call-template name="delimitedList"> <xsl:with-param name="delimiter"> <xsl:value-of select="$COMMA_SPACE"/> </xsl:with-param> </xsl:call-template> </xsl:template> <xsl:template name="quote"> <xsl:param name="item"/> <xsl:value-of select="$DOUBLEQUOTE"/> <xsl:value-of select="$item"/> <xsl:value-of select="$DOUBLEQUOTE"/> </xsl:template> <xsl:template match="xqx:exprWrapper"> <xsl:apply-templates select="xqx:expr"/> </xsl:template> <xsl:template match="xqx:*[@xsi:type='xqx:exprWrapper']"> <xsl:apply-templates select="xqx:expr"/> </xsl:template> <xsl:template match="xqx:QName"> <xsl:value-of select="."/> </xsl:template> <xsl:template match="xqx:NCName"> <xsl:value-of select="."/> </xsl:template> <xsl:template match="xqx:expr[@xsi:type='xqx:rootExpr']"> <xsl:value-of select="$SLASH"/> </xsl:template> <xsl:template match="xqx:expr[@xsi:type='xqx:contextItemExpr']"> <xsl:value-of select="$DOT"/> </xsl:template> <xsl:template match="xqx:expr[@xsi:type='xqx:stringConstantExpr']"> <xsl:call-template name="quote"> <xsl:with-param name="item" select="xqx:value/text()"/> </xsl:call-template> </xsl:template> <xsl:template match="xqx:expr[@xsi:type='xqx:integerConstantExpr' or @xsi:type='xqx:decimalConstantExpr' or xqx:type='xsd:doubleConstantExpr']"> <xsl:value-of select="xqx:value/text()"/> </xsl:template> <xsl:template match="xqx:expr[@xsi:type='xqx:varRef']"> <xsl:value-of select="$DOLLAR"/> <xsl:value-of select="xqx:name/text()"/> </xsl:template> <xsl:template match="xqx:pragma"> <xsl:value-of select="$PRAGMA_BEGIN"/> <xsl:value-of 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:expr[@xsi:type='xqx:extensionExpr']"> <xsl:apply-templates select="xqx:pragma"/> <xsl:value-of select="$LBRACE"/> <xsl:apply-templates select="xqx:enclosedExpr"/> <xsl:value-of select="$RBRACE"/> </xsl:template> <xsl:template match="xqx:expr[@xsi:type='xqx:functionCallExpr']"> <xsl:value-of select="xqx:functionName/text()"/> <xsl:for-each select="xqx:parameters"> <xsl:call-template name="paranthesizedList"/> </xsl:for-each> </xsl:template> <xsl:template match="xqx:expr[@xsi:type='xqx:constructorFunctionExpr']"> <xsl:value-of select="xqx:typeName"/> <xsl:for-each select="xqx:arg"> <xsl:call-template name="paranthesizedList"/> </xsl:for-each> </xsl:template> <xsl:template match="xqx:opType"> <xsl:choose> <xsl:when test="./text() = 'unaryMinus'"> <xsl:value-of select="$MINUS"/> </xsl:when> <xsl:when test="./text() = 'unaryPlus'"> <xsl:value-of select="$PLUS"/> </xsl:when> <xsl:otherwise> <xsl:value-of select="./text()"/> </xsl:otherwise> </xsl:choose> </xsl:template> <xsl:template name="operatorArgs"> <xsl:param name="opType"/> <xsl:for-each select="xqx:parameters"> <xsl:call-template name="paranthesizedList"> <xsl:with-param name="delimiter"> <xsl:value-of select="$SPACE"/> <xsl:value-of select="$opType"/> <xsl:value-of select="$SPACE"/> </xsl:with-param> </xsl:call-template> </xsl:for-each> </xsl:template> <xsl:template match="xqx:expr[@xsi:type='xqx:operatorExpr']"> <xsl:choose> <xsl:when test="xqx:infixOp"> <xsl:call-template name="operatorArgs"> <xsl:with-param name="opType" select="xqx:opType"/> </xsl:call-template> </xsl:when> <xsl:otherwise> <xsl:apply-templates select="xqx:opType"/> <xsl:for-each select="xqx:parameters"> <xsl:call-template name="paranthesizedList"/> </xsl:for-each> </xsl:otherwise> </xsl:choose> </xsl:template> <xsl:template match="xqx:expr[@xsi:type='xqx:sequenceExpr']"> <xsl:for-each select="*"> <xsl:call-template name="paranthesizedList"> <xsl:with-param name="delimiter" select="$COMMA_NEWLINE"/> </xsl:call-template> </xsl:for-each> </xsl:template> <xsl:template match="xqx:expr[@xsi:type='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 select="xqx:typedVariableBinding"/> <xsl:apply-templates select="xqx:positionalVariableBinding"/> <xsl:text> in </xsl:text> <xsl:apply-templates select="xqx:forExpr"/> </xsl:template> <xsl:template match="xqx:letClauseItem"> <xsl:apply-templates select="xqx:typedVariableBinding"/> <xsl:value-of select="$ASSIGN"/> <xsl:apply-templates select="xqx:letExpr"/> </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:returnClause"> <xsl:text> return </xsl:text> <xsl:apply-templates select="*"/> <xsl:value-of select="$NEWLINE"/> </xsl:template> <xsl:template match="xqx:whereClause"> <xsl:text> where </xsl:text> <xsl:apply-templates select="*"/> <xsl:value-of select="$NEWLINE"/> </xsl:template> <xsl:template match="xqx:collation"> <xsl:text> collation </xsl:text> <xsl:value-of select="$DOUBLEQUOTE"/> <xsl:value-of select="."/> <xsl:value-of select="$DOUBLEQUOTE"/> </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:expr[@xsi:type='xqx:flworExpr']"> <xsl:value-of select="$NEWLINE"/> <xsl:apply-templates select="*"/> </xsl:template> <xsl:template match="xqx:expr[@xsi:type='xqx:ifThenElseExpr']"> <xsl:value-of select="$LPAREN"/> <xsl:text> if </xsl:text> <xsl:apply-templates select="xqx:ifClause"/> <xsl:text> then </xsl:text> <xsl:apply-templates select="xqx:thenClause"/> <xsl:text> else </xsl:text> <xsl:apply-templates select="xqx:elseClause"/> <xsl:value-of select="$RPAREN"/> </xsl:template> <xsl:template match="xqx:positionalVariableBinding"> <xsl:text> at </xsl:text> <xsl:value-of select="$DOLLAR"/> <xsl:value-of select="."/> </xsl:template> <xsl:template match="xqx:variableBinding"> <xsl:value-of select="$DOLLAR"/> <xsl:value-of select="."/> </xsl:template> <xsl:template match="xqx:typedVariableBinding" name="typedVariableBinding"> <xsl:value-of select="$DOLLAR"/> <xsl:value-of 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:expr[@xsi:type='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:expr[@xsi:type='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:expr[@xsi:type='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:expr[@xsi:type='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:expr[@xsi:type='xqx:treatExpr']"> <xsl:value-of select="$LPAREN"/> <xsl:apply-templates select="xqx:argExpr"/> <xsl:text> treat as </xsl:text> <xsl:apply-templates select="xqx:sequenceType"/> <xsl:value-of select="$RPAREN"/> </xsl:template> <xsl:template match="xqx:typeswitchExprCaseClause"> <xsl:text> case </xsl:text> <xsl:apply-templates select="xqx:variableBinding"/> <xsl:apply-templates select="xqx:typeDeclaration"/> <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:expr[@xsi:type='xqx:typeswitchExpr']"> <xsl:value-of select="$LPAREN"/> <xsl:text>typeswitch</xsl:text> <xsl:value-of select="$LPAREN"/> <xsl:apply-templates select="xqx:argExpr"/> <xsl:value-of select="$RPAREN"/> <xsl:apply-templates select="xqx:typeswitchExprCaseClause"/> <xsl:apply-templates select="xqx:typeswitchExprDefaultClause"/> <xsl:value-of select="$RPAREN"/> </xsl:template> <xsl:template match="xqx:expr[@xsi:type='xqx:validateExpr']"> <xsl:value-of select="$LPAREN"/> <xsl:text> validate </xsl:text> <xsl:value-of select="xqx:validationMode"/> <xsl:value-of select="$LBRACE"/> <xsl:apply-templates select="xqx:argExpr"/> <xsl:value-of select="$RBRACE"/> <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> <xsl:template match="xqx:star"> <xsl:value-of select="$STAR"/> </xsl:template> <xsl:template match="xqx:Wildcard"> <xsl:apply-templates select="*[1]"/> <xsl:if test="*[2]"> <xsl:value-of select="$COLON"/> <xsl:apply-templates select="*[2]"/> </xsl:if> </xsl:template> <xsl:template name="simpleWildcard" match="xqx:simpleWildcard"> <xsl:apply-templates select="xqx:star"/> <xsl:apply-templates select="xqx:QName"/> </xsl:template> <xsl:template match="xqx:textTest"> <xsl:text>text()</xsl:text> </xsl:template> <xsl:template match="xqx:commentTest"> <xsl:text>comment()</xsl:text> </xsl:template> <xsl:template match="xqx:anyKindTest"> <xsl:text>node()</xsl:text> </xsl:template> <xsl:template match="xqx:piTest"> <xsl:text>processing-instruction</xsl:text> <xsl:value-of select="$LPAREN"/> <xsl:value-of select="*"/> <xsl:value-of select="$RPAREN"/> </xsl:template> <xsl:template match="xqx:documentTest"> <xsl:text>document-node</xsl:text> <xsl:value-of select="$LPAREN"/> <xsl:apply-templates select="*"/> <xsl:value-of select="$RPAREN"/> </xsl:template> <xsl:template match="xqx:nameTest"> <xsl:value-of select="."/> </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:value-of 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:value-of select="xqx:typeName"/> </xsl:if> <xsl:if test="xqx:nillable"> <xsl:value-of select="$QUESTIONMARK"/> </xsl:if> <xsl:value-of select="$RPAREN"/> </xsl:template> <xsl:template match="xqx:schemaElementTest"> <xsl:text>schema-element</xsl:text> <xsl:value-of select="$LPAREN"/> <xsl:value-of select="."/> <xsl:value-of select="$RPAREN"/> </xsl:template> <xsl:template match="xqx:schemaAttributeTest"> <xsl:text>schema-attribute</xsl:text> <xsl:value-of select="$LPAREN"/> <xsl:value-of select="."/> <xsl:value-of select="$RPAREN"/> </xsl:template> <xsl:template match="xqx:stepExpr"> <xsl:value-of select="$SLASH"/> <xsl:apply-templates select="*"/> </xsl:template> <xsl:template match="xqx:expr[@xsi:type='xqx:pathExpr']"> <xsl:apply-templates select="xqx:argExpr"/> <xsl:apply-templates select="xqx:predicates"/> <xsl:apply-templates select="xqx:stepExpr"/> </xsl:template> <xsl:template match="xqx:attributeConstructor"> <xsl:value-of select="$SPACE"/> <xsl:value-of select="xqx:attributeName"/> <xsl:value-of select="$EQUAL"/> <xsl:value-of select="$DOUBLEQUOTE"/> <xsl:choose> <xsl:when test="xqx:attributeValue"> <xsl:value-of select="xqx:attributeValue"/> </xsl:when> <xsl:otherwise> <xsl:value-of select="$LBRACE"/> <xsl:apply-templates select="xqx:attributeValueExpr"/> <xsl:value-of select="$RBRACE"/> </xsl:otherwise> </xsl:choose> <xsl:value-of select="$DOUBLEQUOTE"/> </xsl:template> <xsl:template match="xqx:attributeList"> <xsl:apply-templates select="*"/> </xsl:template> <xsl:template match="xqx:elementContent"> <xsl:for-each select="*"> <xsl:value-of select="$LBRACE"/> <xsl:apply-templates select="*"/> <xsl:value-of select="$RBRACE"/> </xsl:for-each> </xsl:template> <xsl:template match="xqx:expr[@xsi:type='xqx:elementConstructor']"> <xsl:value-of select="$LESSTHAN"/> <xsl:value-of 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:value-of 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:expr[@xsi:type='xqx:computedElementConstructor']"> <xsl:text> element </xsl:text> <xsl:apply-templates select="xqx:tagName"/> <xsl:apply-templates select="xqx:tagNameExpr"/> <xsl:value-of select="$LBRACE"/> <xsl:apply-templates select="xqx:contentExpr"/> <xsl:value-of select="$RBRACE"/> </xsl:template> <xsl:template match="xqx:expr[@xsi:type='xqx:computedAttributeConstructor']"> <xsl:text> attribute </xsl:text> <xsl:apply-templates select="xqx:tagName"/> <xsl:apply-templates select="xqx:tagNameExpr"/> <xsl:value-of select="$LBRACE"/> <xsl:apply-templates select="xqx:valueExpr"/> <xsl:value-of select="$RBRACE"/> </xsl:template> <xsl:template match="xqx:expr[@xsi:type='xqx:computedDocumentConstructor']"> <xsl:text> document {</xsl:text> <xsl:apply-templates select="*"/> <xsl:text> }</xsl:text> </xsl:template> <xsl:template match="xqx:expr[@xsi:type='xqx:computedTextConstructor']"> <xsl:text> text</xsl:text> <xsl:value-of select="$LBRACE"/> <xsl:apply-templates select="*"/> <xsl:value-of select="$RBRACE"/> </xsl:template> <xsl:template match="xqx:expr[@xsi:type='xqx:computedCommentConstructor']"> <xsl:text> comment</xsl:text> <xsl:value-of select="$LBRACE"/> <xsl:apply-templates select="*"/> <xsl:value-of select="$RBRACE"/> </xsl:template> <xsl:template match="xqx:piTargetExpr"> <xsl:value-of select="$LBRACE"/> <xsl:apply-templates select="*"/> <xsl:value-of select="$RBRACE"/> </xsl:template> <xsl:template match="xqx:piValueExpr"> <xsl:value-of select="$LBRACE"/> <xsl:apply-templates select="*"/> <xsl:value-of select="$RBRACE"/> </xsl:template> <xsl:template match="xqx:expr[@xsi:type='xqx:computedPIConstructor']"> <xsl:text> processing-instruction </xsl:text> <xsl:value-of select="xqx:piTarget"/> <xsl:apply-templates select="xqx:piTargetExpr"/> <xsl:apply-templates select="xqx:piValueExpr"/> </xsl:template> <xsl:template match="xqx:expr[@xsi:type='xqx:unorderedExpr']"> <xsl:text> unordered( </xsl:text> <xsl:apply-templates select="*"/> <xsl:value-of select="$RPAREN"/> </xsl:template> <xsl:template match="xqx:expr[@xsi:type='xqx:orderedExpr']"> <xsl:text> ordered( </xsl:text> <xsl:apply-templates select="*"/> <xsl:value-of select="$RPAREN"/> </xsl:template> <xsl:template match="xqx:versionDecl"> <xsl:text> xquery version </xsl:text> <xsl:call-template name="quote"> <xsl:with-param name="item" select="xqx:version"/> </xsl:call-template> <xsl:if test="xqx:encoding"> <xsl:text> encoding </xsl:text> <xsl:call-template name="quote"> <xsl:with-param name="item" select="xqx:encoding"/> </xsl:call-template> </xsl:if> <xsl:value-of select="$SEPARATOR"/> <xsl:value-of select="$NEWLINE"/> </xsl:template> <xsl:template match="xqx:namespaceDecl"> <xsl:text> declare namespace </xsl:text> <xsl:value-of select="xqx:prefix"/> <xsl:value-of select="$EQUAL"/> <xsl:call-template name="quote"> <xsl:with-param name="item" select="xqx:uri"/> </xsl:call-template> </xsl:template> <xsl:template match="xqx:defaultNamespaceDecl"> <xsl:text> declare default </xsl:text> <xsl:value-of select="xqx:defaultNamespaceCategory"/> <xsl:text> namespace </xsl:text> <xsl:call-template name="quote"> <xsl:with-param name="item" select="xqx:uri"/> </xsl:call-template> </xsl:template> <xsl:template match="xqx:defaultCollationDecl"> <xsl:text> 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:boundarySpaceDecl"> <xsl:text> declare boundary-space </xsl:text> <xsl:value-of select="."/> </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 ordering </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:value-of select="xqx:optionName"/> <xsl:value-of select="$SPACE"/> <xsl:value-of select="xqx:optionContents"/> </xsl:template> <xsl:template match="xqx:emptySequenceType"> <xsl:text>empty()</xsl:text> </xsl:template> <xsl:template match="xqx:occurrenceIndicator"> <xsl:value-of select="."/> </xsl:template> <xsl:template match="xqx:anyItemType"> <xsl:text>item()</xsl:text> </xsl:template> <xsl:template match="xqx:sequenceType"> <xsl:apply-templates select="*"/> </xsl:template> <xsl:template match="xqx:atomicType"> <xsl:value-of select="."/> </xsl:template> <xsl:template match="xqx:singleType"> <xsl:apply-templates select="xqx:atomicType"/> <xsl:if test="xqx:optional"> <xsl:text>?</xsl:text> </xsl:if> </xsl:template> <xsl:template match="xqx:typeDeclaration"> <xsl:text> as </xsl:text> <xsl:apply-templates select="*"/> </xsl:template> <xsl:template match="xqx:varDecl"> <xsl:text> declare variable </xsl:text> <xsl:value-of select="$DOLLAR"/> <xsl:value-of select="xqx:varName"/> <xsl:value-of select="$SPACE"/> <xsl:apply-templates select="xqx:typeDeclaration"/> <xsl:if test="xqx:external"> <xsl:text> external </xsl:text> </xsl:if> <xsl:if test="xqx:varValue"> <xsl:value-of select="$ASSIGN"/> <xsl:apply-templates select="xqx:varValue"/> </xsl:if> </xsl:template> <xsl:template match="xqx:schemaImport"> <xsl:text> import schema </xsl:text> <xsl:if test="xqx:defaultElementNamespace"> <xsl:text> default element namespace </xsl:text> </xsl:if> <xsl:if test="xqx:namespacePrefix"> <xsl:text> namespace </xsl:text> <xsl:value-of select="xqx:namespacePrefix"/> <xsl:value-of select="$EQUAL"/> </xsl:if> <xsl:call-template name="quote"> <xsl:with-param name="item" select="xqx:targetNamespace"/> </xsl:call-template> <xsl:if test="xqx:targetLocation"> <xsl:text> at </xsl:text> <xsl:call-template name="quote"> <xsl:with-param name="item" select="xqx:targetLocation"/> </xsl:call-template> </xsl:if> </xsl:template> <xsl:template match="xqx:moduleImport"> <xsl:text> import module </xsl:text> <xsl:if test="xqx:namespacePrefix"> <xsl:text> namespace </xsl:text> <xsl:value-of select="xqx:namespacePrefix"/> <xsl:value-of select="$EQUAL"/> </xsl:if> <xsl:call-template name="quote"> <xsl:with-param name="item" select="xqx:targetNamespace"/> </xsl:call-template> <xsl:if test="xqx:targetLocation"> <xsl:text> at </xsl:text> <xsl:call-template name="quote"> <xsl:with-param name="item" select="xqx:targetLocation"/> </xsl:call-template> </xsl:if> </xsl:template> <xsl:template match="xqx:param"> <xsl:value-of select="$DOLLAR"/> <xsl:value-of select="xqx:varName"/> <xsl:apply-templates select="xqx:typeDeclaration"/> </xsl:template> <xsl:template match="xqx:paramList"> <xsl:call-template name="paranthesizedList"/> </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 select="xqx:expr"/> <xsl:value-of select="$NEWLINE"/> <xsl:value-of select="$RBRACE"/> </xsl:template> <xsl:template match="xqx:functionDecl"> <xsl:text> declare function </xsl:text> <xsl:value-of select="xqx:functionName"/> <xsl:apply-templates select="xqx:paramList"/> <xsl:apply-templates select="xqx:typeDeclaration"/> <xsl:apply-templates select="xqx:functionBody"/> <xsl:if test="xqx:externalDefinition"> <xsl:text> external </xsl:text> </xsl:if> </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 </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: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"> <xsl:apply-templates select="*"/> </xsl:template> </xsl:stylesheet>
application/xquery+xml
Media Type (Non-Normative)This Appendix specifies the media type for XQueryX Version 1.0. XQueryX is the XML syntax of a language, XQuery, for querying over data from XML data sources, as specified in [XQuery 1.0: An XML Query Language].
This document, together with its normative references, defines the XML syntax for the XML Query language XQuery Version 1.0. This Appendix specifies the application/xquery+xml
media type, which is intended to be used for transmitting queries expressed in the XQueryX syntax.
This document was prepared by members of the W3C XML Query Working Group. Please send comments to public-qt-comments@w3.org, a public mailing list with archives at http://lists.w3.org/Archives/Public/public-qt-comments.
application/xquery+xml
MIME media type name: application
MIME subtype name: xquery+xml
Required parameters: none
Optional parameters: charset
This parameter has identical semantics to the charset parameter of the application/xml media type as specified in [RFC3023].
The considerations as specified in RFC 3023 [XMLMIME] also hold for 'application/xquery+xml'.
For documents labeled as 'application/xquery+xml', fragment identifiers are handled as specified in RFC 3023 [XMLMIME].
The intended usage of this media type is for interchange of XQueryX expressions.
Queries written in XQueryX may cause arbitrary URIs to be dereferenced. Therefore, the security issues of [Uniform Resource Locators (URL)] Section 6 should be considered. In addition, the contents of file:
URIs can in some cases be accessed, processed and returned as results.
Furthermore, because the XQuery language (and thus the XQueryX language) permits extensions, it is possible that application/xquery+xml
may describe content that has security implications beyond those described here. However, if the processor follows only the normative semantics of this specification, this content will be ignored. Only in the case where the processor recognizes and processes the additional content, or where further processing of that content is dispatched to other
processors, would security issues arise.
The XML Query Working group is working on a facility to allow XQuery (and thus XQueryX) expressions to be used to create and update persistent data. Untrusted queries should not be given write access to data.
None. (This will be replaced by "See x.y, Conformance, in XQuery." in the Last Call WD.
The public XQuery Web page lists more than two dozen implementations of the XQuery language, both proprietary and open source. Some of these are known to support XQueryX.
This new media type is being registered to allow for deployment of XQueryX on the World Wide Web.
There is no experimental, vendor specific, or personal tree predecessor to "application/xquery+xml", reflecting the fact that no applications currently recognize it. This new type is being registered in order to allow for the expected deployment of XQueryX 1.0 on the World Wide Web, as a first class XML application.
Although no byte sequences can be counted on to consistently identify XQueryX, XQueryX documents will have the sequence "http://www.w3.org/yyyy/mm/XQueryX" to identify the XQueryX namespace (where "yyyy" is exactly four decimal digits and "mm" is exactly two decimal digits). This sequence will normally be found in a namespace attribute of the first element in the document.
Jim Melton, Oracle Corp., jim.melton@oracle.com
This section contains the current issues for XQueryX. The individual issues are shown in detail after an abbreviated issues list.
Issue | Priority | Status | ID |
------------------------------------------------ | ----------- | --------- | ------------------------- |
1: Should we define a programmatic conversion from the XQuery abstract syntax to the XQueryX Schema? (xqueryx-auto) | 2 | Open | xqueryx-auto |
2: How should XQueryX represent operators? (xqueryx-operator-syntax) | 4 | Open | xqueryx-operator-syntax |
3: Are "wrapper" elements necessary or desirable? (xqueryx-wrappers-necessary) | 3 | Open | xqueryx-wrappers-necessary |
4: "<xqx:parameters>" should be "<xqx:arguments>" (xqueryx-param-vs-arg) | 5 | Open | xqueryx-param-vs-arg |
5: Representation of QNames in xqx: element content is suboptimal (xqueryx-qname-in-context) | 3 | Open | xqueryx-qname-in-context |
6: Should XQueryX represent everything that can be expressed in XQuery syntax? (xqueryx-encode-everything) | 4 | Open | xqueryx-encode-everything |
7: The XQueryX schema must be kept aligned with the XQuery grammar (xqueryx-grammar-updates) | 1 | Open | xqueryx-grammar-updates |
8: Should there be a "less-trivial embedding" of XQuery into XML? (xqueryx-less-trivial-embedding) | 1 | Open | xqueryx-less-trivial-embedding |
9: Must an XQueryX document always start at the level of an XQuery module? (xqueryx-start-at-module) | 2 | Open | xqueryx-start-at-module |
10: The XQuery process model does not incorporate XQueryX (xqueryx-process-model) | 3 | Open | xqueryx-process-model |
11: Trivial embedding should have a schema and namespace (xqueryx-schema-namespace) | 3 | Open | xqueryx-schema-namespace |
Should we define a programmatic conversion from the XQuery abstract syntax to the XQueryX Schema?
Source: XML Query WG
If we could define a programmatic conversion from the XQuery abstract syntax to the XQueryX Schema (and the Stylesheet), we could guarantee that the current and future versions of the XQueryX Schema were complete and up-to-date. This would probably need to include annotations to the XQuery grammar. It has been estimated that this would take several times as much effort as the current manual approach.
Resolution:
-------------------------
Issue (xqueryx-operator-syntax):
How should XQueryX represent operators?
Source: XML Query WG
There are many possible notations that XQueryX could use to represent operators. It currently uses the following syntax for operators:
<xqx;infixOp/> <xqx;opType>+</xqx:opType>
and
<xqx;infixOp/> <xqx;opType>and</xqx:opType>
Several other possibilities have been suggested, eg:
<xqx:function name="PLUS"> <xqx:constant datatype="INTEGER">1</xqx:constant> <xqx:constant datatype="INTEGER">2</xqx:constant> </xqx:function>
or
<xqx:plus/> <xqx:and/>
or
<xqx:binaryOperator name="plus"/> <xqx:binaryOperator name="and"/>
or
<xqx:mathOperator name="+"/> <xqx:logicalOperator name="and"/>
Is there any compelling reason to change from the current notation to some alternative?
Resolution:
-------------------------
Issue (xqueryx-wrappers-necessary):
Are "wrapper" elements necessary or desirable?
Source: XML Query WG
The XQueryX schema currently includes the use of "wrapper" elements (<exprWrapper> and <exprList>). These elements might have uses in future enhancements of XQueryX, but arguably do not have any utility in this version.
Should these elements be retained, or should they be removed from the schema design?
Resolution:
-------------------------
"<xqx:parameters>" should be "<xqx:arguments>"
Source: XML Query WG
The element "<xqx:parameters>" is misnamed, since it actually represents the arguments to a function invocation and not the parameters of a function definition. It should probably be changed to "<xqx:arguments>"
Resolution:
-------------------------
Issue (xqueryx-qname-in-context):
Representation of QNames in xqx: element content is suboptimal
Source: XML Query WG
One capability enabled by the existence of XQueryX is the ability to process XQueries using ordinary XML tools, including XQuery itself, XPath, and XSLT. XQueryX schema elements sometimes represent QNames. For example: "<functionName>avg</functionName>". The representation of QNames in context like this makes it very difficult for XML-aware tools to find those QNames by using their fully-qualified form, including their namespace URIs. Are there any XQueryX changes that would make this feasible?
Resolution:
-------------------------
Issue (xqueryx-encode-everything):
Should XQueryX represent everything that can be expressed in XQuery syntax?
Source: XML Query WG
XQueryX is intended to be a language, or syntax, for representing XQuery semantics in an XML form. There is no requirement or intent to presume "compilation" of XQuery expressions from the human-readable syntax into XQueryX. Consequently, the decision has already been made that XQuery comments are not represented in XQueryX (of course, XQueryX is XML and thus can contain XML comments).
But there is at least one additional case to be considered: the XQuery prolog allows an encoding specification (e.g., UTF-8). XQueryX currently allows that encoding specification (corresponding only to the XQuery encoding parameter) to be included in an XQueryX document. This does not affect the encoding of the XQueryX document itself in any way. Should that capability be retained or removed as meaningless? If it is retained, should the stylesheet generate the corresponding XQuery prolog encoding parameter?
Resolution:
-------------------------
Issue (xqueryx-grammar-updates):
The XQueryX schema must be kept aligned with the XQuery grammar
Source: XML Query WG
Changes are made to the XQuery grammar at an ever-decreasing frequency and the XQueryX schema must be re-aligned with the revised grammar whenever changes are made. In particular, changes made in January, 2005, affected the positioning of the "setters" and the XQueryX schema has not yet caught up.
Resolution:
-------------------------
Issue (xqueryx-less-trivial-embedding):
Should there be a "less-trivial embedding" of XQuery into XML?
Source: XML Query WG
The XQueryX specification includes both a schema defining an XML representation of XQuery semantics in a syntax that roughly parallels the XQuery grammar. It also includes a "trivial embedding" of XQuery that merely wraps XQuery syntax in a containing XML element (and escapes certain important characters).
There may be an important requirement to provide a "less-trivial" embedding that uses a sort of mixed XML-and-human-readable syntax.
Resolution:
-------------------------
Issue (xqueryx-start-at-module):
Must an XQueryX document always start at the level of an XQuery module?
Source: XML Query WG
Valid XQuery syntax ranges from the ultra-trivial (e.g., "42" is a valid XQuery expression) to the complex (e.g., fully-specified modules). Should XQueryX documents always represent fully-specified modules, or should it be permissible to represent ultra-trivial expressions?
Resolution:
-------------------------
Issue (xqueryx-process-model):
The XQuery process model does not incorporate XQueryX
Source: XML Query WG
The XQuery process model does not currently incorporate the use of XQueryX. That process model must be updated to account for XQueryX.
Resolution:
-------------------------
Issue (xqueryx-schema-namespace):
Trivial embedding should have a schema and namespace
Source: XML Query WG
The trivial embedding described in this document makes use of an element called "<XQuery>". That element should be in a specified namespace. That namespace could be the same one used by the remainder of XQueryX (represented by the prefix "xqx", or it could be a new namespace ("xqxt"). In either case, there must be a definition of the element in an XML schema.
Resolution:
-------------------------
Issue (xqueryx-xsl-normative):
Should the stylesheet be normative ?
Source: XML Query WG
The XQueryX Schema defines the syntax of XQueryX. But we also need to define the semantics. If we had some programmatic way to convert from XQuery syntax to XQueryX syntax, then this process would define the semantics of XQueryX. As it is, we can only go in the other direction : from XQueryX to XQuery via a stylesheet. So, should the stylesheet be the normative definition of the semantics of XQueryX ?
Resolution:
RESOLVED: The Query WG has determined that the stylesheet must be normative in order to define the semantics of XQueryX.
-------------------------
Some tidy-up of terms is needed.
Source: XML Query WG
Need to tidy up some of the terminology in the Schema : e.g. the use of flwr vs the newer flwor.
Resolution:
RESOLVED: The tidying has been done, particularly the cited example.
-------------------------
XQueryX and XSLT
Source: XML Query WG
Should there be some clear relationship between XQueryX and XSLT?
Resolution:
RESOLVED: No, this is not a goal.
-------------------------
Should path expressions be expanded?
Source: ML Query WG
The current representation requires path expressions to be expanded. Should this be optional?
Resolution:
RESOLVED: XPath expressions should be expanded, and it should not be optional.
-------------------------
Issue (xqueryx-human-readable):
Human readable XQueryX?
Source: XML Query WG
Should making XQueryX queries easier for humans to read and write be a goal?
Resolution:
RESOLVED: No, this is not a goal. It was decided that the priority is to have an XML syntax. The human-readable characteristic is somewhat subjective, so the decision is to go for a solution that allows a very granular access to the language.
-------------------------
Should XQueryX mirror the Formal Semantics?
Source: XML Query WG
Should XQueryX mirror the Formal Semantics rather than the abstract syntax of XQuery?
Resolution:
RESOLVED: No, this is not a goal.
-------------------------
Issue (xqueryx-define-transformation):
Define Transformations from XQuery Grammar priority="2" status="closed"
This issue was a duplicate of [Issue 1: Should we define a programmatic conversion from the XQuery abstract syntax to the XQueryX Schema?].
Resolution:
RESOLVED, but see [Issue 1: Should we define a programmatic conversion from the XQuery abstract syntax to the XQueryX Schema?]
-------------------------
Issue (xqueryx-path-expressions):
Representing Path Expressions
Source: XML Query WG
Should path expressions be represented in a linear fashion, with the individual steps represented as a sequence? One Working Group member has suggested that the path "doc("a")/b/c" should be represented as follows:
<path> <function name="doc"> <constant>a</constant> </function> <step axis="descendant"> <identifier>b</identifier> </step> <step axis="descendant"> <identifier>c</identifier> </step> </path>
Resolution:
RESOLVED: the schema has this sort of structure, only without the use of attributes.
-------------------------
Representing //
Source: XML Query WG
In this document we use the constant SLASHSLASH as a fictive axis that corresponds to the meaning of the "//" operator. In fact, this operator does not correspond directly to an axis, but to descendant-or-self::node()/. For example, //para is short for /descendant-or-self::node()/child::para. Since XQueryX must be able to translate back to the original XQuery syntax, we currently use SLASHSLASH to preserve the original operator.
Is this the best way to represent the // operator in XQueryX?
Resolution:
RESOLVED: Overtaken by events; the schema uses the full (expanded) path notation instead of abbreviations.
-------------------------
Issue (xqueryx-operators-symbolspace):
Symbol space for operators
Source: XML Query WG
The current syntax does not distinguish functions from operators. Since a function may have the same name as an operator, some mechanism must be chosen to disambiguate their names. For instance, since a user can write a function named plus, perhaps the operator plus should be represented as:
<operator name="plus"/>
rather than
<function name="plus"/>
Resolution:
RESOLVED: Overtaken by events in both XQuery and in XQueryX; the schema now clearly distinguishes operators and functions.
-------------------------
Issue (xqueryx-star-identifier):
Wildcard
Originator: | XML Query WG |
Locus: | xqueryx |
Should * be used as an identifier? It should probably be a wildcard.
Resolution:
RESOLVED: * is represented as a wildcard element.
-------------------------
Issue (xqueryx-cast-treat-typeswitch):
Type Expressions
Source: XML Query WG
CAST, TREAT, and TYPESWITCH have no representation in this Working Draft. This must be added soon.
Resolution:
RESOLVED: This specification now covers those expressions.
-------------------------
Issue (xqueryx-schema-declarations):
SCHEMA declaration
Source: XML Query WG
There is currently no representation for schema declarations in XQueryX. This must be added.
Resolution:
RESOLVED: This issue is moot.
-------------------------
Issue (xqueryx-case-of-constants):
Case of Constants
Source: XML Query WG
Should XQueryX constants use upper or lower case?
Resolution:
RESOLVED: There is no compelling reason to adopt either convention; the schema uses lowercase generally when the notion being represented corresponds to an XQuery keyword (e.g., "eq") and camelcase generally when representing notions that do not correspond to a keyword (e.g., unaryPlus).
-------------------------
Should XQueryX variables be in uppercase?
Source: Jonathan Robie
The way the variable class is defined in the alternate schema is not consistent with the way other types/elements are treated
Resolution:
RESOLVED: This issue is moot, as the alternate schema no longer exists.
-------------------------
Issue (xqueryx-support-pragmas-etc):
Shoud XQueryX support pragmas, MUEs, and comments?
Source: Editors
It seems reasonable to support the first two, but not the third (comments).
If the answer is yes, then how rigorously should XQueryX preserve fidelity with respect to the position of these constructs in the base documents? (For example, can XQueryX restrict its support for pragmas and MUEs to only the prolog section?)
If the answer is yes, then the schema for XQueryX needs to reflect this -- and that would mean that every single type/element definition would have to accomodate such a construct. This is not just painful -- it's pretty ridiculous. We must bear in mind that, even with this enormous pain, we still would not have complete fidelity. For example, the XQuery construct "declare function foo" has multiple whitespace locations, while the equivalent in XQueryX has fewer — because XQueryX does not recognize the syntactic pieces of this construct.
If the answer is yes, then some clarifications are in order. What are the expected semantics of a pragma/MUE at some arbitrary location in the XQuery? Do they apply to the entire query? Some subset of the query? Forward-looking subset of the query? The immediately containing block?
Resolution:
RESOLVED: The schema now supports pragmas (made possible by the recent changes made to pragma syntax in XQuery). MUEs (must-understand extensions) no longer exist. At a Query WG meeting in 2004, the WG decided that comments in XQuery have no meaningful correlation in XQueryX (because the goal of XQueryX is to provide an XML syntax to represent XML queries, not to provide a fully reversible transformation of XQuery human-readable syntax to XQueryX and back).
-------------------------
Issue (xqueryx-normative-semantics):
How should the semantics of XQueryX be specified normatively?
Source: XML Query WG
The semantics of XQueryX must be stated normatively. One possible way is to show the correspondence between the XQueryX and XQuery syntaxes; if this solution is chosen, then how do we demonstrate that the XQueryX syntax is equivalent to the XQuery syntax?.
Resolution:
RESOLVED: The XQueryX document states that the semantics depend on the newly-normative stylesheet that transforms XQueryX documents into XQuery human-readable syntax.
-------------------------