XQuery 4.0: An XML Query Language

4.12.3.1 Computed Element Constructors

[Definition: A computed element constructor creates an element node, allowing both the name and the content of the node to be computed.]

The element name is determined by the CompNodeName, which may be provided in a number of ways:

1. As a QName literal, for example:

   element #table {}
element #html:table {}
element #Q{}table {}
element #Q{http://http://www.w3.org/1999/xhtml}table {}

   A QName literal written as an unprefixed lexical QName (the first form above) is resolved using the element constructor namespace rule (TODO: add link, this is defined in PR 1987). This differs from the normal rules for evaluating a QName literal as an atomic item of type xs:QName.

   Note that the last two examples (#Q{}table and #Q{http://http://www.w3.org/1999/xhtml}table) will result in the name of the constructed element having no prefix, which may in turn trigger the generation of a default namespace declaration.

2. As a simple EQName, for example:

   element table {}
element html:table {}
element Q{}table {}
element Q{http://http://www.w3.org/1999/xhtml}table {}

   In XQuery 4.0 the first form (using an unprefixed lexical QName) is allowed only if the element name is not a reserved keyword (such as div or value): see unreserved-name. In all other cases, the effect is exactly the same as when a leading # is added to turn the EQName into a QName literal.

   This syntax is retained for compatibility, but is deprecated.

3. As an expression in curly brackets. This is processed as follows:

   1. Atomization is applied to the value of the name expression. If the result of atomization is not a single atomic item of type xs:QName, xs:string, or xs:untypedAtomic, a type error is raised [err:XPTY0004].

   2. If the atomized value of the name expression is of type xs:QName, that expanded QName is used as the node-name property of the constructed element, retaining the prefix part of the QName.

   3. If the atomized value of the name expression is of type xs:string or xs:untypedAtomic, that value is converted to an expanded QNameas follows:

      1. Leading and trailing whitespace is removed.

      2. If the value is a lexical QName with a prefix, it is expanded using the constructed element namespace rule.

      3. If the value is a URI-qualified name (Q{uri}local), it is converted to an expanded QName with the supplied namespace URI and local name, and with no prefix.

      Note:

      This was under-specified in XQuery 3.1.

   4. If conversion of the atomized name expression to an expanded QName is not successful, a dynamic error is raised [err:XQDY0074].

The resulting expanded QName is used as the node-name property of the constructed element, retaining the prefix part of the QName (or its absence).

An error is raised [err:XQDY0096] if the node-name of the constructed element node has any of the following properties:

• Its namespace prefix is xmlns.

• Its namespace URI is http://www.w3.org/2000/xmlns/.

• Its namespace prefix is xml and its namespace URI is not http://www.w3.org/XML/1998/namespace.

• Its namespace prefix is other than xml and its namespace URI is http://www.w3.org/XML/1998/namespace.

The above error may be raised as a static error if the element name is computed statically; in other cases it must be raised as a dynamic error.

The content expression of a computed element constructor (if present) is processed in exactly the same way as an enclosed expression in the content of a direct element constructor, as described in Step 1e of 4.12.1.3 Content. The result of processing the content expression is a sequence of nodes called the content sequence. If the content expression is absent, the content sequence is an empty sequence.

Processing of the computed element constructor proceeds as follows:

1. If the content sequence contains a document node, the document node is replaced in the content sequence by its children.

2. Adjacent text nodes in the content sequence are merged into a single text node by concatenating their contents, with no intervening blanks. After concatenation, any text node whose content is a zero-length string is deleted from the content sequence.

3. If the content sequence contains an attribute node or a namespace node following a node that is not an attribute node or a namespace node, a type error is raised [err:XQTY0024].

4. The properties of the newly constructed element node are determined as follows:

   1. node-name is the expanded QName resulting from processing the specified CompNodeName, as described above.

   2. parent is empty.

   3. attributes consist of all the attribute nodes in the content sequence, in implementation-dependent order. Note that the parent property of each of these attribute nodes has been set to the newly constructed element node. If two or more attributes have the same node-name, a dynamic error is raised [err:XQDY0025]. If an attribute named xml:space has a value other than preserve or default, a dynamic error may be raised [err:XQDY0092].

   4. children consist of all the element, text, comment, and processing instruction nodes in the content sequence. Note that the parent property of each of these nodes has been set to the newly constructed element node.

   5. base-uri is set to the following value:

      1. If the constructed node has an attribute named xml:base, then the value of this attribute, resolved (if it is relative) against the Executable Base URI, as described in 2.5.6 Resolving a Relative URI Reference.

      2. Otherwise, the Executable Base URI.

   6. The in-scope namespaces are computed as described in 4.12.4 In-scope Namespaces of a Constructed Element.

   7. The nilled property is false.

   8. The string-value property is equal to the concatenated contents of the text-node descendants in document order.

   9. The typed-value property is equal to the string-value property, as an instance of xs:untypedAtomic.

   10. If construction mode in the static context is strip, the type-name property is xs:untyped. On the other hand, if construction mode is preserve, the type-name property is xs:anyType.

   11. The is-id and is-idrefs properties are set to false.

A computed element constructor might be used to make a modified copy of an existing element. For example, if the variable $e is bound to an element with numeric content, the following constructor might be used to create a new element with the same name and attributes as $e and with numeric content equal to twice the value of $e:

element { node-name($e) } { $e/@*, 2 * data($e) }

In this example, if $e is bound by the expression let $e := <length units="inches">{ 5 }</length>, then the result of the example expression is the element <length units="inches">10</length>.

One important purpose of computed constructors is to allow the name of a node to be computed. We will illustrate this feature by an expression that translates the name of an element from one language to another. Suppose that the variable $dict is bound to a dictionary element containing a sequence of entry elements, each of which encodes translations for a specific word. Here is an example entry that encodes the German and Italian variants of the word “address”:

<entry word="address">
  <variant xml:lang="de">Adresse</variant>
  <variant xml:lang="it">indirizzo</variant>
</entry>

Suppose further that the variable $e is bound to the following element:

<address>123 Roosevelt Ave. Flushing, NY 11368</address>

Then the following expression generates a new element in which the name of $e has been translated into Italian and the content of $e (including its attributes, if any) has been preserved. The first enclosed expression after the element keyword generates the name of the element, and the second enclosed expression generates the content and attributes:

element {
  $dict/entry[@word = name($e)]/variant[@xml:lang = "it"]
} {
  $e/@*, $e/node()
}

The result of this expression is as follows:

<indirizzo>123 Roosevelt Ave. Flushing, NY 11368</indirizzo>

4.12.3.7 Computed Namespace Constructors

A computed namespace constructor creates a new namespace node, with its own node identity. The parent of the newly created namespace node is absent.

The name of a namespace node is always an NCName, and represents the namespace prefix.

The string value of a namespace node should be a URI, and represents the namespace URI.

The namespace prefix may be provided in a number of ways:

1. As a string literal, for example namespace "xlink" { "http://www.w3.org/1999/xlink" }. The content of the string literal must either take the form of an NCName, or must be a zero-length string.

2. As a simple NCName, for example namespace xlink { "http://www.w3.org/1999/xlink" }. This form is allowed only if the namespace prefix is not a reserved keyword: see unreserved-name.

3. As an expression in curly braces. This is processed as follows:

   1. Atomization is applied to the result of the enclosed expression.

   2. If the result of atomization is an empty sequence or a single atomic item of type xs:string or xs:untypedAtomic, then the following rules are applied in order:

      1. If the result is castable to xs:NCName, then it is used as the local name of the newly constructed namespace node. (The local name of a namespace node represents the prefix part of the namespace binding.)

      2. If the result is the empty sequence or a zero-length xs:string or xs:untypedAtomic item, the new namespace node has no name (such a namespace node represents a binding for the default namespace).

      3. Otherwise, a dynamic error is raised [err:XQDY0074].

   3. If the result of atomization is not an empty sequence or a single atomic item of type xs:string or xs:untypedAtomic, a type error is raised [err:XPTY0004].

The content expression is evaluated, and the result is cast to xs:anyURI to create the URI property for the newly created node. An implementation may raise a dynamic error [err:XQDY0074] if the URIExpr of a computed namespace constructor is not a valid instance of xs:anyURI.

An error [err:XQDY0101] is raised if a computed namespace constructor attempts to do any of the following:

• Bind the prefix xml to some namespace URI other than http://www.w3.org/XML/1998/namespace.

• Bind a prefix other than xml to the namespace URI http://www.w3.org/XML/1998/namespace.

• Bind the prefix xmlns to any namespace URI.

• Bind a prefix to the namespace URI http://www.w3.org/2000/xmlns/.

• Bind any prefix (including the empty prefix) to a zero-length namespace URI.

By itself, a computed namespace constructor has no effect on in-scopethe in-scope namespacesnamespaces of any element, but if an element constructor’s content sequence contains a namespace node, the namespace binding it represents is added to thethat element’s in-scope namespaces.

A computed namespace constructor has no effect on the staticallystatically known namespaces known namespacesin the static context.

Examples:

• A computed namespace constructor with a prefix:

  namespace a { "http://a.example.com" }

• A computed namespace constructor with a prefix expression:

  namespace { "a" } { "http://a.example.com" }

• A computed namespace constructor with an empty prefix:

  namespace "" { "http://a.example.com" }

Computed namespace constructors are generally used to add to the in-scope namespaces of elements created with element constructors:

<age xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> {
  namespace xs { "http://www.w3.org/2001/XMLSchema" },
  attribute xsi:type { "xs:integer" },
  23
}</age>

In the above example, note that the xsinamespace binding is created for the element because it is used in an attribute name. The attribute’s content is simply character data, and has no effect on namespace bindings. The computed namespace constructor ensures that the xs binding is created.

Computed namespace constructors have no effect on the statically known namespaces. If the prefix a is not already defined in the statically known namespaces, the following expression results in a static error [err:XPST0081].

<a:form>{
  namespace a { "http://a.example.com" }
}</a:form>