XQuery 3.0: An XML Query Language

2.1.1 Static Context

[Definition: 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.

The individual components of the static context are described below. Rules governing the initialization and alteration of these components can be found in C.1 Static Context Components.

• [Definition: XPath 1.0 compatibility mode. This component must be set by all host languages that include XPath 3.0 as a subset, indicating whether rules for compatibility with XPath 1.0 are in effect. XQuery sets the value of this component to false. ]

• [Definition: Statically known namespaces. This is a mapping from prefix to namespace URI that defines all the namespaces that are known during static processing of a given expression.] The URI value is whitespace normalized according to the rules for the xs:anyURI type in [XML Schema 1.0] or [XML Schema 1.1]. 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.

  Some namespaces are predefined; additional namespaces can be added to the statically known namespaces by namespace declarations, schema imports, or module imports in a Prolog, by a module declaration , and by namespace declaration attributes in direct element constructors.

• [Definition: Default element/type namespace. This is a namespace URI or absent^DM30. The namespace URI, if present, is used for any unprefixed QName appearing in a position where an element or type name is expected.] The URI value is whitespace normalized according to the rules for the xs:anyURI type in [XML Schema 1.0] or [XML Schema 1.1].

• [Definition: Default function namespace. This is a namespace URI or absent^DM30. The namespace URI, if present, is used for any unprefixed QName appearing in a position where a function name is expected.] The URI value is whitespace normalized according to the rules for the xs:anyURI type in [XML Schema 1.0] or [XML Schema 1.1].

• [Definition: In-scope schema definitions. This is a generic term for all the element declarations, attribute declarations, and schema type definitions that are in scope during static analysis of an expression.] It includes the following three parts:

  • [Definition: In-scope schema types. Each schema type definition is identified either by an expanded QName (for a named type) or by an implementation-dependent type identifier (for an anonymous type). The in-scope schema types include the predefined schema types described in 2.5.1 Predefined Schema Types. If the Schema Aware Feature is supported, in-scope schema types also include all type definitions found in imported schemas. ]

  • [Definition: In-scope element declarations. Each element declaration is identified either by an expanded QName (for a top-level element declaration) or by an implementation-dependent element identifier (for a local element declaration). If the Schema Aware Feature is supported, in-scope element declarations include all element declarations found in imported schemas. ] An element declaration includes information about the element's substitution group affiliation.

    [Definition: Substitution groups are defined in [XML Schema 1.0] and [XML Schema 1.1] Part 1. Informally, the substitution group headed by a given element (called the head element) consists of the set of elements that can be substituted for the head element without affecting the outcome of schema validation.]

  • [Definition: In-scope attribute declarations. Each attribute declaration is identified either by an expanded QName (for a top-level attribute declaration) or by an implementation-dependent attribute identifier (for a local attribute declaration). If the Schema Aware Feature is supported, in-scope attribute declarations include all attribute declarations found in imported schemas. ]

• [Definition: In-scope variables. This is a mapping from expanded QName to type. It defines the set of variables that are available for reference within an expression. The expanded QName is the name of the variable, and the type is the static type of the variable.]

  Variable declarations in a Prolog are added to in-scope variables. An expression that binds a variable extends the in-scope variables, within the scope of the variable, with the variable and its type. Within the body of an inline function expression or user-defined function , the in-scope variables are extended by the names and types of the function parameters.

  The static type of a variable may either be declared in a query or inferred by static type inference as discussed in 2.2.3.1 Static Analysis Phase.

• [Definition: Context item static type. This component defines the static type of the context item within the scope of a given expression.]

• [Definition: Statically known function signatures. This is a mapping from (expanded QName, arity) to function signature^DM30. ] The entries in this mapping define the set of statically known functions — those functions that are available to be called from a static function call, or referenced from a named function reference. Each such function is uniquely identified by its expanded QName and arity (number of parameters). Given a statically known function's expanded QName and arity, this component supplies the function's signature^DM30, which specifies various static properties of the function, including typesand annotations.

  The statically known function signatures include the signatures of functions from a variety of sources, including built-in functions described in [XQuery and XPath Functions and Operators 3.0], functions declared in the current module (see 4.18 Function Declaration), module imports (see 4.12 Module Import), constructor functions (see 3.16.5 Constructor Functions), and functions provided by an implementation or via an implementation-defined API (see C.1 Static Context Components). It is a static error [err:XQST0034] if two such functions have the same expanded QName and the same arity (even if the signatures are consistent).

• [Definition: Statically known collations. This is an implementation-defined mapping from URI to collation. It defines the names of the collations that are available for use in processing queries and expressions.] [Definition: A collation is a specification of the manner in which strings and URIs are compared and, by extension, ordered. For a more complete definition of collation, see [XQuery and XPath Functions and Operators 3.0].]

• [Definition: Default collation. This identifies one of the collations in statically known collations as the collation to be used by functions and operators for comparing and ordering values of type xs:string and xs:anyURI (and types derived from them) when no explicit collation is specified.]

• [Definition: Construction mode. The construction mode governs the behavior of element and document node constructors. If construction mode is preserve, the type of a constructed element node is xs:anyType, and all attribute and element nodes copied during node construction retain their original types. If construction mode is strip, the type of a constructed element node is xs:untyped; all element nodes copied during node construction receive the type xs:untyped, and all attribute nodes copied during node construction receive the type xs:untypedAtomic.]

• [Definition: Ordering mode. Ordering mode, which has the value ordered or unordered, affects the ordering of the result sequence returned by certain expressions, as discussed in 3.11 Ordered and Unordered Expressions. ]

• [Definition: Default order for empty sequences. This component controls the processing of empty sequences and NaN values as ordering keys in an order by clause in a FLWOR expression, as described in 3.10.8 Order By Clause.] Its value may be greatest or least.

• [Definition: Boundary-space policy. This component controls the processing of boundary whitespace by direct element constructors, as described in 3.9.1.4 Boundary Whitespace.] Its value may be preserve or strip.

• [Definition: Copy-namespaces mode. This component controls the namespace bindings that are assigned when an existing element node is copied by an element constructor, as described in 3.9.1 Direct Element Constructors. Its value consists of two parts: preserve or no-preserve, and inherit or no-inherit.]

• [Definition: Static Base URI. This is an absolute URI, used to resolve relative URIs both during static analysis and during dynamic evaluation. ] All expressions within a module have the same static base URI. The Static Base URI can be set using a base URI declaration. The Static Base URI is available during dynamic evaluation by use of the fn:static-base-uri function, and is used implicitly during dynamic evaluation by functions such as fn:doc. Relative URI references are resolved as described in 2.4.6 Resolving a Relative URI Reference.

  If the value of the Static Base URI is based on the location of the query module (in the terminology of [RFC3986], the URI used to retrieve the encapsulating entity), then the implementation may use different values for the Static Base URI during static analysis and during dynamic evaluation. This might be necessary, for example, if a query consisting of several modules is compiled, and the resulting object code is distributed to a different location for execution. It would then be inappropriate to use the same location when resolving import module declarations as when retrieving source documents using the fn:doc function. If an implementation uses different values for the Static Base URI during static analysis and during dynamic evaluation, then it is implementation-defined which of the two values is used for particular operations that rely on the Static Base URI; for example, it is implementation-defined which value is used for resolving collation URIs.

• [Definition: Statically known documents. This is a mapping from strings to types. The string represents the absolute URI of a resource that is potentially available using the fn:doc function. The type is the static type of a call to fn:doc with the given URI as its literal argument. ] If the argument to fn:doc is a string literal that is not present in statically known documents, then the static type of fn:doc is document-node()?.

  Note:

  The purpose of the statically known documents is to provide static type information, not to determine which documents are available. A URI need not be found in the statically known documents to be accessed using fn:doc.

• [Definition: Statically known collections. This is a mapping from strings to types. The string represents the absolute URI of a resource that is potentially available using the fn:collection function. The type is the type of the sequence of nodes that would result from calling the fn:collection function with this URI as its argument.] If the argument to fn:collection is a string literal that is not present in statically known collections, then the static type of fn:collection is node()*.

  Note:

  The purpose of the statically known collections is to provide static type information, not to determine which collections are available. A URI need not be found in the statically known collections to be accessed using fn:collection.

• [Definition: Statically known default collection type. This is the type of the sequence of nodes that would result from calling the fn:collection function with no arguments.] Unless initialized to some other value by an implementation, the value of statically known default collection type is node()*.

• [Definition: Statically known decimal formats. This is a mapping from QName to decimal format, with one default format that has no visible name. Each format is used for serializing decimal numbers using fn:format-number().]

  Each decimal format contains three sets of properties, which control the interpretation of characters in the picture string supplied to the fn:format-number function, and also specify characters that may appear in the result of formatting the number.

  The following attributes specify characters used to format the number per se:

  • [Definition: decimal-separator specifies the character used for the decimal-separator-symbol; the default value is the period character (.)]

  • [Definition: grouping-separator specifies the character used for the grouping-separator-symbol, which is typically used as a thousands separator; the default value is the comma character (,)]

  • [Definition: percent specifies the character used for the percent-symbol; the default value is the percent character (%)]

  • [Definition: per-mille specifies the character used for the per-mille-symbol; the default value is the Unicode per-mille character (#x2030)]

  • [Definition: zero-digit specifies the character used for the zero-digit-symbol; the default value is the digit zero (0). This character must be a digit (category Nd in the Unicode property database), and it must have the numeric value zero. This attribute implicitly defines the Unicode character that is used to represent each of the values 0 to 9 in the final result string: Unicode is organized so that each set of decimal digits forms a contiguous block of characters in numerical sequence.]

  The following attributes control the interpretation of characters in the picture string supplied to the format-number function. In each case the value must be a single character.

  • [Definition: digit-sign specifies the character used for the digit-sign in the picture string; the default value is the number sign character (#)]

  • [Definition: pattern-separator specifies the character used for the pattern-separator-symbol, which separates positive and negative sub-pictures in a picture string; the default value is the semi-colon character (;)]

  The following attributes specify characters or strings that may appear in the result of formatting the number:

  • [Definition: infinity specifies the string used for the infinity-symbol; the default value is the string "Infinity"]

  • [Definition: NaN specifies the string used for the NaN-symbol, which is used to represent the value NaN (not-a-number); the default value is the string "NaN"]

  • [Definition: minus-sign specifies the character used for the minus-sign-symbol; the default value is the hyphen-minus character (-, #x2D). The value must be a single character.]

2.1.2 Dynamic Context

[Definition: 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 is absent^DM30 , a dynamic error is raised [err:XPDY0002].

The individual components of the dynamic context are described below. Rules governing the initialization and alteration of these components can be found in C.2 Dynamic Context Components.

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

[Definition: 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. [Definition: 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.

• [Definition: The context item is the item currently being processed.] [Definition: When the context item is a node, it can also be referred to as the context node.] The context item is returned by an expression consisting of a single dot (.). When an expression E1/E2 or E1[E2] is evaluated, each item in the sequence obtained by evaluating E1 becomes the context item in the inner focus for an evaluation of E2.

  [Definition: The initial context item is a context item that an implementation can set before processing a query begins. The query body and the prolog of every module in a query share the same initial context item.]

• [Definition: The context position is the position of the context item within the sequence of items currently being processed.] It changes whenever the context item changes. When the focus is defined, the value of the context position is an integer greater than zero. The context position is returned by the expression fn:position(). When an expression E1/E2 or E1[E2] is evaluated, the context position in the inner focus for an evaluation of E2 is the position of the context item in the sequence obtained by evaluating E1. The position of the first item in a sequence is always 1 (one). The context position is always less than or equal to the context size.

• [Definition: The context size is the number of items in the sequence of items currently being processed.] Its value is always an integer greater than zero. The context size is returned by the expression fn:last(). When an expression E1/E2 or E1[E2] is evaluated, the context size in the inner focus for an evaluation of E2 is the number of items in the sequence obtained by evaluating E1.

• [Definition: Variable values. This is a mapping from expanded QName to value. It contains the same expanded QNames as the in-scope variables in the static context for the expression. The expanded QName is the name of the variable and the value is the dynamic value of the variable, which includes its dynamic type.]

• [Definition: Named functions. This is a mapping from (expanded QName, arity) to function^DM30. ] It supplies a function for each signature in statically known function signatures and may supply other functions (see 2.2.5 Consistency Constraints). Named functions can include functions with implementation-dependent implementations; these functions do not have a static context or a dynamic context of their own.

• [Definition: Current dateTime. This information represents an implementation-dependent point in time during the processing of a query, and includes an explicit timezone. It can be retrieved by the fn:current-dateTime function. If invoked multiple times during the execution of a query, this function always returns the same result.]

• [Definition: Implicit timezone. This is the timezone to be used when a date, time, or dateTime value that does not have a timezone is used in a comparison or arithmetic operation. The implicit timezone is an implementation-defined value of type xs:dayTimeDuration. See [XML Schema 1.0] or [XML Schema 1.1] for the range of valid values of a timezone.]

• [Definition: Default language. This is the natural language used when creating human-readable output (for example, by the functions fn:format-date and fn:format-integer) if no other language is requested. The value is a language code as defined by the type xs:language.]

• [Definition: Default calendar. This is the calendar used when formatting dates in human-readable output (for example, by the functions fn:format-date and fn:format-dateTime) if no other calendar is requested. The value is a string.]

• [Definition: Default place. This is a geographical location used to identify the place where events happened (or will happen) when formatting dates and times using functions such as fn:format-date and fn:format-dateTime, if no other place is specified. It is used when translating timezone offsets to civil timezone names, and when using calendars where the translation from ISO dates/times to a local representation is dependent on geographical location. Possible representations of this information are an ISO country code or an Olson timezone name, but implementations are free to use other representations from which the above information can be derived.]

• [Definition: Available documents. This is a mapping of strings to document nodes. Each string represents the absolute URI of a resource. The document node is the root of a tree that represents that resource using the data model. The document node is returned by the fn:doc function when applied to that URI.] The set of available documents is not limited to the set of statically known documents, and it may be empty.

  If there are one or more URIs in available documents that map to a document node D, then the document-uri property of D must either be absent, or must be one of these URIs.

  Note:

  This means that given a document node $N, the result of fn:doc(fn:document-uri($N)) is $N will always be true, unless fn:document-uri($N) is an empty sequence.

• [Definition: Available text resources. This is a mapping of strings to text resources. Each string represents the absolute URI of a resource. The resource is returned by the fn:unparsed-text function when applied to that URI.] The set of available text resources is not limited to the set of statically known documents, and it may be empty.

• [Definition: Available node collections. This is a mapping of strings to sequences of nodes. Each string represents the absolute URI of a resource. The sequence of nodes represents the result of the fn:collection function when that URI is supplied as the argument. ] The set of available node collections is not limited to the set of statically known collections, and it may be empty.

  For every document node D that is in the target of a mapping in available node collections, or that is the root of a tree containing such a node, the document-uri property of D must either be absent, or must be a URI U such that available documents contains a mapping from U to D.

  Note:

  This means that for any document node $N retrieved using the fn:collection function, either directly or by navigating to the root of a node that was returned, the result of fn:doc(fn:document-uri($N)) is $N will always be true, unless fn:document-uri($N) is an empty sequence. This implies a requirement for the fn:doc and fn:collection functions to be consistent in their effect. If the implementation uses catalogs or user-supplied URI resolvers to dereference URIs supplied to the fn:doc function, the implementation of the fn:collection function must take these mechanisms into account. For example, an implementation might achieve this by mapping the collection URI to a set of document URIs, which are then resolved using the same catalog or URI resolver that is used by the fn:doc function.

• [Definition: Default node collection. This is the sequence of nodes that would result from calling the fn:collection function with no arguments.] The value of default collection may be initialized by the implementation.

• [Definition: Available resource collections. This is a mapping of strings to sequences of URIs. The string represents the absolute URI of a resource which can be interpreted as an aggregation of a number of individual resources each of which has its own URI. The sequence of URIs represents the result of the fn:uri-collection function when that URI is supplied as the argument. ] There is no implication that the URIs in this sequence can be successfully dereferenced, or that the resources they refer to have any particular media type.

  Note:

  An implementation may maintain some consistent relationship between the available node collections and the available resource collections, for example by ensuring that the result of fn:uri-collection(X)!fn:doc(.) is the same as the result of fn:collection(X). However, this is not required. The fn:uri-collection function is more general than fn:collection in that it allows access to resources other than XML documents; at the same time, fn:collection allows access to nodes that might lack individual URIs, for example nodes corresponding to XML fragments stored in the rows of a relational database.

• [Definition: Default resource collection. This is the sequence of URIs that would result from calling the fn:uri-collection function with no arguments.] The value of default resource collection may be initialized by the implementation.

• [Definition: Environment variables. This is a mapping from names to values. Both the names and the values are strings. The names are compared using an implementation-defined collation, and are unique under this collation. The set of environment variables is implementation-defined and may be empty.]

  Note:

  A possible implementation is to provide the set of POSIX environment variables (or their equivalent on other operating systems) appropriate to the process in which the query is initiated.

2.2.1 Data Model Generation

Before a query can be processed, its input data must be represented as an XDM instance. This process occurs outside the domain of XQuery 3.0, which is why Figure 1 represents it in the external processing domain. Here are some steps by which an XML document might be converted to an XDM instance:

1. A document may be parsed using an XML parser that generates an XML Information Set (see [XML Infoset]). The parsed document may then be validated against one or more schemas. This process, which is described in [XML Schema 1.0] or [XML Schema 1.1], results in an abstract information structure called the Post-Schema Validation Infoset (PSVI). If a document has no associated schema, its Information Set is preserved. (See DM1 in Fig. 1.)

2. The Information Set or PSVI may be transformed into an XDM instance by a process described in [XQuery and XPath Data Model (XDM) 3.0]. (See DM2 in Fig. 1.)

The above steps provide an example of how an XDM instance might be constructed. An XDM instance might also be synthesized directly from a relational database, or constructed in some other way (see DM3 in Fig. 1.) XQuery 3.0 is defined in terms of the data model, but it does not place any constraints on how XDM instances are constructed.

[Definition: Each element node and attribute node in an XDM instance has a type annotation ( described in [XQuery and XPath Data Model (XDM) 3.0]. ) The type annotation of a node is a reference to an XML Schema type. ] The type-name of a node is the name of the type referenced by its type annotation. If the XDM instance was derived from a validated XML document as described in Section 3.3 Construction from a PSVI ^DM30, the type annotations of the element and attribute nodes are derived from schema validation. XQuery 3.0 does not provide a way to directly access the type annotation of an element or attribute node.

The value of an attribute is represented directly within the attribute node. An attribute node whose type is unknown (such as might occur in a schemaless document) is given the type annotation xs:untypedAtomic.

The value of an element is represented by the children of the element node, which may include text nodes and other element nodes. The type annotation of an element node indicates how the values in its child text nodes are to be interpreted. An element that has not been validated (such as might occur in a schemaless document) is annotated with the schema type xs:untyped. An element that has been validated and found to be partially valid is annotated with the schema type xs:anyType. If an element node is annotated as xs:untyped, all its descendant element nodes are also annotated as xs:untyped. However, if an element node is annotated as xs:anyType, some of its descendant element nodes may have a more specific type annotation.

2.2.2 Schema Import Processing

The in-scope schema definitions in the static context may be extracted from actual XML schemas (see step SI1 in Figure 1) or may be generated by some other mechanism (see step SI2 in Figure 1). In either case, the result must satisfy the consistency constraints defined in 2.2.5 Consistency Constraints.

2.2.3 Expression Processing

XQuery 3.0 defines two phases of processing called the static analysis phase and the dynamic evaluation phase (see Fig. 1). During the static analysis phase, static errors, dynamic errors, or type errors may be raised. During the dynamic evaluation phase, only dynamic errors or type errors may be raised. These kinds of errors are defined in 2.3.1 Kinds of Errors.

Within each phase, an implementation is free to use any strategy or algorithm whose result conforms to the specifications in this document.

2.2.4 Serialization

[Definition: Serialization is the process of converting an XDM instance to a sequence of octets (step DM4 in Figure 1.), as described in [XSLT and XQuery Serialization 3.0]. ]

An XQuery implementation is not required to provide a serialization interface. For example, an implementation may provide only a DOM interface (see [Document Object Model]) or an interface based on an event stream.

[XSLT and XQuery Serialization 3.0] defines a set of serialization parameters that govern the serialization process. If an XQuery implementation provides a serialization interface, it may support (and may expose to users) any of the serialization parameters listed (with default values) in C.1 Static Context Components. If an implementation does not support one of these parameters, it must ignore it without raising an error.

[Definition: An output declaration is an option declaration in the namespace "http://www.w3.org/2010/xslt-xquery-serialization"; it is used to declare serialization parameters.] Except for parameter-document, each option corresponds to a serialization parameter element defined in Section B Schema for Serialization Parameters ^SER30. The name of each option is the same as the name of the corresponding serialization parameter element, and the values permitted for each option are the same as the values allowed in the serialization parameter element. There is no output declaration for use-character-maps, it can be set only by means of a parameter document. When the application requests serialization of the output, the processor may use these parameters to control the way in which the serialization takes place. Processors may also allow external mechanisms for specifying serialization parameters, which may or may not override serialization parameters specified in the query prolog.

The following example illustrates the use of declaration options.

declare namespace output = "http://www.w3.org/2010/xslt-xquery-serialization";
declare option output:method   "xml";
declare option output:encoding "iso-8859-1";
declare option output:indent   "yes";
declare option output:parameter-document "file:///home/me/serialization-parameters.xml";

An output declaration may appear only in a main module; it is a static error [err:XQST0108] if an output declaration appears in a library module. It is a static error [err:XQST0110] if the same serialization parameter is declared more than once. It is a static error [err:XQST0109] if the local name of an output declaration in the http://www.w3.org/2010/xslt-xquery-serialization namespace is not one of the serialization parameter names listed in C.1 Static Context Components or parameter-document, or if the name of an output declaration is use-character-maps . The default value for the method parameter is "xml". An implementation may define additional implementation-defined serialization parameters in its own namespaces.

If the local name of an output declaration in the http://www.w3.org/2010/xslt-xquery-serialization namespace is parameter-document, the value of the output declaration is treated as a URI literal. The value is a location hint, and identifies an XDM instance in an implementation-defined way. If a processor is performing serialization, it is a static error [err:XQST0119] if the implementation is not able to process the value of the output:parameter-document declaration to produce an XDM instance.

If a processor is performing serialization, the XDM instance identified by an output:parameter-document output declaration specifies the values of serialization parameters in the manner defined by Section 3.1 Setting Serialization Parameters by Means of a Data Model Instance ^SER30. It is a static error [err:XQST0115] if this yields a serialization error. The value of any other output declaration overrides any value that might have been specified for the same serialization parameter using an output declaration in the http://www.w3.org/2010/xslt-xquery-serialization namespace with the local name parameter-document declaration.

A serialization parameter that is not applicable to the chosen output method must be ignored, except that if its value is not a valid value for that parameter, an error may be raised.

A processor that is performing serialization must raise a serialization error if the values of any serialization parameters that it supports (other than any that are ignored under the previous paragraph) are incorrect.

A processor that is not performing serialization may report errors if any serialization parameters are incorrect, or may ignore such parameters.

Specifying serialization parameters in a query does not by itself demand that the output be serialized. It merely defines the desired form of the serialized output for use in situations where the processor has been asked to perform serialization.

2.2.5 Consistency Constraints

In order for XQuery 3.0 to be well defined, the input XDM instance, the static context, and the dynamic context must be mutually consistent. The consistency constraints listed below are prerequisites for correct functioning of an XQuery 3.0 implementation. Enforcement of these consistency constraints is beyond the scope of this specification. This specification does not define the result of a query under any condition in which one or more of these constraints is not satisfied.

• For every node that has a type annotation, if that type annotation is found in the in-scope schema definitions (ISSD), then its definition in the ISSD must be equivalent to its definition in the type annotation .

• Every element name, attribute name, or schema type name referenced in in-scope variables or statically known function signatures must be in the in-scope schema definitions, unless it is an element name referenced as part of an ElementTest or an attribute name referenced as part of an AttributeTest.

• Any reference to a global element, attribute, or type name in the in-scope schema definitions must have a corresponding element, attribute or type definition in the in-scope schema definitions.

• For each mapping of a string to a document node in available documents, if there exists a mapping of the same string to a document type in statically known documents, the document node must match the document type, using the matching rules in 2.5.5 SequenceType Matching.

• For each mapping of a string to a sequence of nodes in available node collections, if there exists a mapping of the same string to a type in statically known collections, the sequence of nodes must match the type, using the matching rules in 2.5.5 SequenceType Matching.

• The sequence of nodes in the default collection must match the statically known default collection type, using the matching rules in 2.5.5 SequenceType Matching.

• The value of the context item must match the context item static type, using the matching rules in 2.5.5 SequenceType Matching.

• For each (variable, type) pair in in-scope variables and the corresponding (variable, value) pair in variable values such that the variable names are equal, the value must match the type, using the matching rules in 2.5.5 SequenceType Matching.

• For each variable declared as external, if the variable declaration does not include a VarDefaultValue, the external environment must provide a value for the variable.

  For each variable declared as external for which the external environment provides a value: If the variable declaration includes a declared type, the value provided by the external environment must match the declared type, using the matching rules in 2.5.5 SequenceType Matching. If the variable declaration does not include a declared type, the external environment must provide a type to accompany the value provided, using the same matching rules.

• For each function declared as external: the function's implementation^DM30 must either return a value that matches the declared result type, using the matching rules in 2.5.5 SequenceType Matching, or raise an implementation-defined error.

• For a given query, define a participating ISSD as the in-scope schema definitions of a module that is used in evaluating the query. If two participating ISSDs contain a definition for the same schema type, element name, or attribute name, the definitions must be equivalent in both ISSDs. In this context, equivalence means that validating an instance against type T in one ISSD will always have the same effect as validating the same instance against type T in the other ISSD (that is, it will produce the same PSVI, insofar as the PSVI is used during subsequent processing). This means, for example, that the membership of the substitution group of an element declaration in one ISSD must be the same as that of the corresponding element declaration in the other ISSD; that the set of types derived by extension from a given type must be the same; and that in the presence of a strict or lax wildcard, the set of global element (or attribute) declarations capable of matching the wildcard must be the same.

• In the statically known namespaces, the prefix xml must not be bound to any namespace URI other than http://www.w3.org/XML/1998/namespace, and no prefix other than xml may be bound to this namespace URI. The prefix xmlns must not be bound to any namespace URI, and no prefix may be bound to the namespace URI http://www.w3.org/2000/xmlns/.

• For each (expanded QName, arity) -> FunctionTest entry in statically known function signatures, there must exist an (expanded QName, arity) -> function entry in named functions such that the function's signature^DM30 is FunctionTest.

2.3.1 Kinds of Errors

As described in 2.2.3 Expression Processing, 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.

[Definition: An error that 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.

[Definition: 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. ]

[Definition: 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 [err:XPST0005]. 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:

error()

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.

if (empty($arg))
then
  "cat" * 2
else
  0

[Definition: 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. An error must be raised if such a limitation is exceeded [err:XPDY0130].

2.3.2 Identifying and Reporting Errors

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

• err denotes the namespace for XPath and XQuery errors, http://www.w3.org/2005/xqt-errors. This binding of the namespace prefix err is used for convenience in this document, and is not normative.

• XX denotes the language in which the error is defined, using the following encoding:

  • XP denotes an error defined by XPath. Such an error may also occur XQuery since XQuery includes XPath as a subset.

  • XQ denotes an error defined by XQuery (or an error originally defined by XQuery and later added to XPath).

• YY denotes the error category, using the following encoding:

  • ST denotes a static error.

  • DY denotes a dynamic error.

  • TY denotes a type error.

• nnnn is a unique numeric code.

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.

2.3.3 Handling Dynamic Errors

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 return a value or raise a dynamic error, the implementation may choose to return the value or raise the dynamic error (see 2.3.4 Errors and Optimization). 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:

($x div $y) + xs:decimal($z)

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.

[Definition: 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 Section 3.15 Try/Catch Expressions ^XQ30 .

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 [XQuery and XPath Functions and Operators 3.0].

A dynamic error can also be raised explicitly by calling the fn:error function, which always raises a dynamic error and never returns a value. This function is defined in [XQuery and XPath Functions and Operators 3.0]. 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):

fn:error(xs:QName("app:err057"), "Unexpected value", fn:string($v))

2.3.4 Errors and Optimization

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:

• If an implementation can find (for example, by using an index) that at least one item returned by $expr1 in the following example has the value 47, it is allowed to return true as the result of the some expression, without searching for another item returned by $expr1 that would raise an error if it were evaluated.

  some $x in $expr1 satisfies $x = 47
  

• In the following example, if an implementation can find (for example, by using an index) the product element-nodes that have an id child with the value 47, it is allowed to return these nodes as the result of the path expression, without searching for another product node that would raise an error because it has an id child whose value is not an integer.

  //product[id = 47]
  

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:

• Other than the raising or not raising of errors, the result of evaluating a rewritten expression must conform to the semantics defined in this specification for the original expression.

  Note:

  This allows an implementation to return a result in cases where the original expression would have raised an error, or to raise an error in cases where the original expression would have returned a result. The main cases where this is likely to arise in practice are (a) where a rewrite changes the order of evaluation, such that a subexpression causing an error is evaluated when the expression is written one way and is not evaluated when the expression is written a different way, and (b) where intermediate results of the evaluation cause overflow or other out-of-range conditions.

  Note:

  This rule does not mean that the result of the expression will always be the same in non-error cases as if it had not been rewritten, because there are many cases where the result of an expression is to some degree implementation-dependent or implementation-defined.

• Conditional and typeswitch expressions must not raise a dynamic error in respect of subexpressions occurring in a branch that is not selected, and must not return the value delivered by a branch unless that branch is selected. Thus, the following example must not raise a dynamic error if the document abc.xml does not exist:

  if (doc-available('abc.xml')) then doc('abc.xml') else ()
  

• As stated earlier, an expression must not be rewritten to dispense with a required cardinality check: for example, string-length(//title) must raise an error if the document contains more than one title element.

• Expressions must not be rewritten in such a way as to create or remove static errors. The static errors in this specification are defined for the original expression, and must be preserved if the expression is rewritten.

Expression rewrite is illustrated by the following examples.

• Consider the expression //part[color eq "Red"]. An implementation might choose to rewrite this expression as //part[color = "Red"][color eq "Red"]. The implementation might then process the expression as follows: First process the "=" predicate by probing an index on parts by color to quickly find all the parts that have a Red color; then process the "eq" predicate by checking each of these parts to make sure it has only a single color. The result would be as follows:

  • Parts that have exactly one color that is Red are returned.

  • If some part has color Red together with some other color, an error is raised.

  • The existence of some part that has no color Red but has multiple non-Red colors does not trigger an error.

• The expression in the following example cannot raise a casting error if it is evaluated exactly as written (i.e., left to right). Since neither predicate depends on the context position, an implementation might choose to reorder the predicates to achieve better performance (for example, by taking advantage of an index). This reordering could cause the expression to raise an error.

  $N[@x castable as xs:date][xs:date(@x) gt xs:date("2000-01-01")]
  

  To avoid unexpected errors caused by expression rewrite, tests that are designed to prevent dynamic errors should be expressed using conditional or typeswitch expressions. For example, the above expression can be written as follows:

  $N[if (@x castable as xs:date)
     then xs:date(@x) gt xs:date("2000-01-01")
     else false()]
  

2.4.1 Document Order

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 [XQuery and XPath Data Model (XDM) 3.0], and its definition is repeated here for convenience. Document order is a total ordering, although the relative order of some nodes is implementation-dependent. [Definition: Informally, document order is the order in which nodes appear in the XML serialization of a document.] [Definition: 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.] [Definition: The node ordering that is the reverse of document order is called reverse document order.]

Within a tree, document order satisfies the following constraints:

1. The root node is the first node.

2. Every node occurs before all of its children and descendants.

3. Attribute nodes immediately follow the element node with which they are associated. The relative order of attribute nodes is stable but implementation-dependent.

4. The relative order of siblings is the order in which they occur in the children property of their parent node.

5. Children and descendants occur before following siblings.

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.

2.4.2 Atomization

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]. [Definition: Atomization of a sequence is defined as the result of invoking the fn:data function on the sequence, as defined in [XQuery and XPath Functions and Operators 3.0].]

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:

• If the item is an atomic value, it is returned.

• If the item is a node, its typed value is returned ([err:FOTY0012] is raised if the node has no typed value.)

• If the item is a function^DM30 [err:FOTY0012] is raised.

Atomization is used in processing the following types of expressions:

• Arithmetic expressions

• Comparison expressions

• Function calls and returns

• Cast expressions

• Constructor expressions for various kinds of nodes

• order by clauses in FLWOR expressions

• group by clauses in FLWOR expressions

• Switch expressions

2.4.3 Effective Boolean Value

Under certain circumstances (listed below), it is necessary to find the effective boolean value of a value. [Definition: The effective boolean value of a value is defined as the result of applying the fn:boolean function to the value, as defined in [XQuery and XPath Functions and Operators 3.0].]

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

1. If its operand is an empty sequence, fn:boolean returns false.

2. If its operand is a sequence whose first item is a node, fn:boolean returns true.

3. If its operand is a singleton value of type xs:boolean or derived from xs:boolean, fn:boolean returns the value of its operand unchanged.

4. If its operand is a singleton value of type xs:string, xs:anyURI, xs:untypedAtomic, or a type derived from one of these, fn:boolean returns false if the operand value has zero length; otherwise it returns true.

5. If its operand is a singleton value of any numeric type or derived from a numeric type, fn:boolean returns false if the operand value is NaN or is numerically equal to zero; otherwise it returns true.

6. In all other cases, fn:boolean raises a type error [err:FORG0006].

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

• Logical expressions (and, or)

• The fn:not function

• The where clause of a FLWOR expression

• Certain types of predicates, such as a[b]

• Conditional expressions (if)

• Quantified expressions (some, every)

• WindowStartCondition and WindowEndCondition in window clauses.

2.4.4 Input Sources

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 [XQuery and XPath Functions and Operators 3.0].

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:

• The fn:doc function takes a string containing a URI. If that URI is associated with a document in available documents, fn:doc returns a document node whose content is the data model representation of the given document; otherwise it raises a dynamic error.

• The fn:unparsed-text function takes a string containing a URI, which must identify a resource that can be read as text; otherwise it raises a dynamic error.

• The fn:environment-variable and fn:available-environment-variables identify environment variables that are available in the dynamic context.

• The fn:collection function with one argument takes a string containing a URI. If that URI is associated with a collection in available node collections, fn:collection returns the data model representation of that collection; otherwise it raises a dynamic error. A collection may be any sequence of nodes. For example, the expression fn:collection("http://example.org")//customer identifies all the customer elements that are descendants of nodes found in the collection whose URI is http://example.org.

• The fn:collection function with zero arguments returns the default collection, an implementation-dependent sequence of nodes.

• The fn:uri-collection function returns a sequence of xs:anyURI values representing the URIs in a resource collection.

• The fn:uri-collection function with zero arguments returns the URIs in the default resource collection.

These input functions are all specified in [XQuery and XPath Functions and Operators 3.0], which specifies error conditions and other details not described here.

2.4.5 URI Literals

XQuery 3.0 requires a statically known, valid URI in a URILiteral or a BracedURILiteral. An implementation may raise a static error [err:XQST0046] if the value of a URI Literal or a Braced URI Literal is of nonzero length and is 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.

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 subjected to percent-encoding or decoding as defined in [RFC3986].

2.4.6 Resolving a Relative URI Reference

[Definition: 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.

2.5.1 Predefined Schema Types

The schema types defined in [XQuery and XPath Data Model (XDM) 3.0] 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 [XML Schema 1.0] or [XML Schema 1.1] and augmented by additional types defined in [XQuery and XPath Data Model (XDM) 3.0]. Element and attribute declarations in the xs namespace are not implicitly included in the static context. The schema types defined in [XQuery and XPath Data Model (XDM) 3.0] are summarized below.

1. [Definition: xs:untyped is used as the type annotation of an element node that has not been validated, or has been validated in skip mode.] No predefined schema types are derived from xs:untyped.

2. [Definition: xs:untypedAtomic is an atomic type that is used to denote untyped atomic data, such as text that has not been assigned a more specific type.] An attribute that has been validated in skip mode is represented in the data model by an attribute node with the type annotation xs:untypedAtomic. No predefined schema types are derived from xs:untypedAtomic.

3. [Definition: xs:dayTimeDuration is derived by restriction from xs:duration. The lexical representation of xs:dayTimeDuration is restricted to contain only day, hour, minute, and second components.]

4. [Definition: xs:yearMonthDuration is derived by restriction from xs:duration. The lexical representation of xs:yearMonthDuration is restricted to contain only year and month components.]

5. [Definition: xs:anyAtomicType is an atomic type that includes all atomic values (and no values that are not atomic). Its base type is xs:anySimpleType from which all simple types, including atomic, list, and union types, are derived. All primitive atomic types, such as xs:decimal and xs:string, have xs:anyAtomicType as their base type.]

   Note:

   xs:anyAtomicType will not appear as the type of an actual value in an XDM instance.

6. [Definition: xs:error is a simple type with no value space, defined in [XML Schema 1.1]. In implementations that support XML Schema 1.1, it can be used in the 2.5.4 SequenceType Syntax to raise errors.]

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 [XQuery and XPath Functions and Operators 3.0].

Figure 2: Hierarchy of Schema Types used in XQuery 3.0.

2.5.2 Namespace-sensitive Types

[Definition: 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.

2.5.3 Typed Value and String Value

Every node has a typed value and a string value , except for nodes whose value is absent^DM30. [Definition: 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.] [Definition: 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 [XQuery and XPath Functions and Operators 3.0].

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:

• If the node was created by mapping from an Infoset or PSVI, see rules in [XQuery and XPath Data Model (XDM) 3.0].

• If the node was created by an XQuery node constructor, see rules in 3.9.1 Direct Element Constructors, 3.9.3.1 Computed Element Constructors, or 3.9.3.2 Computed Attribute Constructors.

• If the node was created by a validate expression, see rules in 3.18 Validate Expressions.

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.

1. For text and document nodes, the typed value of the node is the same as its string value, as an instance of the type xs:untypedAtomic. The string value of a document node is formed by concatenating the string values of all its descendant text nodes, in document order.

2. The typed value of a comment or processing instruction node is the same as its string value. It is an instance of the type xs:string.

3. The typed value of an attribute node with the type annotation xs:anySimpleType or xs:untypedAtomic is the same as its string value, as an instance of xs:untypedAtomic. The typed value of an attribute node with any other type annotation is derived from its string value and type annotation using the lexical-to-value-space mapping defined in [XML Schema 1.0] or [XML Schema 1.1] Part 2 for the relevant type.

   Example: A1 is an attribute having string value "3.14E-2" and type annotation xs:double. The typed value of A1 is the xs:double value whose lexical representation is 3.14E-2.

   Example: A2 is an attribute with type annotation xs:IDREFS, which is a list datatype whose item type is the atomic datatype xs:IDREF. Its string value is "bar baz faz". The typed value of A2 is a sequence of three atomic values ("bar", "baz", "faz"), each of type xs:IDREF. The typed value of a node is never treated as an instance of a named list type. Instead, if the type annotation of a node is a list type (such as xs:IDREFS), its typed value is treated as a sequence of the generalized atomic type from which it is derived (such as xs:IDREF).

4. For an element node, the relationship between typed value and string value depends on the node's type annotation, as follows:

   1. If the type annotation is xs:untyped or xs:anySimpleType or denotes a complex type with mixed content (including xs:anyType), then the typed value of the node is equal to its string value, as an instance of xs:untypedAtomic. However, if the nilled property of the node is true, then its typed value is the empty sequence.

      Example: E1 is an element node having type annotation xs:untyped and string value "1999-05-31". The typed value of E1 is "1999-05-31", as an instance of xs:untypedAtomic.

      Example: E2 is an element node with the type annotation formula, which is a complex type with mixed content. The content of E2 consists of the character "H", a child element named subscript with string value "2", and the character "O". The typed value of E2 is "H2O" as an instance of xs:untypedAtomic.

   2. If the type annotation denotes a simple type or a complex type with simple content, then the typed value of the node is derived from its string value and its type annotation in a way that is consistent with schema validation. However, if the nilled property of the node is true, then its typed value is the empty sequence.

      Example: E3 is an element node with the type annotation cost, which is a complex type that has several attributes and a simple content type of xs:decimal. The string value of E3 is "74.95". The typed value of E3 is 74.95, as an instance of xs:decimal.

      Example: E4 is an element node with the type annotation hatsizelist, which is a simple type derived from the atomic type hatsize, which in turn is derived from xs:integer. The string value of E4 is "7 8 9". The typed value of E4 is a sequence of three values (7, 8, 9), each of type hatsize.

      Example: E5 is an element node with the type annotation my:integer-or-string which is a union type with member types xs:integer and xs:string. The string value of E5 is "47". The typed value of E5 is 47 as an xs:integer, since xs:integer is the member type that validated the content of E5. In general, when the type annotation of a node is a union type, the typed value of the node will be an instance of one of the member types of the union.

      Note:

      If an implementation stores only the string value of a node, and the type annotation of the node is a union type, the implementation must be able to deliver the typed value of the node as an instance of the appropriate member type.

   3. If the type annotation denotes a complex type with empty content, then the typed value of the node is the empty sequence and its string value is the zero-length string.

   4. If the type annotation denotes a complex type with element-only content, then the typed value of the node is absent^DM30. The fn:data function raises a type error [err:FOTY0012] when applied to such a node. The string value of such a node is equal to the concatenated string values of all its text node descendants, in document order.

      Example: E6 is an element node with the type annotation weather, which is a complex type whose content type specifies element-only. E6 has two child elements named temperature and precipitation. The typed value of E6 is absent^DM30, and the fn:data function applied to E6 raises an error.

2.5.4 SequenceType Syntax

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 . 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:

• xs:date refers to the built-in atomic schema type named xs:date

• attribute()? refers to an optional attribute node

• element() refers to any element node

• element(po:shipto, po:address) refers to an element node that has the name po:shipto and has the type annotation po:address (or a schema type derived from po:address)

• element(*, po:address) refers to an element node of any name that has the type annotation po:address (or a type derived from po:address)

• element(customer) refers to an element node named customer with any type annotation

• schema-element(customer) refers to an element node whose name is customer (or is in the substitution group headed by customer) and whose type annotation matches the schema type declared for a customer element in the in-scope element declarations

• node()* refers to a sequence of zero or more nodes of any kind

• item()+ refers to a sequence of one or more items

• function(*) refers to any function^DM30, regardless of arity or type

• function(node()) as xs:string* refers to a function^DM30 that takes a single argument whose value is a single node, and returns a sequence of zero or more xs:string values

• (function(node()) as xs:string)* refers to a sequence of zero or more functions^DM30, each of which takes a single argument whose value is a single node, and returns as its result a single xs:string value

2.5.5 SequenceType Matching

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

[Definition: 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 [err:XPTY0004]. This function is defined as follows:

• derives-from( AT, ET ) raises a type error [err:XPTY0004] if ET is not present in the in-scope schema definitions (ISSD).

• derives-from( AT, ET ) returns true if any of the following conditions applies:

  • AT is ET

  • ET is the base type of AT

  • ET is a pure union type of which AT is a member type

  • There is a type MT such that derives-from( AT, MT ) and derives-from( MT, ET )

• Otherwise, derives-from( AT, ET ) returns false

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

2.5.6 SequenceType Subtype Relationships

Given two sequence types, it is possible to determine if one is a subtype of the other. [Definition: 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).

2.5.7 xs:error

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

3.1.1 Literals

[Definition: 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 Section 18.2 Casting from xs:string and xs:untypedAtomic ^FO30.

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. [Definition: 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. [Definition: A character reference is an XML-style reference to a [Unicode] 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 [XML 1.0] or [XML 1.1] apply.) A static error [err:XQST0090] 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:

• "12.5" denotes the string containing the characters '1', '2', '.', and '5'.

• 12 denotes the xs:integer value twelve.

• 12.5 denotes the xs:decimal value twelve and one half.

• 125E2 denotes the xs:double value twelve thousand, five hundred.

• "He said, ""I don't like it.""" denotes a string containing two quotation marks and one apostrophe.

• "Ben & Jerry's" denotes the xs:string value "Ben & Jerry's".

• "€99.50" denotes the xs:string value "€99.50".

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 [XQuery and XPath Functions and Operators 3.0]. 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:

• xs:integer("12") returns the integer value twelve.

• xs:date("2001-08-25") returns an item whose type is xs:date and whose value represents the date 25th August 2001.

• xs:dayTimeDuration("PT5H") returns an item whose type is xs:dayTimeDuration and whose value represents a duration of five hours.

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."

• xs:double("INF") returns the special double-precision value, "positive infinity."

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:

• 9 cast as hatsize returns the atomic value 9 whose type is hatsize.

3.1.2 Variable References

[Definition: A variable reference is an EQName preceded by a $-sign.] 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.

Every variable binding has a static scope. The scope defines where references to the variable can validly occur. It is a static error [err:XPST0008] 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 [err:XPDY0002].

At evaluation time, the value of a variable reference is the value to which the relevant variable is bound.

3.1.3 Parenthesized Expressions

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 3.4.1 Constructing Sequences.

3.1.4 Context Item Expression

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 (as in the expression (1 to 100)[. mod 5 eq 0]).

If the context item is absent^DM30, a context item expression raises a dynamic error [err:XPDY0002].

3.1.5 Static Function Calls

[Definition: The built-in functions supported by XQuery 3.0 are defined in [XQuery and XPath Functions and Operators 3.0].] 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.

[Definition: A static function call consists of an EQName followed by a parenthesized list of zero or more arguments.] [Definition: 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 [err:XPST0017].

[Definition: A static or dynamic function call is a partial function application if one or more arguments is an ArgumentPlaceholder. ]

Evaluation of function calls is described in 3.1.5.1 Evaluating Static and Dynamic Function Calls .

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:

• my:three-argument-function(1, 2, 3) denotes a static function call with three arguments.

• my:two-argument-function((1, 2), 3) denotes a static function call with two arguments, the first of which is a sequence of two values.

• my:two-argument-function(1, ()) denotes a static function call with two arguments, the second of which is an empty sequence.

• my:one-argument-function((1, 2, 3)) denotes a static function call with one argument that is a sequence of three values.

• my:one-argument-function(( )) denotes a static function call with one argument that is an empty sequence.

• my:zero-argument-function( ) denotes a static function call with zero arguments.

declare function local:filter($s as item()*, $p as function(xs:string) as xs:boolean) as item()*
{
  $s[$p(.)]
};

let $f := function($a) { starts-with($a, "E") }
return
  local:filter(("Ethel", "Enid", "Gertrude"), $f)
      

3.1.6 Named Function References

[Definition: A named function reference denotes a named function.] [Definition: 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 named function reference do not match the name and arity of a function signature in the static context, a static error is raised [err:XPST0017].

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.

Certain functions in the [XQuery and XPath Functions and Operators 3.0] 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. For the purposes of named function references, these functions are regarded as taking arguments and producing results of type xs:anyAtomicType, with a type error raised at runtime if the argument value provided is not of the correct numeric type.

The following are examples of named function references:

• fn:abs#1 references the fn:abs function which takes a single argument.

• fn:concat#5 references the fn:concat function which takes 5 arguments.

• local:myfunc#2 references a function named local:myfunc which takes 2 arguments.

3.1.7 Inline Function Expressions

[Definition: An inline function expression creates an anonymous function^DM30 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 [err:XQST0039] 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 [err:XQST0125] 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 absent^DM30.

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.

The result of an inline function expression is a single function with the following properties (as defined in Section 2.8.1 Functions ^DM30):

• name: Absent.

• parameter names: The parameter names in the InlineFunctionExpr's ParamList.

• signature: A FunctionTest constructed from the Annotations and SequenceTypes in the InlineFunctionExpr.

• implementation: The InlineFunctionExpr's FunctionBody.

• nonlocal variable bindings: For each nonlocal variable, a binding of it to its value in the variable values component of the dynamic context of the InlineFunctionExpr.

The following are examples of some inline function expressions:

• This example creates a function that takes no arguments and returns a sequence of the first 6 primes:

  function() as xs:integer+ { 2, 3, 5, 7, 11, 13 }
  

• This example creates a function that takes two xs:double arguments and returns their product:

  function($a as xs:double, $b as xs:double) as xs:double { $a * $b }
  

• This example creates a function that returns its item()* argument:

  function($a) { $a }
  

• This example creates a sequence of functions each of which returns a different node from the default collection.

  collection()/(let $a := . return function() { $a })
  

3.2.1 Filter 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:

• Given a sequence of products in a variable, return only those products whose price is greater than 100.

  $products[price gt 100]
  

• List all the integers from 1 to 100 that are divisible by 5. (See 3.4.1 Constructing Sequences for an explanation of the to operator.)

  (1 to 100)[. mod 5 eq 0]
  

• The result of the following expression is the integer 25:

  (21 to 29)[5]
  

• The following example returns the fifth through ninth items in the sequence bound to variable $orders.

  $orders[fn:position() = (5 to 9)]
  

• The following example illustrates the use of a filter expression as a step in a path expression. It returns the last chapter or appendix within the book bound to variable $book:

  $book/(chapter | appendix)[fn:last()]
  

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:

1. If the value of the predicate expression is a singleton atomic value of a numeric type or derived from a numeric type, the predicate truth value is true if the value of the predicate expression is equal (by the eq operator) to the context position, and is false otherwise. [Definition: A predicate whose predicate expression returns a numeric type is called a numeric predicate.]

   Note:

   In a region of a query where ordering mode is unordered, the result of a numeric predicate is implementation-dependent , as explained in 3.11 Ordered and Unordered Expressions.

2. Otherwise, the predicate truth value is the effective boolean value of the predicate expression.

3.2.2 Dynamic Function Call

[Definition: A dynamic function call consists of a base expression that returns the function and a parenthesized list of zero or more arguments (argument expressions or ArgumentPlaceholders).]

A dynamic function call is evaluated as described in 3.1.5.1 Evaluating Static and Dynamic Function Calls .

The following are examples of some dynamic function calls:

• This example invokes the function contained in $f, passing the arguments 2 and 3:

  $f(2, 3)
  

• This example fetches the second item from sequence $f, treats it as a function and invokes it, passing an xs:string argument:

  $f[2]("Hi there")
  

• This example invokes the function $f passing no arguments, and filters the result with a positional predicate:

  $f()[2]
  

3.3.1 Relative Path Expressions

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 3.3.5 Abbreviated Syntax, leaving a sequence of steps separated by "/" . 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.

E1/E2 ::= let $R := E1!E2
  return
    if (every $r in $R satisfies $r instance of node())
    then ($R|())
    else if (every $r in $R satisfies not($r instance of node()))
    then $R
    else error()

3.3.2 Steps

[Definition: 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 3.2 Postfix Expressions.

[Definition: 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 [err:XPTY0020]. 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 3.3.5 Abbreviated Syntax.

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 3.3.2.1 Axes. The available node tests are described in 3.3.2.2 Node Tests. Examples of steps are provided in 3.3.4 Unabbreviated Syntax and 3.3.5 Abbreviated Syntax.

3.3.3 Predicates within Steps

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 example selects the second chapter element that is a child of the context node:

  child::chapter[2]
  

• This example selects all the descendants of the context node that are elements named "toy" and whose color attribute has the value "red":

  descendant::toy[attribute::color = "red"]
  

• This example selects all the employee children of the context node that have both a secretary child element and an assistant child element:

  child::employee[secretary][assistant]
  

3.3.4 Unabbreviated Syntax

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 3.3.5 Abbreviated Syntax.

• child::para selects the para element children of the context node

• child::* selects all element children of the context node

• child::text() selects all text node children of the context node

• child::node() selects all the children of the context node. Note that no attribute nodes are returned, because attributes are not children.

• attribute::name selects the name attribute of the context node

• attribute::* selects all the attributes of the context node

• parent::node() selects the parent of the context node. If the context node is an attribute node, this expression returns the element node (if any) to which the attribute node is attached.

• descendant::para selects the para element descendants of the context node

• ancestor::div selects all div ancestors of the context node

• ancestor-or-self::div selects the div ancestors of the context node and, if the context node is a div element, the context node as well

• descendant-or-self::para selects the para element descendants of the context node and, if the context node is a para element, the context node as well

• self::para selects the context node if it is a para element, and otherwise returns an empty sequence

• child::chapter/descendant::para selects the para element descendants of the chapter element children of the context node

• child::*/child::para selects all para grandchildren of the context node

• / selects the root of the tree that contains the context node, but raises a dynamic error if this root is not a document node

• /descendant::para selects all the para elements in the same document as the context node

• /descendant::list/child::member selects all the member elements that have a list parent and that are in the same document as the context node

• child::para[fn:position() = 1] selects the first para child of the context node

• child::para[fn:position() = fn:last()] selects the last para child of the context node

• child::para[fn:position() = fn:last()-1] selects the last but one para child of the context node

• child::para[fn:position() > 1] selects all the para children of the context node other than the first para child of the context node

• following-sibling::chapter[fn:position() = 1] selects the next chapter sibling of the context node

• preceding-sibling::chapter[fn:position() = 1] selects the previous chapter sibling of the context node

• /descendant::figure[fn:position() = 42] selects the forty-second figure element in the document containing the context node

• /child::book/child::chapter[fn:position() = 5]/child::section[fn:position() = 2] selects the second section of the fifth chapter of the book whose parent is the document node that contains the context node

• child::para[attribute::type eq "warning"] selects all para children of the context node that have a type attribute with value warning

• child::para[attribute::type eq 'warning'][fn:position() = 5] selects the fifth para child of the context node that has a type attribute with value warning

• child::para[fn:position() = 5][attribute::type eq "warning"] selects the fifth para child of the context node if that child has a type attribute with value warning

• child::chapter[child::title = 'Introduction'] selects the chapter children of the context node that have one or more title children whose typed value is equal to the string Introduction

• child::chapter[child::title] selects the chapter children of the context node that have one or more title children

• child::*[self::chapter or self::appendix] selects the chapter and appendix children of the context node

• child::*[self::chapter or self::appendix][fn:position() = fn:last()] selects the last chapter or appendix child of the context node

3.3.5 Abbreviated Syntax

The abbreviated syntax permits the following abbreviations:

1. The attribute axis attribute:: can be abbreviated by @. For example, a path expression para[@type="warning"] is short for child::para[attribute::type="warning"] and so selects para children with a type attribute with value equal to warning.

2. If the axis name is omitted from an axis step, the default axis is child, with two exceptions: if the NodeTest in an axis step contains an AttributeTest or SchemaAttributeTest then the default axis is attribute; if the NodeTest in an axis step is a NamespaceNodeTest then a static error is raised [err:XQST0134] .

   Note:

   In an implementation that does not support the namespace axis, an attempt to access it always raises an error. Thus, an XQuery implementation will always raise an error in this case, since XQuery does not support the namespace axis. The namespace axis is deprecated as of XPath 2.0, but required in some languages that use XPath, including XSLT.

   For example, the path expression section/para is an abbreviation for child::section/child::para, and the path expression section/@id is an abbreviation for child::section/attribute::id. Similarly, section/attribute(id) is an abbreviation for child::section/attribute::attribute(id). Note that the latter expression contains both an axis specification and a node test.

3. Each non-initial occurrence of // is effectively replaced by /descendant-or-self::node()/ during processing of a path expression. For example, div1//para is short for child::div1/descendant-or-self::node()/child::para and so will select all para descendants of div1 children.

   Note:

   The path expression //para[1] does not mean the same as the path expression /descendant::para[1]. The latter selects the first descendant para element; the former selects all descendant para elements that are the first para children of their respective parents.

4. A step consisting of .. is short for parent::node(). For example, ../title is short for parent::node()/child::title and so will select the title children of the parent of the context node.

   Note:

   The expression ., known as a context item expression, is a primary expression, and is described in 3.1.4 Context Item Expression.

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

• para selects the para element children of the context node

• * selects all element children of the context node

• text() selects all text node children of the context node

• @name selects the name attribute of the context node

• @* selects all the attributes of the context node

• para[1] selects the first para child of the context node

• para[fn:last()] selects the last para child of the context node

• */para selects all para grandchildren of the context node

• /book/chapter[5]/section[2] selects the second section of the fifth chapter of the book whose parent is the document node that contains the context node

• chapter//para selects the para element descendants of the chapter element children of the context node

• //para selects all the para descendants of the root document node and thus selects all para elements in the same document as the context node

• //@version selects all the version attribute nodes that are in the same document as the context node

• //list/member selects all the member elements in the same document as the context node that have a list parent

• .//para selects the para element descendants of the context node

• .. selects the parent of the context node

• ../@lang selects the lang attribute of the parent of the context node

• para[@type="warning"] selects all para children of the context node that have a type attribute with value warning

• para[@type="warning"][5] selects the fifth para child of the context node that has a type attribute with value warning

• para[5][@type="warning"] selects the fifth para child of the context node if that child has a type attribute with value warning

• chapter[title="Introduction"] selects the chapter children of the context node that have one or more title children whose typed value is equal to the string Introduction

• chapter[title] selects the chapter children of the context node that have one or more title children

• employee[@secretary and @assistant] selects all the employee children of the context node that have both a secretary attribute and an assistant attribute

• book/(chapter|appendix)/section selects every section element that has a parent that is either a chapter or an appendix element, that in turn is a child of a book element that is a child of the context node.

• If E is any expression that returns a sequence of nodes, then the expression E/. returns the same nodes in document order, with duplicates eliminated based on node identity.

3.4.1 Constructing Sequences

[Definition: 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:

• The result of this expression is a sequence of five integers:

  (10, 1, 2, 3, 4)
  

• This expression combines four sequences of length one, two, zero, and two, respectively, into a single sequence of length five. The result of this expression is the sequence 10, 1, 2, 3, 4.

  (10, (1, 2), (), (3, 4))
  

• The result of this expression is a sequence containing all salary children of the context node followed by all bonus children.

  (salary, bonus)
  

• Assuming that $price is bound to the value 10.50, the result of this expression is the sequence 10.50, 10.50.

  ($price, $price)
  

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.

• This example uses a range expression as one operand in constructing a sequence. It evaluates to the sequence 10, 1, 2, 3, 4.

  (10, 1 to 4)
  

• This example constructs a sequence of length one containing the single integer 10.

  10 to 10
  

• The result of this example is a sequence of length zero.

  15 to 10
  

• This example uses the fn:reverse function to construct a sequence of six integers in decreasing order. It evaluates to the sequence 15, 14, 13, 12, 11, 10.

  fn:reverse(10 to 15)
  

3.4.2 Combining Node Sequences

XQuery 3.0 provides the following operators for combining sequences of nodes:

• The union and | operators are equivalent. They take two node sequences as operands and return a sequence containing all the nodes that occur in either of the operands.

• The intersect operator takes two node sequences as operands and returns a sequence containing all the nodes that occur in both operands.

• The except operator takes two node sequences as operands and returns a sequence containing all the nodes that occur in the first operand but not in the second operand.

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 [err:XPTY0004].

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, [XQuery and XPath Functions and Operators 3.0] 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.

3.7.1 Value Comparisons

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:

1. Atomization is applied to the operand. The result of this operation is called the atomized operand.

2. If the atomized operand is an empty sequence, the result of the value comparison is an empty sequence, and the implementation need not evaluate the other operand or apply the operator. However, an implementation may choose to evaluate the other operand in order to determine whether it raises an error.

3. If the atomized operand is a sequence of length greater than one, a type error is raised [err:XPTY0004].

4. If the atomized operand is of type xs:untypedAtomic, it is cast to xs:string.

   Note:

   The purpose of this rule is to make value comparisons transitive. Users should be aware that the general comparison operators have a different rule for casting of xs:untypedAtomic operands. Users should also be aware that transitivity of value comparisons may be compromised by loss of precision during type conversion (for example, two xs:integer values that differ slightly may both be considered equal to the same xs:float value because xs:float has less precision than xs:integer).

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 B.2 Operator Mapping 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 [XQuery and XPath Functions and Operators 3.0].

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 B.2 Operator Mapping, a type error is raised [err:XPTY0004].

Here are some examples of value comparisons:

• The following comparison atomizes the node(s) that are returned by the expression $book/author. The comparison is true only if the result of atomization is the value "Kennedy" as an instance of xs:string or xs:untypedAtomic. If the result of atomization is an empty sequence, the result of the comparison is an empty sequence. If the result of atomization is a sequence containing more than one value, a type error is raised [err:XPTY0004].

  $book1/author eq "Kennedy"
  

• The following path expression contains a predicate that selects products whose weight is greater than 100. For any product that does not have a weight subelement, the value of the predicate is the empty sequence, and the product is not selected. This example assumes that weight is a validated element with a numeric type.

  //product[weight gt 100]
  

• The following comparisons are true because, in each case, the two constructed nodes have the same value after atomization, even though they have different identities and/or names:

  <a>5</a> eq <a>5</a>
  

  <a>5</a> eq <b>5</b>
  

• The following comparison is true if my:hatsize and my:shoesize are both user-defined types that are derived by restriction from a primitive numeric type:

  my:hatsize(5) eq my:shoesize(5)
  

• The following comparison is true. The eq operator compares two QNames by performing codepoint-comparisons of their namespace URIs and their local names, ignoring their namespace prefixes.

  fn:QName("http://example.com/ns1", "this:color")
     eq fn:QName("http://example.com/ns1", "that:color")
  

3.7.2 General 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:

1. Atomization is applied to each operand. After atomization, each operand is a sequence of atomic values.

2. The result of the comparison is true if and only if there is a pair of atomic values, one in the first operand sequence and the other in the second operand sequence, that have the required magnitude relationship. Otherwise the result of the comparison is false. The magnitude relationship between two atomic values is determined by applying the following rules. If a cast operation called for by these rules is not successful, a dynamic error is raised. [err:FORG0001]

   Note:

   The purpose of these rules is to preserve compatibility with XPath 1.0, in which (for example) x < 17 is a numeric comparison if x is an untyped value. Users should be aware that the value comparison operators have different rules for casting of xs:untypedAtomic operands.

   1. If both atomic values are instances of xs:untypedAtomic, then the values are cast to the type xs:string.

   2. If exactly one of the atomic values is an instance of xs:untypedAtomic, it is cast to a type depending on the other value's dynamic type T according to the following rules, in which V denotes the value to be cast:

      1. If T is a numeric type or is derived from a numeric type, then V is cast to xs:double.

      2. If T is xs:dayTimeDuration or is derived from xs:dayTimeDuration, then V is cast to xs:dayTimeDuration.

      3. If T is xs:yearMonthDuration or is derived from xs:yearMonthDuration, then V is cast to xs:yearMonthDuration.

      4. In all other cases, V is cast to the primitive base type of T.

      Note:

      The special treatment of the duration types is required to avoid errors that may arise when comparing the primitive type xs:duration with any duration type.

   3. After performing the conversions described above, the atomic values are compared using one of the value comparison operators eq, ne, lt, le, gt, or ge, depending on whether the general comparison operator was =, !=, <, <=, >, or >=. The values have the required magnitude relationship if and only if the result of this value comparison is true.

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:

• The following comparison is true if the typed value of any author subelement of $book1 is "Kennedy" as an instance of xs:string or xs:untypedAtomic:

  $book1/author = "Kennedy"
  

• The following example contains three general comparisons. The value of the first two comparisons is true, and the value of the third comparison is false. This example illustrates the fact that general comparisons are not transitive.

  (1, 2) = (2, 3)
  (2, 3) = (3, 4)
  (1, 2) = (3, 4)
  

• The following example contains two general comparisons, both of which are true. This example illustrates the fact that the = and != operators are not inverses of each other.

  (1, 2) = (2, 3)
  (1, 2) != (2, 3)
  

• Suppose that $a, $b, and $c are bound to element nodes with type annotation xs:untypedAtomic, with string values "1", "2", and "2.0" respectively. Then ($a, $b) = ($c, 3.0) returns false, because $b and $c are compared as strings. However, ($a, $b) = ($c, 2.0) returns true, because $b and 2.0 are compared as numbers.

3.7.3 Node 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:

1. The operands of a node comparison are evaluated in implementation-dependent order.

2. If either operand is an empty sequence, the result of the comparison is an empty sequence, and the implementation need not evaluate the other operand or apply the operator. However, an implementation may choose to evaluate the other operand in order to determine whether it raises an error.

3. Each operand must be either a single node or an empty sequence; otherwise a type error is raised [err:XPTY0004].

4. A comparison with the is operator is true if the two operand nodes have the same identity, and are thus the same node; otherwise it is false. See [XQuery and XPath Data Model (XDM) 3.0] for a definition of node identity.

5. A comparison with the << operator returns true if the left operand node precedes the right operand node in document order; otherwise it returns false.

6. A comparison with the >> operator returns true if the left operand node follows the right operand node in document order; otherwise it returns false.

Here are some examples of node comparisons:

• The following comparison is true only if the left and right sides each evaluate to exactly the same single node:

  /books/book[isbn="1558604820"] is /books/book[call="QA76.9 C3845"]
  

• The following comparison is false because each constructed node has its own identity:

  <a>5</a> is <a>5</a>
  

• The following comparison is true only if the node identified by the left side occurs before the node identified by the right side in document order:

  /transactions/purchase[parcel="28-451"]
     << /transactions/sale[parcel="33-870"]
  

3.9.1 Direct Element Constructors

An element constructor creates an element node. [Definition: 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: