The static context of an expression is the information that is available during static analysis of the expression, prior to its evaluation. This information can be used to decide whether the expression contains a static error. If analysis of an expression relies on some component of the static context that has not been assigned a value, a static error is raised .

The individual components of the static context are summarized below. Rules governing the scope and initialization of these components can be found in .

The dynamic context of an expression is defined as information that is available at the time the expression is evaluated. If evaluation of an expression relies on some part of the dynamic context that has not been assigned a value, a dynamic error is raised .

The individual components of the dynamic context are summarized below. Further rules governing the semantics of these components can be found in .

The dynamic context consists of all the components of the static context, and the additional components listed below.

The first three components of the dynamic context (context item, context position, and context size) are called the focus of the expression. The focus enables the processor to keep track of which items are being processed by the expression.

Certain language constructs, notably the path expression E1/E2 and the filter expression E1[E2], create a new focus for the evaluation of a sub-expression. In these constructs, E2 is evaluated once for each item in the sequence that results from evaluating E1. Each time E2 is evaluated, it is evaluated with a different focus. The focus for evaluating E2 is referred to below as the inner focus, while the focus for evaluating E1 is referred to as the outer focus. The inner focus exists only while E2 is being evaluated. When this evaluation is complete, evaluation of the containing expression continues with its original focus unchanged.

As described in , XQuery defines a static analysis phase, which does not depend on input data, and a dynamic evaluation phase, which does depend on input data. Errors may be raised during each phase.

A static error is an error that must be detected during the static analysis phase. A syntax error is an example of a static error.

A dynamic error is an error that must be detected during the dynamic evaluation phase and may be detected during the static analysis phase. Numeric overflow is an example of a dynamic error.

A type error may be raised during the static analysis phase or the dynamic evaluation phase. During the static analysis phase, a type error occurs when the static type of an expression does not match the expected type of the context in which the expression occurs. During the dynamic evaluation phase, a type error occurs when the dynamic type of a value does not match the expected type of the context in which the value occurs.

The outcome of the static analysis phase is either success or one or more type errors, static errors, or statically-detected dynamic errors. The result of the dynamic evaluation phase is either a result value, a type error, or a dynamic error.

During the static analysis phase, if the Static Typing Feature is in effect and the static type assigned to an expression other than () or data(()) is empty-sequence(), a static error is raised . This catches cases in which a query refers to an element or attribute that is not present in the in-scope schema definitions, possibly because of a spelling error.

Independently of whether the Static Typing Feature is in effect, if an implementation can determine during the static analysis phase that an expression, if evaluated, would necessarily raise a type error or a dynamic error, the implementation may (but is not required to) report that error during the static analysis phase. However, the fn:error() function must not be evaluated during the static analysis phase.

In addition to static errors, dynamic errors, and type errors, an XQuery implementation may raise warnings, either during the static analysis phase or the dynamic evaluation phase. The circumstances in which warnings are raised, and the ways in which warnings are handled, are implementation-defined.

In addition to the errors defined in this specification, an implementation may raise a dynamic error for a reason beyond the scope of this specification. For example, limitations may exist on the maximum numbers or sizes of various objects. Any such limitations, and the consequences of exceeding them, are implementation-dependent.

The errors defined in this specification are identified by QNames that have the form err:XXYYnnnn, where:

The method by which an XQuery processor reports error information to the external environment is implementation-defined.

An error can be represented by a URI reference that is derived from the error QName as follows: an error with namespace URI NS and local part LP can be represented as the URI reference NS#LP. For example, an error whose QName is err:XPST0017 could be represented as http://www.w3.org/2005/xqt-errors#XPST0017.

Except as noted in this document, if any operand of an expression raises a dynamic error, the expression also raises a dynamic error. If an expression can validly return a value or raise a dynamic error, the implementation may choose to return the value or raise the dynamic error. For example, the logical expression expr1 and expr2 may return the value false if either operand returns false, or may raise a dynamic error if either operand raises a dynamic error.

If more than one operand of an expression raises an error, the implementation may choose which error is raised by the expression. For example, in this expression:

both the sub-expressions ($x div $y) and xs:decimal($z) may raise an error. The implementation may choose which error is raised by the "+" expression. Once one operand raises an error, the implementation is not required, but is permitted, to evaluate any other operands.

In addition to its identifying QName, a dynamic error may also carry a descriptive string and one or more additional values called error values. An implementation may provide a mechanism whereby an application-defined error handler can process error values and produce diagnostic messages.

A dynamic error may be raised by a built-in function or operator. For example, the div operator raises an error if its operands are xs:decimal values and its second operand is equal to zero. Errors raised by built-in functions and operators are defined in .

A dynamic error can also be raised explicitly by calling the fn:error function, which only raises an error and never returns a value. This function is defined in . For example, the following function call raises a dynamic error, providing a QName that identifies the error, a descriptive string, and a diagnostic value (assuming that the prefix app is bound to a namespace containing application-defined error codes):

Because different implementations may choose to evaluate or optimize an expression in different ways, certain aspects of the detection and reporting of dynamic errors are implementation-dependent, as described in this section.

An implementation is always free to evaluate the operands of an operator in any order.

