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 described below. Rules governing the scope and initialization and alteration 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 is , a dynamic error is raised .

The individual components of the dynamic context are summarized described below. Rules governing the initialization and alteration 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. If any component in the focus is defined, all components of the focus are defined. A singleton focus is a focus that refers to a single item; in a singleton focus, context item is set to the item, context position = 1 and context size = 1.

Certain language constructs, notably the path operator E1/E2, the simple mapping operator, and the predicate 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 3.0 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.

An error that must can be detected during the static analysis phase, and is not a type error, is a static error. 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.

If more than one error is present, or if an error condition comes within the scope of more than one error defined in this specification, then any non-empty subset of these errors may be reported.

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 a QueryBody , if evaluated, would necessarily raise a dynamic error or that an expression, if evaluated, would necessarily raise a type error, the implementation may (but is not required to) report that error during the static analysis phase.

An implementation can raise a dynamic error for a QueryBody statically only if the query can never execute without raising that error, as in the following example:

The following example contains a type error, which can be reported statically even if the implementation can not prove that the expression will actually be evaluated.

In addition to static errors, dynamic errors, and type errors, an XQuery 3.0 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. An error must be raised if such a limitation is exceeded .

Any limits on primitives defined by the XML and XSD specifications that differ from what these specifications state are implementation-defined, and must be documented. See . should not be raised for these.

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

The method by which an XQuery 3.0 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 (see ). 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. XQuery 3.0 provides standard error handling via .

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 always raises a dynamic 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 raising 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 raising 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: If a processor evaluates an operand E (wholly or in part), then it 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 may rewrite expressions into a different form. There are a number of rules that limit the extent of this freedom:

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. 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. The node ordering that is the reverse of document order is called reverse document order.

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 3.0 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 3.0 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 3.0 are as follows:

These input functions are all specified in , which specifies error conditions and other details not described here.

XQuery 3.0 requires a statically known, valid URI in a URILiteral or a BracedURILiteral. An implementation may raise a static error if the value of a URI Literal or a Braced URI Literal is of nonzero length and is not in the lexical space of xs:anyURI neither an absolute URI nor a relative URI.

As in a string literal, any predefined entity reference (such as &), character reference (such as •), or EscapeQuot or EscapeApos (for example, "") is replaced by its appropriate expansion. Certain characters, notably the ampersand, can only be represented using a predefined entity reference or a character reference.

A Braced URI Literal or URI Literal is subjected to whitespace normalization as defined for the xs:anyURI type in or : this means that leading and trailing whitespace is removed, and any other sequence of whitespace characters is replaced by a single space (#x20) character. Whitespace normalization is done after the expansion of character references, so writing a newline (for example) as 
 does not prevent its being normalized to a space character.

Whitespace is normalized using the whitespace normalization rules of fn:normalize-space. If the result of whitespace normalization contains only whitespace, the corresponding URI consists of the empty string. Whitespace normalization is done after the expansion of character references, so writing a newline (for example) as 
 does not prevent its being normalized to a space character.

A Braced URI Literal or URI Literal is not automatically subjected to percent-encoding or decoding as defined in .

To resolve a relative URI $rel against a base URI $base is to expand it to an absolute URI, as if by calling the function fn:resolve-uri($rel, $base). During static analysis, the base URI is the Static Base URI. During dynamic evaluation, the base URI used to resolve a relative URI reference depends on the semantics of the expression.

Any process that attempts to resolve URI against a base URI, or to dereference the URI, may apply percent-encoding or decoding as defined in the relevant RFCs.

The schema types defined in are summarized below.

The in-scope schema types in the static context are initialized with certain predefined schema types, including the built-in schema types in the namespace http://www.w3.org/2001/XMLSchema, which has the predefined namespace prefix xs. The schema types in this namespace are defined in or and augmented by additional types defined in . Element and attribute declarations in the xs namespace are not implicitly included in the static context. The schema types defined in are summarized below.

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

The namespace-sensitive types are xs:QName, xs:NOTATION, types derived by restriction from xs:QName or xs:NOTATION, list types that have a namespace-sensitive item type, and union types with a namespace-sensitive type in their transitive membership.

It is not possible to preserve the type of a namespace-sensitive value without also preserving the namespace binding that defines the meaning of each namespace prefix used in the value. Therefore, XQuery 3.0 defines some error conditions that occur only with namespace-sensitive values. For instance, casting to a namespace-sensitive type raises a type error [err:FONS0004] if the namespace bindings for the result cannot be determined. copying nodes with namespace-sensitive types can raise such an error if done using a mode that prohibits copying namespace bindings (see ), and casts to namespace-sensitive types raise an error if the input expression, when evaluated, contains a node (see ).

Every node has a typed value and a string value , except for nodes whose value is . 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 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 3.0 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()), generalized atomic types (such as xs:integer) and function types (such as function() as item()*).