In some cases, a processor can determine the result of an expression without accessing all the data that would be implied by the formal expression semantics. For example, the formal description of filter expressions suggests that $s[1] should be evaluated by examining all the items in sequence $s, and selecting all those that satisfy the predicate position()=1. In practice, many implementations will recognize that they can evaluate this expression by taking the first item in the sequence and then exiting. If $s is defined by an expression such as //book[author eq 'Berners-Lee'], then this strategy may avoid a complete scan of a large document and may therefore greatly improve performance. However, a consequence of this strategy is that a dynamic error or type error that would be detected if the expression semantics were followed literally might not be detected at all if the evaluation exits early. In this example, such an error might occur if there is a book element in the input data with more than one author subelement.

The extent to which a processor may optimize its access to data, at the cost of not detecting errors, is defined by the following rules.

Consider an expression Q that has an operand (sub-expression) E. In general the value of E is a sequence. At an intermediate stage during evaluation of the sequence, some of its items will be known and others will be unknown. If, at such an intermediate stage of evaluation, a processor is able to establish that there are only two possible outcomes of evaluating Q, namely the value V or an error, then the processor may deliver the result V without evaluating further items in the operand E. For this purpose, two values are considered to represent the same outcome if their items are pairwise the same, where nodes are the same if they have the same identity, and values are the same if they are equal and have exactly the same type.

There is an exception to this rule: a processor is required to establish that the actual value of the operand E does not violate any constraints on its cardinality. For example, the expression $e eq 0 results in a type error if the value of $e contains two or more items. A processor is not allowed to decide, after evaluating the first item in the value of $e and finding it equal to zero, that the only possible outcomes are the value true or a type error caused by the cardinality violation. It must establish that the value of $e contains no more than one item.

These rules apply to all the operands of an expression considered in combination: thus if an expression has two operands E1 and E2, it may be evaluated using any samples of the respective sequences that satisfy the above rules.

The rules cascade: if A is an operand of B and B is an operand of C, then the processor needs to evaluate only a sufficient sample of B to determine the value of C, and needs to evaluate only a sufficient sample of A to determine this sample of B.

The effect of these rules is that the processor is free to stop examining further items in a sequence as soon as it can establish that further items would not affect the result except possibly by causing an error. For example, the processor may return true as the result of the expression S1 = S2 as soon as it finds a pair of equal values from the two sequences.

Another consequence of these rules is that where none of the items in a sequence contributes to the result of an expression, the processor is not obliged to evaluate any part of the sequence. Again, however, the processor cannot dispense with a required cardinality check: if an empty sequence is not permitted in the relevant context, then the processor must ensure that the operand is not an empty sequence.

Examples:

For a variety of reasons, including optimization, implementations are free to rewrite expressions into equivalent expressions. Other than the raising or not raising of errors, the result of evaluating an equivalent expression must be the same as the result of evaluating the original expression. Expression rewrite is illustrated by the following examples.

An ordering called document order is defined among all the nodes accessible during processing of a given query, which may consist of one or more trees (documents or fragments). Document order is defined in , and its definition is repeated here for convenience. The node ordering that is the reverse of document order is called reverse document order.

Document order is a total ordering, although the relative order of some nodes is implementation-dependent. Informally, document order is the order in which nodes appear in the XML serialization of a document. Document order is stable, which means that the relative order of two nodes will not change during the processing of a given query, even if this order is implementation-dependent.

Within a tree, document order satisfies the following constraints:

The relative order of nodes in distinct trees is stable but implementation-dependent, subject to the following constraint: If any node in a given tree T1 is before any node in a different tree T2, then all nodes in tree T1 are before all nodes in tree T2.

The semantics of some XQuery operators depend on a process called atomization. Atomization is applied to a value when the value is used in a context in which a sequence of atomic values is required. The result of atomization is either a sequence of atomic values or a type error [err:FOTY0012]. Atomization of a sequence is defined as the result of invoking the fn:data function on the sequence, as defined in .

The semantics of fn:data are repeated here for convenience. The result of fn:data is the sequence of atomic values produced by applying the following rules to each item in the input sequence:

Atomization is used in processing the following types of expressions:

Under certain circumstances (listed below), it is necessary to find the effective boolean value of a value. The effective boolean value of a value is defined as the result of applying the fn:boolean function to the value, as defined in .

The dynamic semantics of fn:boolean are repeated here for convenience:

The effective boolean value of a sequence is computed implicitly during processing of the following types of expressions:

XQuery has a set of functions that provide access to input data. These functions are of particular importance because they provide a way in which an expression can reference a document or a collection of documents. The input functions are described informally here; they are defined in .

An expression can access input data either by calling one of the input functions or by referencing some part of the dynamic context that is initialized by the external environment, such as a variable or context item.

The input functions supported by XQuery are as follows:

If one of the above functions is invoked repeatedly with arguments that resolve to the same absolute URI during the processing of a single query, each invocation must return the same node sequence. This rule applies also to repeated invocations of fn:collection with zero arguments during the processing of a single query.

In certain places in the XQuery grammar, a statically known valid absolute URI is required. These places are denoted by the grammatical symbol URILiteral. For example, URILiterals are used to specify namespaces and collations, both of which must be statically known.

Syntactically, a URILiteral is identical to a StringLiteral: a sequence of zero or more characters enclosed in single or double quotes. However, an implementation MAY raise a static error if the value of a URILiteral is of nonzero length and is not in the lexical space of xs:anyURI, or if it is a string that represents a "relative reference" as defined in . The value of a URILiteral is whitespace-normalized according to the rules for the xs:anyURI type in ; however, no escaping normalization is applied.

The following is an example of a valid URILiteral:

The in-scope schema types in the static context are initialized with certain predefined schema types, including the built-in schema types of . These built-in schema types are in the namespace http://www.w3.org/2001/XMLSchema, which has the predefined namespace prefix xs. Some examples of built-in schema types include xs:integer, xs:string, and xs:date. Element and attribute declarations in the xs namespace are not implicitly included in the static context.

In addition, the predefined schema types of XQuery include the schema types defined in the namespace http://www.w3.org/2005/xpath-datatypes, which has the predefined namespace prefix xdt. The schema types in this namespace are defined in and are summarized below.

The relationships among the schema types in the xs and xdt namespaces are illustrated in Figure 2. A more complete description of the XQuery type hierarchy can be found in .

Every node has a typed value and a string value. The typed value of a node is a sequence of atomic values and can be extracted by applying the fn:data function to the node. The string value of a node is a string and can be extracted by applying the fn:string function to the node. Definitions of fn:data and fn:string can be found in .

An implementation may store both the typed value and the string value of a node, or it may store only one of these and derive the other from it as needed. The string value of a node must be a valid lexical representation of the typed value of the node, but the node is not required to preserve the string representation from the original source document. For example, if the typed value of a node is the xs:integer value 30, its string value might be "30" or "0030".

The typed value, string value, and type annotation of a node are closely related, and are defined by rules found in the following locations:

As a convenience to the reader, the relationship between typed value and string value for various kinds of nodes is summarized and illustrated by examples below.

Whenever it is necessary to refer to a type in an XQuery expression, the SequenceType syntax is used.

With the exception of the special type empty-sequence(), a sequence type consists of an item type that constrains the type of each item in the sequence, and a cardinality that constrains the number of items in the sequence. Apart from the item type item(), which permits any kind of item, item types divide into node types (such as element()) and atomic types (such as xs:integer).

Item types representing element and attribute nodes may specify the required type annotations of those nodes, in the form of a schema type. Thus the item type element(*, us:address) denotes any element node whose type annotation is (or is derived from) the schema type named us:address.

Here are some examples of sequence types that might be used in XQuery expressions:

During evaluation of an expression, it is sometimes necessary to determine whether a value with a known dynamic type "matches" an expected sequence type. This process is known as SequenceType matching. For example, an instance of expression returns true if the dynamic type of a given value matches a given sequence type, or false if it does not.

QNames appearing in a sequence type have their prefixes expanded to namespace URIs by means of the statically known namespaces and (where applicable) the default element/type namespace. As usual, two expanded QNames are equal if their local parts are the same and their namespace URI's are the same. An unprefixed attribute QName is in no namespace.

The rules for SequenceType matching compare the dynamic type of a value with an expected sequence type. These rules are a subset of the formal rules that match a value with an expected type defined in , because the Formal Semantics must be able to match values against types that are not expressible using the SequenceType syntax.

Some of the rules for SequenceType matching require determining whether a given schema type is the same as or derived from an expected schema type. The given schema type may be "known" (defined in the in-scope schema definitions), or "unknown" (not defined in the in-scope schema definitions). An unknown schema type might be encountered, for example, if a source document has been validated using a schema that was not imported into the static context. In this case, an implementation is allowed (but is not required) to provide an implementation-dependent mechanism for determining whether the unknown schema type is derived from the expected schema type. For example, an implementation might maintain a data dictionary containing information about type hierarchies.

The use of a value whose dynamic type is derived from an expected type is known as subtype substitution. Subtype substitution does not change the actual type of a value. For example, if an xs:integer value is used where an xs:decimal value is expected, the value retains its type as xs:integer.

The definition of SequenceType matching relies on a pseudo-function named derives-from(AT, ET), which takes an actual simple or complex schema type AT and an expected simple or complex schema type ET, and either returns a boolean value or raises a type error . The pseudo-function derives-from is defined below and is defined formally in .

The rules for SequenceType matching are given below, with examples (the examples are for purposes of illustration, and do not cover all possible cases).

A literal is a direct syntactic representation of an atomic value. XQuery supports two kinds of literals: numeric literals and string literals.

The value of a numeric literal containing no "." and no e or E character is an atomic value of type xs:integer. The value of a numeric literal containing "." but no e or E character is an atomic value of type xs:decimal. The value of a numeric literal containing an e or E character is an atomic value of type xs:double. The value of the numeric literal is determined by casting it to the appropriate type according to the rules for casting from xdt:untypedAtomic to a numeric type as specified in .

The value of a string literal is an atomic value whose type is xs:string and whose value is the string denoted by the characters between the delimiting apostrophes or quotation marks. If the literal is delimited by apostrophes, two adjacent apostrophes within the literal are interpreted as a single apostrophe. Similarly, if the literal is delimited by quotation marks, two adjacent quotation marks within the literal are interpreted as one quotation mark.

A string literal may contain a predefined entity reference. A predefined entity reference is a short sequence of characters, beginning with an ampersand, that represents a single character that might otherwise have syntactic significance. Each predefined entity reference is replaced by the character it represents when the string literal is processed. The predefined entity references recognized by XQuery are as follows:

A string literal may also contain a character reference. A character reference is an XML-style reference to a character, identified by its decimal or hexadecimal code point. For example, the Euro symbol (€) can be represented by the character reference €. Character references are normatively defined in Section 4.1 of the XML specification (it is implementation-defined whether the rules in or apply.)

Here are some examples of literal expressions:

The xs:boolean values true and false can be represented by calls to the built-in functions fn:true() and fn:false(), respectively.