Lexical 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 or default function namespace . Equality of QNames is defined by the eq operator.

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.

The occurrence indicators '+', '*', and '?' bind to the last ItemType in the SequenceType, as described in occurrence-indicators constraint.

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

SequenceType matching compares the dynamic type of a value with an expected sequence type.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.

An XQuery 3.0 implementation must be able to determine relationships among the types in type annotations in an XDM instance and the types in the in-scope schema definitions (ISSD). An XQuery 3.0 implementation must be able to determine relationships among the types in ISSDs used in different modules of the same query.

Some of the rules for SequenceType matching require determining whether a given schema type encountered as a type annotation in an instance document is the same as or derived from an expected schema type. This determination is done by reference to a schema S (that is, a set of schema components). This schema S is the union of:

A type error may be raised if this union does not constitute a valid schema (for example, if there are conflicts between types present in the static context and types used dynamically for validating instances.)

Whether the schema used to validate the instance document is in S is implementation-defined. Whether the implementation provides further schema components in S is also implementation-defined.

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 . This function is defined as follows:

Formally, it returns true if AT and ET are both present in S and AT is validly derived from ET given the empty set, as defined in or Part 1 constraints Type Derivation OK (Complex) (if AT is a complex type), or Type Derivation OK (Simple) (if AT is a simple type). The phrase "given the empty set" is used because the rules in the XML Schema specification are parameterized: the parameter is a list of the kinds of derivation that are not allowed, and in this case the list is always empty.

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

Given two sequence types, it is possible to determine if one is a subtype of the other. A sequence type A is a subtype of a sequence type B if the judgement subtype(A, B) is true. When the judgement subtype(A, B) is true, it is always the case that for any value V, (V instance of A) implies (V instance of B).

The type xs:error has an empty value space; it never appears as a dynamic type or as the content type of a dynamic element or attribute type. xs:error offers an alternative way of raising errors, in addition to fn:error.

A cast to xs:error raises an error or returns the empty sequence. Promotion to xs:error is not possible. Neither xs:error nor xs:error+ can ever match a value. xs:error is a subtype of all simple types, and a supertype only of itself. xs:error? and xs:error* are identical to empty-sequence(). A variable binding with a type declaration xs:error always raises a type error. Calling a function in the signature in which xs:error appears always raises a type error .

A literal is a direct syntactic representation of an atomic value. XQuery 3.0 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 xs: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 codepoint. 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.) A static error is raised if a character reference does not identify a valid character in the version of XML that is in use.

Here are some examples of literal expressions:

The xs:boolean values true and false can be constructed 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."

Constructor functions are available for all Generalized atomic types, including union types. For example, if my:dt is a user-defined union type whose member types are xs:date, xs:time, and xs:dateTime, then the expression my:dt("2011-01-10") creates an atomic value of type xs:date. The rules follow XML Schema validation rules for union types: the effect is to choose the first member type that accepts the given string in its lexical space.

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

A variable reference is an EQName 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. Two variable references are equivalent if their expanded QNames are equal (as defined by the eq operator). The scope of a variable binding is defined separately for each kind of expression that can bind variables.

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

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 except where it is occluded by another binding that uses the same name within that scope.

A reference to a variable that was declared external, but was not bound to a value by the external environment, raises a dynamic error .

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.