Values of other atomic types can be constructed by calling the constructor function for the given type. The constructor functions for XML Schema built-in types are defined in . In general, the name of a constructor function for a given type is the same as the name of the type (including its namespace). For example:

Constructor functions can also be used to create special values that have no literal representation, as in the following examples:

xs:float("NaN") returns the special floating-point value, "Not a Number."

It is also possible to construct values of various types by using a cast expression. For example:

A variable reference is a QName preceded by a $-sign. Two variable references are equivalent if their local names are the same and their namespace prefixes are bound to the same namespace URI in the statically known namespaces. An unprefixed variable reference is in no namespace.

Every variable reference must match a name in the in-scope variables, which include variables from the following sources:

A variable may be declared in a Prolog, in the current module or an imported module. See for a discussion of modules and Prologs.

Every variable binding has a static scope. The scope defines where references to the variable can validly occur. It is a static error to reference a variable that is not in scope. If a variable is bound in the static context for an expression, that variable is in scope for the entire expression.

If a variable reference matches two or more variable bindings that are in scope, then the reference is taken as referring to the inner binding, that is, the one whose scope is smaller. At evaluation time, the value of a variable reference is the value of the expression to which the relevant variable is bound. The scope of a variable binding is defined separately for each kind of expression that can bind variables.

Parentheses may be used to enforce a particular evaluation order in expressions that contain multiple operators. For example, the expression (2 + 4) * 5 evaluates to thirty, since the parenthesized expression (2 + 4) is evaluated first and its result is multiplied by five. Without parentheses, the expression 2 + 4 * 5 evaluates to twenty-two, because the multiplication operator has higher precedence than the addition operator.

Empty parentheses are used to denote an empty sequence, as described in .

A context item expression evaluates to the context item, which may be either a node (as in the expression fn:doc("bib.xml")/books/book[fn:count(./author)>1]) or an atomic value (as in the expression (1 to 100)[. mod 5 eq 0]).

If the context item is undefined, a context item expression raises a dynamic error .

The built-in functions supported by XQuery are defined in . Additional functions may be declared in a Prolog, imported from a library module, or provided by the external environment as part of the static context.

A function call consists of a QName followed by a parenthesized list of zero or more expressions, called arguments. If the QName in the function call has no namespace prefix, it is considered to be in the default function namespace.

If the expanded QName and number of arguments in a function call do not match the name and arity of a function signature in the static context, a static error is raised .

A function call is evaluated as follows:

The function conversion rules are used to convert an argument value or a return value to its expected type; that is, to the declared type of the function parameter or return. The expected type is expressed as a sequence type. The function conversion rules are applied to a given value as follows:

Since the arguments of a function call are separated by commas, any argument expression that contains a top-level comma operator must be enclosed in parentheses. Here are some illustrative examples of function calls:

A step is a part of a path expression that generates a sequence of items and then filters the sequence by zero or more predicates. The value of the step consists of those items that satisfy the predicates. A step may be either an axis step or a filter expression. Filter expressions are described in .

An axis step returns a sequence of nodes that are reachable from the context node via a specified axis. Such a step has two parts: an axis, which defines the "direction of movement" for the step, and a node test, which selects nodes based on their kind, name, and/or type annotation. If the context item is a node, an axis step returns a sequence of zero or more nodes; otherwise, a type error is raised . If ordering mode is ordered, the resulting node sequence is returned in document order; otherwise it is returned in implementation-dependent order. An axis step may be either a forward step or a reverse step, followed by zero or more predicates.

In the abbreviated syntax for a step, the axis can be omitted and other shorthand notations can be used as described in .

The unabbreviated syntax for an axis step consists of the axis name and node test separated by a double colon. The result of the step consists of the nodes reachable from the context node via the specified axis that have the node kind, name, and/or type annotation specified by the node test. For example, the step child::para selects the para element children of the context node: child is the name of the axis, and para is the name of the element nodes to be selected on this axis. The available axes are described in . The available node tests are described in . Examples of steps are provided in and .

A predicate consists of an expression, called a predicate expression, enclosed in square brackets. A predicate serves to filter a sequence, retaining some items and discarding others. For each item in the sequence to be filtered, the predicate expression is evaluated using an inner focus derived from that item, as described in . The result of the predicate expression is coerced to a xs:boolean value, called the predicate truth value, as described below. Those items for which the predicate truth value is true are retained, and those for which the predicate truth value is false are discarded.

The predicate truth value is derived by applying the following rules, in order:

Here are some examples of axis steps that contain predicates:

When using predicates with a sequence of nodes selected using a reverse axis, it is important to remember that the the context positions for such a sequence are assigned in reverse document order. For example, preceding::foo[1] returns the first qualifying foo element in reverse document order, because the predicate is part of an axis step using a reverse axis. By contrast, (preceding::foo)[1] returns the first qualifying foo element in document order, because the parentheses cause (preceding::foo) to be parsed as a primary expression in which context positions are assigned in document order. Similarly, ancestor::*[1] returns the nearest ancestor element, because the ancestor axis is a reverse axis, whereas (ancestor::*)[1] returns the root element (first ancestor in document order).

This section provides a number of examples of path expressions in which the axis is explicitly specified in each step. The syntax used in these examples is called the unabbreviated syntax. In many common cases, it is possible to write path expressions more concisely using an abbreviated syntax, as explained in .

The abbreviated syntax permits the following abbreviations:

Here are some examples of path expressions that use the abbreviated syntax:

One way to construct a sequence is by using the comma operator, which evaluates each of its operands and concatenates the resulting sequences, in order, into a single result sequence. Empty parentheses can be used to denote an empty sequence.

A sequence may contain duplicate atomic values or nodes, but a sequence is never an item in another sequence. When a new sequence is created by concatenating two or more input sequences, the new sequence contains all the items of the input sequences and its length is the sum of the lengths of the input sequences.

Here are some examples of expressions that construct sequences:

A range expression can be used to construct a sequence of consecutive integers. Each of the operands of the to operator is converted as though it was an argument of a function with the expected parameter type xs:integer?. If either operand is an empty sequence, or if the integer derived from the first operand is greater than the integer derived from the second operand, the result of the range expression is an empty sequence. If the two operands convert to the same integer, the result of the range expression is that integer. Otherwise, the result is a sequence containing the two integer operands and every integer between the two operands, in increasing order.

A filter expression consists simply of a primary expression followed by zero or more predicates. The result of the filter expression consists of all the items returned by the primary expression for which all the predicates are true. If no predicates are specified, the result is simply the result of the primary expression. The ordering of the items returned by a filter expression is the same as their order in the result of the primary expression. Context positions are assigned to items based on their ordinal position in the result sequence. The first context position is 1.

Here are some examples of filter expressions:

XQuery provides the following operators for combining sequences of nodes:

All these operators eliminate duplicate nodes from their result sequences based on node identity. If ordering mode is ordered, the resulting sequence is returned in document order; otherwise it is returned in implementation-dependent order.

If an operand of union, intersect, or except contains an item that is not a node, a type error is raised .

Here are some examples of expressions that combine sequences. Assume the existence of three element nodes that we will refer to by symbolic names A, B, and C. Assume that the variables $seq1, $seq2 and $seq3 are bound to the following sequences of these nodes:

Then:

In addition to the sequence operators described here, includes functions for indexed access to items or sub-sequences of a sequence, for indexed insertion or removal of items in a sequence, and for removing duplicate items from a sequence.

The value comparison operators are eq, ne, lt, le, gt, and ge. Value comparisons are used for comparing single values.

The first step in evaluating a value comparison is to evaluate its operands. The order in which the operands are evaluated is implementation-dependent. Each operand is evaluated by applying the following steps, in order:

After evaluation of the operands, if the types of the operands are a valid combination for the given operator, the operator is applied to the operands. The combinations of atomic types that are accepted by the various value comparison operators, and their respective result types, are listed in together with the operator functions that define the semantics of the operator for each type combination. The definitions of the operator functions are found in .

Informally, if both atomized operands consist of exactly one atomic value, then the result of the comparison is true if the value of the first operand is (equal, not equal, less than, less than or equal, greater than, greater than or equal) to the value of the second operand; otherwise the result of the comparison is false.

If the types of the operands, after evaluation, are not a valid combination for the given operator, according to the rules in , a type error is raised .

Here are some examples of value comparisons:

The general comparison operators are =, !=, <, <=, >, and >=. General comparisons are existentially quantified comparisons that may be applied to operand sequences of any length. The result of a general comparison that does not raise an error is always true or false.

A general comparison is evaluated by applying the following rules, in order:

When evaluating a general comparison in which either operand is a sequence of items, an implementation may return true as soon as it finds an item in the first operand and an item in the second operand that have the required magnitude relationship. Similarly, a general comparison may raise a dynamic error as soon as it encounters an error in evaluating either operand, or in comparing a pair of items from the two operands. As a result of these rules, the result of a general comparison is not deterministic in the presence of errors.

Here are some examples of general comparisons:

Node comparisons are used to compare two nodes, by their identity or by their document order. The result of a node comparison is defined by the following rules:

Here are some examples of node comparisons:

An element constructor creates an element node. A direct element constructor is a form of element constructor in which the name of the constructed element is a constant. Direct element constructors are based on standard XML notation. For example, the following expression is a direct element constructor that creates a book element containing an attribute and some nested elements:

If the element name in a direct element constructor has a namespace prefix, the namespace prefix is resolved to a namespace URI using the statically known namespaces. If the element name has no namespace prefix, it is implicitly qualified by the default element/type namespace. Note that both the statically known namespaces and the default element/type namespace may be affected by namespace declaration attributes found inside the element constructor. The namespace prefix of the element name is retained after expansion of the QName, as described in . The resulting expanded QName becomes the node-name property of the constructed element node.

In a direct element constructor, the name used in the end tag must exactly match the name used in the corresponding start tag, including its prefix or absence of a prefix.

In a direct element constructor, curly braces { } delimit enclosed expressions, distinguishing them from literal text. Enclosed expressions are evaluated and replaced by their value, as illustrated by the following example:

The above query might generate the following result (whitespace has been added for readability to this result and other result examples in this document):

Since XQuery uses curly braces to denote enclosed expressions, some convention is needed to denote a curly brace used as an ordinary character. For this purpose, a pair of identical curly brace characters within the content of an element or attribute are interpreted by XQuery as a single curly brace character (that is, the pair "{{" represents the character "{" and the pair "}}" represents the character "}".) Alternatively, the character references { and } can be used to denote curly brace characters. A single left curly brace ("{") is interpreted as the beginning delimiter for an enclosed expression. A single right curly brace ("}") without a matching left curly brace is treated as a static error .