Parentheses may be used to override the precedence rules. 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 or function item (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 3.0 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 static function call consists of an EQName followed by a parenthesized list of zero or more arguments. An argument to a function call is either an argument expression or an ArgumentPlaceholder ("?"). If the EQName in a static function call is a lexical QName that has no namespace prefix, it is considered to be in the default function namespace.

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

A static or dynamic function call or dynamic function invocation is a partial function application if one or more arguments is an ArgumentPlaceholder. It is a static error if a static function call is a partial function application and the identified function is a context-dependent built-in function .

Evaluation of partial function applications is described in , while evaluation of (non-partial) function calls is described in .

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 static function calls:

A literal function item named function reference creates a function item that represents denotes a named function. A named function is a function defined in the static context for the query. To uniquely identify a particular named function, both its name as an expanded QName and its arity are required.

If the EQName is a lexical QName that has no namespace prefix, it is considered to be in the default function namespace.

If the expanded QName and arity in a literal function item named function reference do not match the name and arity of a function signature in the static context, a static error is raised .

The result of a literal function item named function reference is a single function item with the following properties (as defined in ):

An empty set of variable values.

The value of a NamedFunctionRef is the function obtained by looking up the expanded QName and arity in the named functions component of the dynamic context.

Furthermore, if the function referenced by a NamedFunctionRef has an implementation-dependent implementation, then the implementation of the function returned by the NamedFunctionRef is associated with the static context of this NamedFunctionRef expression and to the dynamic context in which it is currently being evaluated. If the function referenced by a NamedFunctionRef is a context-dependent built-in function .

It is a static error if the function referenced by a NamedFunctionRef is a context-dependent built-in function .

Certain functions in the specification are defined to be polymorphic. These are denoted as accepting parameters of "numeric" type, or returning "numeric" type. Here "numeric" is a pseudonym for the four primitive numeric types xs:decimal, xs:integer, xs:float, and xs:double. The functions in question are:

fn:abs

The following are examples of literal function item expressions named function references:

An inline function expression creates an anonymous function defined directly in the inline function expression itself. An inline function expression specifies the names and SequenceTypes of the parameters to the function, the SequenceType of the result, and the body of the function.

If a function parameter is declared using a name but no type, its default type is item()*. If the result type is omitted from an inline function expression, its default result type is item()*.

The parameters of an inline function expression are considered to be variables whose scope is the function body. It is a static error for an inline function expression to have more than one parameter with the same name.

An inline function expression may have annotations. XQuery 3.0 does not define annotations that apply to inline function expressions, in particular it is a static error if an inline function expression is annotated as %public or %private. An implementation can define annotations, in its own namespace, to support functionality beyond the scope of this specification.

The static context for the function body is inherited from the location of the inline function expression, with the exception of the static type of the context item which is initially .

The variables in scope for the function body include all variables representing the function parameters, as well as all variables that are in scope for the inline function expression.

Function parameter names can mask variables that would otherwise be in scope for the function body.

The result of an inline function expression is a single function item with the following properties (as defined in ):

name: An absent name. Absent.

The following are examples of some inline function expressions:

A filter expression consists of a base expression followed by a predicate, which is an expression written in square brackets. The result of the filter expression consists of the items returned by the base expression, filtered by applying the predicate to each item in turn. The ordering of the items returned by a filter expression is the same as their order in the result of the primary expression.

Here are some examples of filter expressions:

For each item in the input sequence, the predicate expression is evaluated using an inner focus, defined as follows: The context item is the item currently being tested against the predicate. The context size is the number of items in the input sequence. The context position is the position of the context item within the input sequence.

For each item in the input sequence, the result of the predicate expression is coerced to an 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:

A dynamic function invocation call consists of a PrimaryExpr base expression that returns the function item and a parenthesized list of zero or more arguments (argument expressions or ArgumentPlaceholders).

If the PrimaryExpr does not return a sequence consisting of a single function item with the same arity as the number of specified arguments, a type error is raised .

A dynamic function invocation is a partial function application if at least one of the arguments is an ArgumentPlaceholder ("?"), and is evaluated according to the rules in .

A dynamic function invocation that is not a partial function application invokes the function item, calling the function it represents, and is evaluated as described in .

A dynamic function call is evaluated as described in .

The following are examples of some dynamic function invocations calls:

Relative path expressions are binary operators on step expressions, which are named E1 and E2 in this section.

Each non-initial occurrence of "//" in a path expression is expanded as described in , leaving a sequence of steps separated by either "/" or "!", which have the same precedence. This sequence of steps is then evaluated from left to right. Each item produced by the evaluation of E1 is used as the context item to evaluate E2; the sequences resulting from all the evaluations of E2 are combined to produce a result.

The following example illustrates the use of relative path expressions.

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, working from left to right. A step may be either an axis step or a postfix expression. Postfix 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 within a Step has similar syntax and semantics to a predicate within a filter expression. The only difference is in the way the context position is set for evaluation of the predicate.

For the purpose of evaluating the context position within a predicate, the input sequence is considered to be sorted as follows: into document order if the predicate is in a forward-axis step, into reverse document order if the predicate is in a reverse-axis step, or in its original order if the predicate is not in a step.

Here are some examples of axis steps that contain predicates:

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 items, 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.

XQuery 3.0 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 .

If an IntersectExceptExpr contains more than two InstanceofExprs, they are grouped from left to right. With a UnionExpr, it makes no difference how operands are grouped, the results are the same.

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:

Next, if possible, the two operands are converted to their least common type by a combination of type promotion and subtype substitution. For example, if the operands are of type hatsize (derived from xs:integer) and shoesize (derived from xs:float), their least common type is xs:float.

Finally, 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 lexical 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 must not consist of the characters "XML" in any combination of upper and lower case. The DirPIContents of a processing instruction must 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 must 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, comment, or namespace.

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 an EQName 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:

In an element constructor, if two or more namespace bindings in the in-scope bindings would have the same prefix, then an error is raised if they have different URIs ; if they would have the same prefix and URI, duplicate bindings are ignored. If the name of an element in an element constructor is in no namespace, creating a default namespace for that element using a computed namespace constructor is an error . For instance, the following computed constructor raises an error because the element's name is not in a namespace, but a default namespace is defined.

The following query serves as an example illustrates the in-scope namespaces of a constructed element:

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