The result of an element constructor is a new element node, with its own node identity. All the attribute and descendant nodes of the new element node are also new nodes with their own identities, even if they are copies of existing nodes.

XQuery allows an expression to generate a processing instruction node or a comment node. This can be accomplished by using a direct processing instruction constructor or a direct comment constructor. In each case, the syntax of the constructor expression is based on the syntax of a similar construct in XML.

A direct processing instruction constructor creates a processing instruction node whose target property is PITarget and whose content property is DirPIContents. The base-uri property of the node is empty. The parent property of the node is empty.

The PITarget of a processing instruction may not consist of the characters "XML" in any combination of upper and lower case. The DirPIContents of a processing instruction may not contain the string "?>".

The following example illustrates a direct processing instruction constructor:

A direct comment constructor creates a comment node whose content property is DirCommentContents. Its parent property is empty.

The DirCommentContents of a comment may not contain two consecutive hyphens or end with a hyphen. These rules are syntactically enforced by the grammar shown above.

The following example illustrates a direct comment constructor:

An alternative way to create nodes is by using a computed constructor. A computed constructor begins with a keyword that identifies the type of node to be created: element, attribute, document, text, processing-instruction, or comment.

For those kinds of nodes that have names (element, attribute, and processing instruction nodes), the keyword that specifies the node kind is followed by the name of the node to be created. This name may be specified either as a QName or as an expression enclosed in braces. When an expression is used to specify the name of a constructed node, that expression is called the name expression of the constructor.

The final part of a computed constructor is an expression enclosed in braces, called the content expression of the constructor, that generates the content of the node.

The following example illustrates the use of computed element and attribute constructors in a simple case where the names of the constructed nodes are constants. This example generates exactly the same result as the first example in :

An element node constructed by a direct or computed element constructor has an in-scope namespaces property that consists of a set of namespace bindings. The in-scope namespaces of an element node may affect the way the node is serialized (see ), and may also affect the behavior of certain functions that operate on nodes, such as fn:name. Note the difference between in-scope namespaces, which is a dynamic property of an element node, and statically known namespaces, which is a static property of an expression. Also note that one of the namespace bindings in the in-scope namespaces may have no prefix (denoting the default namespace for the given element). The in-scope namespaces of a constructed element node consist of the following namespace bindings:

The following query serves as an example:

The in-scope namespaces of the resulting p:a element consists of the following namespace bindings:

The namespace bindings for p and q are added to the result element because their respective namespaces are used in the names of the element and its attributes. The namespace binding r="http://example.com/ns/r" is added to the in-scope namespaces of the constructed element because it is defined by a namespace declaration attribute, even though it is not used in a name.

No namespace binding corresponding to f="http://example.com/ns/f" is created, because the namespace prefix f appears only in the query prolog and is not used in an element or attribute name of the constructed node. This namespace binding does not appear in the query result, even though it is present in the statically known namespaces and is available for use during processing of the query.

Note that the following constructed element, if nested within a validate expression, cannot be validated:

The constructed element will have namespace bindings for the prefixes xsi (because it is used in a name) and xml (because it is defined for every constructed element node). During validation of the constructed element, the validator will be unable to interpret the namespace prefix xs because it is has no namespace binding. Validation of this constructed element could be made possible by providing a namespace declaration attribute, as in the following example:

The purpose of the for and let clauses in a FLWOR expression is to produce a tuple stream in which each tuple consists of one or more bound variables.

The simplest example of a for clause contains one variable and an associated expression. The value of the expression associated with a variable in a for clause is called the binding sequence for that variable. The for clause iterates over the items in the binding sequence, binding the variable to each item in turn. If ordering mode is ordered, the resulting sequence of variable bindings is ordered according to the order of values in the binding sequence; otherwise the ordering of the variable bindings is implementation-dependent.

A for clause may also contain multiple variables, each with an associated expression whose value is the binding sequence for that variable. In this case, the for clause iterates each variable over its binding sequence. The resulting tuple stream contains one tuple for each combination of values in the respective binding sequences. If ordering mode is ordered, the order of the tuple stream is determined primarily by the order of the binding sequence of the leftmost variable, and secondarily by the binding sequences of the other variables, working from left to right. Otherwise, the ordering of the variable bindings is implementation-dependent.

A let clause may also contain one or more variables, each with an associated expression. Unlike a for clause, however, a let clause binds each variable to the result of its associated expression, without iteration. The variable bindings generated by let clauses are added to the binding tuples generated by the for clauses. If there are no for clauses, the let clauses generate one tuple containing all the variable bindings.

Although for and let clauses both bind variables, the manner in which variables are bound is quite different, as illustrated by the following examples. The first example uses a let clause:

The variable $s is bound to the result of the expression (<one/>, <two/>, <three/>). Since there are no for clauses, the let clause generates one tuple that contains the binding of $s. The return clause is invoked for this tuple, creating the following output:

The next example is a similar query that contains a for clause instead of a let clause:

In this example, the variable $s iterates over the given expression. If ordering mode is ordered, $s is first bound to <one/>, then to <two/>, and finally to <three/>. One tuple is generated for each of these bindings, and the return clause is invoked for each tuple, creating the following output:

The following example illustrates how binding tuples are generated by a for clause that contains multiple variables when ordering mode is ordered.

The tuple stream generated by the above for clause is as follows:

If ordering mode were unordered, the for clause in the above example would generate the same tuple stream but the order of the tuples would be implementation-dependent.

The scope of a variable bound in a for or let clause comprises all subexpressions of the containing FLWOR expression that appear after the variable binding. The scope does not include the expression to which the variable is bound. The following example illustrates how bindings in for and let clauses may reference variables that were bound in earlier clauses, or in earlier bindings in the same clause of the FLWOR expression:

The for and let clauses of a given FLWOR expression may bind the same variable name more than once. In this case, each new binding occludes the previous one, which becomes inaccessible in the remainder of the FLWOR expression.

Each variable bound in a for or let clause may have an optional type declaration, which is a type declared using the syntax in . If the type of a value bound to the variable does not match the declared type according to the rules for SequenceType matching, a type error is raised . For example, the following expression raises a type error because the variable $salary has a type declaration that is not satisfied by the value that is bound to the variable:

Each variable bound in a for clause may have an associated positional variable that is bound at the same time. The name of the positional variable is preceded by the keyword at. The positional variable always has an implied type of xs:integer. As a variable iterates over the items in its binding sequence, its positional variable iterates over the integers that represent the ordinal positions of those items in the binding sequence, starting with 1.

Positional variables are illustrated by the following for clause:

If ordering mode is ordered, the tuple stream generated by the above for clause is as follows:

If ordering mode is unordered, the order of the tuple stream is implementation-dependent. In addition, if a for clause contains subexpressions that are affected by ordering mode, the association of positional variables with items returned by these subexpressions is implementation-dependent if ordering mode is unordered.

The optional where clause serves as a filter for the tuples of variable bindings generated by the for and let clauses. The expression in the where clause, called the where-expression, is evaluated once for each of these tuples. If the effective boolean value of the where-expression is true, the tuple is retained and its variable bindings are used in an execution of the return clause. If the effective boolean value of the where-expression is false, the tuple is discarded. The effective boolean value of an expression is defined in .

The following expression illustrates how a where clause might be applied to a positional variable in order to perform sampling on an input sequence. This expression approximates the average value in a sequence by sampling one value out of each one hundred input values.

The return clause of a FLWOR expression is evaluated once for each tuple in the tuple stream, and the results of these evaluations are concatenated, as if by the comma operator, to form the result of the FLWOR expression.

If no order by clause is present, the order of the tuple stream is determined by the for and let clauses and by ordering mode. If an order by clause is present, it reorders the tuples in the tuple stream into a new, value-based order. In either case, the resulting order determines the order in which the return clause is evaluated, once for each tuple, using the variable bindings in the respective tuples. Note that ordering mode has no effect on a FLWOR expression if an order by clause is present, since order by takes precedence over ordering mode.

An order by clause contains one or more ordering specifications, called orderspecs, as shown in the grammar above. For each tuple in the tuple stream, after filtering by the where clause, the orderspecs are evaluated, using the variable bindings in that tuple. The relative order of two tuples is determined by comparing the values of their orderspecs, working from left to right until a pair of unequal values is encountered. If an orderspec specifies a collation, that collation is used in comparing values of type xs:string, xs:anyURI, or types derived from them (otherwise, the default collation is used). If an orderspec specifies a collation by a relative URI, that relative URI is resolved to an absolute URI using the base URI in the static context. If an orderspec specifies a collation that is not found in statically known collations, an error is raised .

The process of evaluating and comparing the orderspecs is based on the following rules:

When two orderspec values are compared to determine their relative position in the ordering sequence, the greater-than relationship is defined as follows:

If T1 and T2 are two tuples in the tuple stream, and V1 and V2 are the first pair of values encountered when evaluating their orderspecs from left to right for which one value is greater-than the other (as defined above), then:

If neither V1 nor V2 is greater-than the other for any pair of orderspecs for tuples T1 and T2, the following rules apply.

An order by clause makes it easy to sort the result of a FLWOR expression, even if the sort key is not included in the result of the expression. For example, the following expression returns employee names in descending order by salary, without returning the actual salaries:

The following example illustrates an order by clause that uses several options. It causes a collection of books to be sorted in primary order by title, and in secondary descending order by price. A specific collation is specified for the title ordering, and in the ordering by price, books with no price are specified to occur last (as though they have the least possible price). Whenever two books with the same title and price occur, the keyword stable indicates that their input order is preserved.

The following example illustrates how FLWOR expressions can be nested, and how ordering can be specified at multiple levels of an element hierarchy. The example query inverts a document hierarchy to transform a bibliography into an author list. The input (bound to the variable $bib) is a bib element containing a list of books, each of which in turn contains a list of authors. The example is based on the following input:

The following query transforms the input document into a list in which each author's name appears only once, followed by a list of titles of books written by that author. The fn:distinct-values function is used to eliminate duplicates (by value) from a list of author nodes. The author list, and the lists of books published by each author, are returned in alphabetic order using the default collation.

The result of the above expression is as follows:

The boolean operator instance of returns true if the value of its first operand matches the SequenceType in its second operand, according to the rules for SequenceType matching; otherwise it returns false. For example:

The typeswitch expression chooses one of several expressions to evaluate based on the dynamic type of an input value.

In a typeswitch expression, the typeswitch keyword is followed by an expression enclosed in parentheses, called the operand expression. This is the expression whose type is being tested. The remainder of the typeswitch expression consists of one or more case clauses and a default clause.

Each case clause specifies a SequenceType followed by a return expression. The effective case in a typeswitch expression is the first case clause such that the value of the operand expression matches the SequenceType in the case clause, using the rules of SequenceType matching. The value of the typeswitch expression is the value of the return expression in the effective case. If the value of the operand expression does not match any SequenceType named in a case clause, the value of the typeswitch expression is the value of the return expression in the default clause.

In a case or default clause, if the value to be returned depends on the value of the operand expression, the clause must specify a variable name. Within the return expression of the case or default clause, this variable name is bound to the value of the operand expression. Inside a case clause, the static type of the variable is the SequenceType named in the case clause. Inside a default clause, the static type of the variable is the same as the static type of the operand expression. If the value to be returned by a case or default clause does not depend on the value of the operand expression, the clause need not specify a variable.

The scope of a variable binding in a case or default clause comprises that clause. It is not an error for more than one case or default clause in the same typeswitch expression to bind variables with the same name.

A special rule applies to propagation of dynamic errors by typeswitch expressions. A typeswitch expression ignores (does not raise) any dynamic errors encountered in case clauses other than the effective case. Dynamic errors encountered in the default clause are raised only if there is no effective case.

The following example shows how a typeswitch expression might be used to process an expression in a way that depends on its dynamic type.

Occasionally it is necessary to convert a value to a specific datatype. For this purpose, XQuery provides a cast expression that creates a new value of a specific type based on an existing value. A cast expression takes two operands: an input expression and a target type. The type of the input expression is called the input type. The target type must be an atomic type that is in the in-scope schema types and is not xs:NOTATION or xdt:anyAtomicType, optionally followed by the occurrence indicator "?" to denote that an empty sequence is permitted . If the target type has no namespace prefix, it is considered to be in the default element/type namespace. The semantics of the cast expression are as follows:

If casting from the input type to the target type is supported but nevertheless it is not possible to cast the input value into the value space of the target type, a dynamic error is raised. [err:FORG0001] This includes the case when any facet of the target type is not satisfied. For example, the expression "2003-02-31" cast as xs:date would raise a dynamic error.

XQuery provides an expression that tests whether a given value is castable into a given target type. The target type must be an atomic type that is in the in-scope schema types and is not xs:NOTATION or xdt:anyAtomicType, optionally followed by the occurrence indicator "?" to denote that an empty sequence is permitted . The expression V castable as T returns true if the value V can be successfully cast into the target type T by using a cast expression; otherwise it returns false. The castable expression can be used as a predicate to avoid errors at evaluation time. It can also be used to select an appropriate type for processing of a given value, as illustrated in the following example:

For every atomic type in the in-scope schema types (except xs:NOTATION and xdt:anyAtomicType, which are not instantiable), a constructor function is implicitly defined. In each case, the name of the constructor function is the same as the name of its target type (including namespace). The signature of the constructor function for type T is as follows:

The constructor function for a given type is used to convert instances of other atomic types into the given type. The semantics of the constructor function T($arg) are defined to be equivalent to the expression ($arg cast as T?).

The constructor functions for xs:QName and for types derived from xs:QName and xs:NOTATION require their arguments to be string literals; otherwise a static error is raised. This rule is consistent with the semantics of cast expressions for these types, as defined in .

The following examples illustrate the use of constructor functions:

XQuery provides an expression called treat that can be used to modify the static type of its operand.

Like cast, the treat expression takes two operands: an expression and a SequenceType. Unlike cast, however, treat does not change the dynamic type or value of its operand. Instead, the purpose of treat is to ensure that an expression has an expected dynamic type at evaluation time.

The semantics of expr1 treat as type1 are as follows:

The Schema Import Feature permits the query Prolog to contain a schema import.

If an XQuery implementation does not support the Schema Import Feature, it MUST raise a static error if it encounters a schema import.

The Schema Validation Feature permits a query to contain a validate expression (see .)

If an XQuery implementation does not support the Schema Validation Feature, it MUST raise a static error if it encounters a validate expression.

The Static Typing Feature provides support for the static semantics defined in , and requires implementations to detect and report type errors during the static analysis phase.

If an implementation does not support the Static Typing Feature, but can nevertheless determine during the static analysis phase that an expression, if evaluated, will necessarily raise a type error at run time, the implementation MAY raise that error during the static analysis phase. The choice of whether to raise such an error at analysis time is implementation dependent.

The following axes are designated as optional axes: ancestor, ancestor-or-self, following, following-sibling, preceding, and preceding-sibling.

A conforming XQuery implementation that supports the Full Axis Feature MUST support all the optional axes.

Conforming XQuery implementations that do not support the Full Axis Feature MAY support one or more optional axes; it is implementation-defined which optional axes are supported by such implementations. A conforming implementation that encounters a reference to an optional axis that it does not support MUST raise a static error .

A conforming XQuery implementation that supports the Module Feature allows a query Prolog to contain a Module Import and allows library modules to be created.

A conforming implementation that does not support the Module Feature MUST raise a static error if it encounters a module declaration or a module import. Since a module declaration is required in a library module, the Module Feature is required in order to create a library module.

A conforming XQuery implementation that supports the Serialization Feature MUST provide means for serializing the result of a query, as specified in .

A conforming XQuery implementation that supports the Serialization Feature MUST conform to . The means by which serialization is invoked is implementation-defined.

If an error is raised during the serialization process as specified in , an conforming XQuery implementation MUST report the error to the calling environment.

A conforming XQuery implementation that supports the Trivial XML Embedding Feature MUST provide the embedding specified in Section 5, "A Trivial Embedding of XQuery."