XQuery 1.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. If analysis of an expression relies on some component of the static context that has not been assigned a value, a static error is raised.[err:XP0001]

The individual components of the static context are summarized below. Further rules governing the semantics 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 2.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: In-scope namespaces. This is a set of (prefix, URI) pairs. The in-scope namespaces are used for resolving prefixes used in QNames within the expression.]

  Some namespaces are predefined; additional namespaces can be defined by Prologs, by namespace declaration attributes, and by computed namespace constructors.

• [Definition: Default element/type namespace. This is a namespace URI. This namespace is used for any unprefixed QName appearing in a position where an element or type name is expected.] The initial default element/type namespace may be provided by the external environmentor by a declaration in the Prolog of a module.

• [Definition: Default function namespace. This is a namespace URI. This namespace URI is used for any unprefixed QName appearing as the function name in a function call. The initial default function namespace may be provided by the external environmentor by a declaration in the Prolog of a module.]

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

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

  • [Definition: In-scope element declarations. Each element declaration is identified either by a QName (for a top-level element declaration) or by an implementation-dependent element identifier (for a local element declaration). If the Schema Import Feature is supported, in-scope element declarations include all element declarations found in imported schemas. An element declaration includes information about the substitution groups to which this element belongs.]

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

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

  Variable declarations in the Prolog of a module are added to the in-scope variables of the module. An expression that binds a variable (such as a let, for, some, or every expression) extends the in-scope variables of its subexpressions with the new bound variable and its type. Within a function declaration, the in-scope variables are extended by the names and types of the function parameters.

• [Definition: In-scope functions. This component defines the set of functions that are available to be called from within an expression. Each function is uniquely identified by its expanded QName and its arity (number of parameters).] [Definition: Each function has a function signature that specifies the name of the function and the static types of its parameters and its result.]

  The in-scope functions include constructor functions, which are discussed in 3.12.5 Constructor Functions.

• [Definition: In-scope collations. This is a set of (URI, collation) pairs. It defines the names of the collations that are available for use in function calls that take a collation name as an argument.] A collation may be regarded as an object that supports two functions: a function that given a set of strings, returns a sequence containing those strings in sorted order; and a function that given two strings, returns true if they are considered equal, and false if not.

• [Definition: Default collation. This collation is used by string comparison functions and operators when no explicit collation is specified.] For exceptions to this rule, see 4.11 Default Collation Declaration.

• [Definition: Validation mode. The validation mode specifies the mode in which validation is performed by element constructors and by validate expressions. ] Its value is one of strict, lax, or skip. The initial validation mode may be provided by the environment external to a query or by the validation declaration in the Prolog of a module. If no validation mode is specified in either of these ways, the initial validation mode is lax.

  The validation mode for a subexpression is inherited from the containing expression. A validate expression that specifies a mode changes the validation mode of its subexpressions to the specified mode.

• [Definition: Validation context. An expression's validation context determines the context in which elements constructed by the expression are validated. ] Its value is either global or a context path that starts with the name of a top-level element declaration or top-level type definition in the in-scope schema definitions. The default validation context of a module is global.

  The validation context for a subexpression is inherited from the containing expression. An element constructor extends the validation context of its subexpressions with the name of the constructed element, and a validate expression that specifies a context redefines the validation context of its subexpressions.

• [Definition: XMLSpace policy. This policy, declared in the Prolog, controls the processing of whitespace by element constructors.] Its value may be preserve or strip.

• [Definition: Base URI. This is an absolute URI, used when necessary in the resolution of relative URIs (for example, by the fn:resolve-uri function.)]

• [Definition: Statically-known documents. This is a mapping from strings onto types. The string represents the absolute URI of a resource that is potentially available using the fn:doc function. The type is the type of the document node that would result from calling the fn:doc function with this URI as its argument. ] If the argument to fn:doc is not a string literal that is 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 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 onto 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 not a string literal that is 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 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.

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 has not been assigned a value, a dynamic error is raised.[err:XP0002]

The individual components of the dynamic context are summarized below. Further rules governing the semantics 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 nodes are being processed by the expression.

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

• [Definition: The context item is the item currently being processed in a path expression. An item is either an atomic value or a node.][Definition: When the context item is a node, it can also be referred to as the context node.] The context item is returned by the expression ".". 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 context position is the position of the context item within the sequence of items currently being processed in a path expression. ]It changes whenever the context item changes. Its value is always 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 in a path expression.] 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: Dynamic variables. This is a set of (QName, value) pairs. It contains the same QNames as the in-scope variables in the static context for the expression. The QName is the name of the variable and the value is the dynamic value of the variable.]

• [Definition: Function implementations. Each function in in-scope functions has a function implementation that enables the function to map instances of its parameter types into an instance of its result type. For a user-defined function, the function implementation is an XQuery expression. For an external function, the function implementation is implementation-dependent.]

• [Definition: Current date and time. This information represents an implementation-dependent point in time during processing of a query or transformation. It can be retrieved by the fn:current-date, fn:current-time, and fn:current-dateTime functions. If invoked multiple times during the execution of a query or transformation, these functions always return 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 in any other operation. This value is an instance of xdt:dayTimeDuration that is implementation-defined . See [ISO 8601] for the range of legal values of a timezone.]

• [Definition: Available documents. This is a mapping of strings onto document nodes. The 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 constrained by the set of statically-known documents, and it may be empty.

• [Definition: Available collections. This is a mapping of strings onto sequences of nodes. The 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 collections is not constrained by the set of statically-known collections, and it may be empty.

2.2.1 Data Model Generation

Before an expression can be processed, the input documents to be accessed by the expression must be represented in the data model. This process occurs outside the domain of XQuery, 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 the data model:

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], 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 the data model by a process described in [XQuery 1.0 and XPath 2.0 Data Model]. (See DM2 in Fig. 1.)

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

Each atomic value, element node, and attribute node in the data model is annotated with its dynamic type. The dynamic type specifies a range of values—for example, an attribute named version might have the dynamic type xs:decimal, indicating that it contains a decimal value. For example, if the data model was derived from an input XML document, the dynamic types of the elements and attributes are derived from schema validation.

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 annotated with the dynamic type xdt: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 dynamic type of an element node indicates how the values in its child text nodes are to be interpreted. An element whose type is unknown (such as might occur in a schemaless document) is annotated with the type xdt:untypedAny.

An atomic value of unknown type is annotated with the type xdt:untypedAtomic.

2.2.2 Schema Import Processing

2.2.3 Expression Processing

XQuery defines two phases of processing called the static analysis phase and the dynamic evaluation phase (see Fig. 1). An implementation is free to use any strategy or algorithm whose result conforms to these specifications.

2.2.4 Serialization

[Definition: Serialization is the process of converting a set of nodes from the data model into a sequence of octets (step DM4 in Figure 1.) ] The general framework for serialization of the data model is described in [XSLT 2.0 and XQuery 1.0 Serialization].

2.2.5 Consistency Constraints

In order for XQuery to be well defined, the data model, the static context, and the dynamic context must be mutually consistent. The consistency constraints listed below are prerequisites for correct functioning of an XQuery implementation. Enforcement of these consistency constraints is beyond the scope of this specification.

Some of the consistency constraints use the term data model schema. [Definition: For a given node in the data model, the data model schema is defined as the schema from which the type annotation of that node was derived.] For a node that was constructed by some process other than schema validation, the data model schema consists simply of the type definition that is represented by the type annotation of the node.

• For every data model node that has a type annotation other than xs:anyType, if that type annotation is found in the in-scope schema definitions (ISSD), then its definition in the ISSD must be the same as its definition in the data model schema. Furthermore, all types that are derived by extension from the given type in the data model schema must also be known by equivalent definitions in the ISSD.

• For every element name EN that is found both in a data model node and in the in-scope schema definitions (ISSD), all elements that are known in the data model schema to be in the same substitution group as EN must also be known in the ISSD to be in the same substitution group as EN.

• Every item type (i.e., every element, attribute, or type name) referenced in in-scope variables or in-scope functions must be 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.4.4 SequenceType Matching.

• For each mapping of a string to a sequence of nodes in available 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.4.4 SequenceType Matching.

• The dynamic variables in the dynamic context and the in-scope variables in the static context must correspond as follows:

  • All variables defined in in-scope variables must be defined in dynamic variables.

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

2.3.1 Document Order

An ordering called document order is defined among all the nodes used during a given query or transformation, which may consist of one or more trees (documents or fragments). Document order is defined in [XQuery 1.0 and XPath 2.0 Data Model], and its definition is repeated here for convenience.

Document order is a total ordering, although the relative order of some nodes is implementation-dependent. Informally, document order is the order returned by an in-order, depth-first traversal of the data model. Document order is stable, which means that the relative order of two nodes will not change during the processing of a given query or transformation, even if this order is implementation-dependent.

Within a tree, document order satisfies the following constraints:

1. The root node is the first node.

2. The relative order of siblings is determined by their order in the XML representation of the tree. A node N1 occurs before a node N2 in document order if and only if the start of N1 occurs before the start of N2 in the XML representation.

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

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

5. Element nodes occur before their children; children 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 tree T1 is before any node in tree T2, then all nodes in tree T1 are before all nodes in tree T2.

2.3.2 Atomization

The semantics of some XQuery operators depend on a process called atomization. [Definition: 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. Atomization of a sequence is defined as the result of invoking the fn:data function on the sequence, as defined in [XQuery 1.0 and XPath 2.0 Functions and Operators].]

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.

Atomization is used in processing the following types of expressions:

• Arithmetic expressions

• Comparison expressions

• Function calls and returns

• Cast expressions

• Computed element and attribute constructors.

2.3.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 1.0 and XPath 2.0 Functions and Operators].]

The semantics of fn:boolean are repeated here for convenience. fn:boolean returns false if its operand is any of the following:

• An empty sequence

• The boolean value false

• A zero-length value of type xs:string or xdt:untypedAtomic

• A numeric value that is equal to zero

• The xs:double or xs:float value NaN

Otherwise, fn:boolean returns true.

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)

2.3.4 Input Sources

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

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

The input functions supported by XQuery are as follows:

• The fn:doc function takes a string containing a URI that refers to an XML document, and returns a document node whose content is the data model representation of the given document.

• The fn:collection function takes a string containing a URI, and returns the data model representation of the collection identified by the URI. 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.

If a given input function is invoked repeatedly with arguments that resolve to the same absolute URI during the scope of a single query or transformation, each invocation returns the same result.

2.4.1 Predefined Types

1. xdt:anyAtomicType is an abstract type that includes all atomic values (and no values that are not atomic). It is a subtype of xs:anySimpleType, which is the base type for all simple types, including atomic, list, and union types. All specific atomic types such as xs:integer, xs:string, and xdt:untypedAtomic, are subtypes of xdt:anyAtomicType.

2. xdt:untypedAny is a concrete type used to denote the dynamic type of an element node that has not been assigned a more specific type. It has no subtypes. An element that has been validated in skip mode, or that has a PSVI type property of xs:anyType, is represented in the Data Model by an element node with the type xdt:untypedAny.

3. xdt:untypedAtomic is a concrete type used to denote untyped atomic data, such as text that has not been assigned a more specific type. It has no subtypes. An attribute that has been validated in skip mode, or that has a PSVI property of xs:anySimpleType, is represented in the Data Model by an attribute node with the type xdt:untypedAtomic.

4. xdt:dayTimeDuration is a concrete subtype of xs:duration whose lexical representation contains only day, hour, minute, and second components.

5. xdt:yearMonthDuration is a concrete subtype of xs:duration whose lexical representation is restricted to contain only year and month components.

The relationships among the types in the xs and xdt namespaces are illustrated in Figure 2. The abstract types, represented by ovals in the figure, may be assigned to an expression during the static analysis phase if no more specific type can be inferred for the expression. During the dynamic evaluation phase, each node or value in the data model is assigned a concrete type, represented by one of the types listed in the rectangular boxes in Figure 2. A more complete description of the XQuery type hierarchy can be found in [XQuery 1.0 and XPath 2.0 Functions and Operators].

Figure 2: Summary of XQuery Type Hierarchy

2.4.2 Typed Value and String Value

In the data model, every node has a typed value and a string value. The typed value of a node is a sequence of atomic values and can be extracted by applying the fn:data function to the node. The typed value for each kind of node is defined by the dm:typed-value accessor in [XQuery 1.0 and XPath 2.0 Data Model]. The string value of a node is a string and can be extracted by applying the fn:string function to the node. The string value for each kind of node is defined by the dm:string-value accessor in [XQuery 1.0 and XPath 2.0 Data Model]. Element and attribute nodes have a type annotation, which represents (in an implementation-dependent way) the dynamic (run-time) type of the node. In the [XQuery 1.0 and XPath 2.0 Data Model], type annotation is defined by the dm:type accessor; however, XQuery does not provide a way to directly access the type annotation of an element or attribute node.

The relationship between the typed value and the string value for various kinds of nodes is described and illustrated by examples below.

1. For text, document, and namespace nodes, the typed value of the node is the same as its string value, as an instance of the type xdt: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 xdt:untypedAtomic is the same as its string value, as an instance of xdt:untypedAtomic. The typed value of an attribute node with any other type annotation is derived from its string value and type annotation in a way that is consistent with schema validation.

   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 derived from 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 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 xdt:untypedAtomic, or denotes a complex type with mixed content, then the typed value of the node is equal to its string value, as an instance of xdt:untypedAtomic.

      Note:

      Since xs:untypedAny is a complex type with mixed content, this rule applies to elements whose type is xs:untypedAny.

      Example: E1 is an element node having type annotation xdt:untypedAny and string value "1999-05-31". The typed value of E1 is "1999-05-31", as an instance of xdt: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 xdt: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.

      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.

   3. If the type annotation denotes a complex type with empty content, then the typed value of the node is the empty sequence.

   4. If the type annotation denotes a complex type with element-only content, then the typed value of the node is undefined. The fn:data function raises a type error [err:XP0007] when applied to such a node.

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

2.4.3 SequenceType Syntax

[Definition: When it is necessary to refer to a type in an XQuery expression, the SequenceType syntax is used. The name SequenceType suggests that this syntax is used to describe the type of an XQuery value, which is always a sequence.]

QNames appearing in a SequenceType have their prefixes expanded to namespace URIs by means of the in-scope namespaces and the default element/type namespace. It is a static error [err:XP0008] to use a TypeName in an ElementTest or AttributeTest if that name is not found in the in-scope type definitions. It is a static error [err:XP0008] to use an ElementName in an ElementTest if that name is not found in the in-scope element definitions unless a TypeNameOrWildcard is specified. It is a static error [err:XP0008] to use a (SchemaContextPath ElementName) pair in an ElementTest if the ElementName can not be located from the in-scope element definitions using the SchemaContextPath. It is a static error [err:XP0008] to use an AttributeName in an AttributeTest if that name is not found in the in-scope attribute definitions unless a TypeNameOrWildcard is specified. It is a static error [err:XP0008] to use a (SchemaContextPath AttributeName) pair in an AttributeTest if the AttributeName can not be located from the in-scope attribute definitions using the SchemaContextPath. If a QName that is used as an AtomicType is not defined as an atomic type in the in-scope type definitions, a static error is raised. [err:XP0051]

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

• xs:date refers to the built-in Schema type date

• attribute()? refers to an optional attribute

• element() refers to any element

• element(po:shipto, po:address) refers to an element that has the name po:shipto (or is in the substitution group of that element), and has the type annotation po:address (or a subtype of that type)

• element(po:shipto, *) refers to an element named po:shipto (or in the substitution group of po:shipto), with no restrictions on its type

• element(*, po:address) refers to an element of any name that has the type annotation po:address (or a subtype of po:address). If the keyword nillable were used following po:address, that would indicate that the element may have empty content and the attribute xsi:nil="true", even though the declaration of the type po:address has required content.

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

• item()+ refers to a sequence of one or more nodes or atomic values

2.4.4 SequenceType Matching

[Definition: During evaluation of an expression, it is sometimes necessary to determine whether a value with a known type "matches" an expected type, expressed in the SequenceType syntax. This process is known as SequenceType matching.] For example, an instance of expression returns true if the actual type of a given value matches a given type, or false if it does not.

The rules for SequenceType matching compare the actual type of a value with an expected type. These rules are a subset of the static typing rules defined in [XQuery 1.0 and XPath 2.0 Formal Semantics], which compare the static type of an expression with the expected type of the context in which the expression is used. The static typing rules are a superset of the SequenceType matching rules because the static type of an expression is typically more general than the dynamic type of the value produced by evaluating the expression. For example, the static type of the expression if (expr) then "true" else 0 is xs:string | xs:integer, as described in [XQuery 1.0 and XPath 2.0 Formal Semantics]. However, if expr evaluates to true, then the dynamic type of this expression is xs:string.

Some of the rules for SequenceType matching require matching of simple or complex types to determine whether a given type is the same as or derived from an expected type. These types may be "known" types, which are defined in the in-scope schema definitions, or "unknown" types, which are not defined in the in-scope schema definitions. An unknown type might be encountered, for example, if the module in which the given type is encountered does not import the schema in which the given type is defined. In this case, an implementation is allowed (but is not required) to provide an implementation-dependent mechanism for determining whether the unknown type is compatible with the expected type. For example, an implementation might maintain a data dictionary containing information about type hierarchies.

We define the process of matching simple or complex types using a pseudo-function named type-matches(ET, AT) that takes an expected simple or complex type ET and an actual simple or complex type AT, and either returns a boolean value or raises a type error. [err:XP0004][err:XP0006] This pseudo-function type-matches is defined as follows:

• type-matches(ET, AT) returns true if:

  1. AT is a known type, and is the same as ET, or is derived by one or more steps of restriction or extension from ET, or

  2. AT is an unknown type, and an implementation-dependent mechanism is able to determine that AT is derived by restriction from ET.

• type-matches(ET, AT) returns false if:

  1. AT is a known type, and is not the same as ET, and is not derived by one or more steps of restriction or extension from ET, or

  2. AT is an unknown type, and an implementation-dependent mechanism is able to determine that AT is not derived by restriction from ET.

• type-matches(ET, AT) raises a type error [err:XP0004][err:XP0006] if:

  1. ET is an unknown type, or

  2. AT is an unknown type, and the implementation is not able to determine whether AT is derived by restriction from ET.

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.1 Kinds of Errors

As described in 2.2.3 Expression Processing, XQuery defines an analysis phase, which does not depend on input data, and an evaluation phase, which does depend on input data. Errors may be raised during each phase.

[Definition: A static error is an error that must be detected during the analysis phase. A syntax error is an example of a static error. The means by which static errors are reported during the analysis phase is implementation-defined. ]

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

[Definition: A type error may be raised during the analysis or evaluation phase. During the 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 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 analysis phase is either success or one or more type errors and/or static errors. The result of the evaluation phase is either a result value, a type error, or a dynamic error.

If any expression (at any level) can be evaluated during the analysis phase (because all its explicit operands are known and it has no dependencies on the dynamic context), then any error in performing this evaluation may be reported as a static error. However, the fn:error() function must not be evaluated during the analysis phase. For example, an implementation is allowed (but not required) to treat the following expression as a static error, because it calls a constructor function with a constant string that is not in the lexical space of the target type:

xs:date("Next Tuesday")

In addition to static errors, dynamic errors, and type errors, an XQuery implementation may raise warnings, either during the analysis phase or the 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 if insufficient resources are available for processing a given expression. For example, an implementation may specify limitations on the maximum numbers or sizes of various objects. These limitations, and the consequences of exceeding them, are implementation-dependent.

2.5.2 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 validly return a value or raise a dynamic error, the implementation may choose to return the value or raise the dynamic error. For example, the logical expression expr1 and expr2 may return the value false if either operand returns false, or may raise a dynamic error if either operand raises a dynamic error.

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

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

A dynamic error carries an error value. [Definition: An error value is a single item or the empty sequence.] For example, an error value might be an integer, a string, a QName, or an element. An implementation may provide a mechanism whereby an application-defined error handler can process error values and produce diagnostics; in the absence of such an error handler, the string value of the error value may be used directly as an error message.

A dynamic error may be raised by a built-in function or operator. For example, the div operator raises an error if its second operand equals zero.

An error can be raised explicitly by calling the fn:error function, which only raises an error and never returns a value. This function is defined in [XQuery 1.0 and XPath 2.0 Functions and Operators]. The fn:error function takes an optional item as its parameter, which is the error value. For example, the following function call raises a dynamic error whose error value is a string:

fn:error(fn:concat("Unexpected value ", fn:string($v)))

2.5.3 Errors and Optimization

Because different implementations may choose to evaluate or optimize an expression in different ways, the detection and reporting of dynamic errors is implementation-dependent.

When an implementation is able to evaluate an expression without evaluating some subexpression, the implementation is never required to evaluate that subexpression solely to determine whether it raises a dynamic error. For example, if a function parameter is never used in the body of the function, an implementation may choose whether to evaluate the expression bound to that parameter in a function call.

Similarly, in evaluating an expression, an implementation is not required to search for data whose only possible effect on the result would be to raise an error, as illustrated in the following 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 because it is not an integer.

  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]
  

In some cases, an optimizer may be able to achieve substantial performance improvements by rearranging an expression so that the underlying operations are performed in a different order than that in which they are written. In such cases, errors may be raised that would not have been raised if the expression were evaluated as written. However, an expression must not be rearranged in a way that changes its result value in the absence of errors.

• The expression in the following example cannot raise a casting error if it is evaluated exactly as written (i.e., left to right). An implementation is permitted, however, 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 reordering of expressions, tests that are designed to prevent dynamic errors should be expressed using conditional or typeswitch expressions. Conditional and typeswitch expressions raise only dynamic errors that occur in the branch that is actually selected.

• Unlike the previous example, the following example cannot raise a dynamic error if @x is not castable into an xs:date.

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

3.1.1 Literals

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

The value of a numeric literal containing no "." and no e or E character is an atomic value of type xs:integer. The value of a numeric literal containing "." but no e or E character is an atomic value of type xs:decimal. The value of a numeric literal containing an e or E character is an atomic value of type xs:double. Values of numeric literals are interpreted according to the rules in [XML Schema].

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.

Here are some examples of literal expressions:

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

• 12 denotes the integer value twelve.

• 12.5 denotes the decimal value twelve and one half.

• 125E2 denotes the 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 string "Ben & Jerry's".

• "€99.50" denotes the string "€99.50".

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

Values of other atomic types can be constructed by calling the constructor for the given type. The constructors for XML Schema built-in types are defined in [XQuery 1.0 and XPath 2.0 Functions and Operators]. 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.

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

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

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

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

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

2. A variable may be added to the in-scope variables by the host language environment.

3. A variable may be bound by an XQuery expression. The kinds of expressions that can bind variables are FLWOR expressions (3.8 FLWOR Expressions), quantified expressions (3.11 Quantified Expressions), and typeswitch expressions (3.12.2 Typeswitch). Function calls also bind values to the formal parameters of functions before executing the function body.

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

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

3.1.3 Parenthesized Expressions

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

Empty parentheses are used to denote an empty sequence, as described in 3.3.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")//book[fn:count(./author)>1]) or an atomic value (as in the expression (1 to 100)[. mod 5 eq 0]).

If the context item is undefined, a context item expression raises a dynamic error.[err:XP0002]

3.1.5 Function Calls

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

If the expanded QName and number of arguments in a function call do not match the name and arity of an in-scope function in the static context, a static error is raised.[err:XP0017]

XQuery allows functions to be called. A core library of functions is defined in [XQuery 1.0 and XPath 2.0 Functions and Operators]. 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. For details on processing function names that have no namespace prefix, see 4.5 Default Namespace Declaration.

A function call is evaluated as follows:

1. Argument expressions are evaluated, producing argument values. The order of argument evaluation is implementation-dependent and a function need not evaluate an argument if the function can evaluate its body without evaluating that argument.

2. Each argument value is converted by applying the function conversion rules listed below.

3. If the function is a built-in function, it is evaluated using the converted argument values. The result is a value of the function's declared return type.

4. If the function is a user-declared function, the converted argument values are bound to the formal parameters of the function, and the function body is evaluated. The value returned by the function body is then converted to the declared return type of the function by applying the function conversion rules.

   When a converted argument value is bound to a function parameter, the argument value retains its most specific dynamic type, even though this may be a subtype of the type of the formal parameter. For example, a function with a parameter $p of type xs:decimal can be invoked with an argument of type xs:integer, which is derived from xs:decimal. During the processing of this function invocation, the dynamic type of $p inside the body of the function is considered to be xs:integer. Similarly, the value returned by a function retains its most specific type, which may be a subtype of the declared return type of the function. For example, a function that has a declared return type of xs:decimal may in fact return a value of dynamic type xs:integer.

   A function does not inherit a focus (context item, context position, and context size) from the environment of the function call. During evaluation of a function body, the focus is undefined, except where it is defined by the action of some expression inside the function body. It is a static error [err:XP0018] for an expression to depend on the focus when the focus is undefined.

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

• If the expected type is a sequence of an atomic type (possibly with an occurrence indicator *, +, or ?), the following conversions are applied:

  1. Atomization is applied to the given value, resulting in a sequence of atomic values.

  2. Each item in the atomic sequence that is of type xdt:untypedAtomic is cast to the expected atomic type.

  3. For each numeric item in the atomic sequence that can be promoted to the expected atomic type using the promotion rules in B.1 Type Promotion, the promotion is done.

• If, after the above conversions, the resulting value does not match the expected type according to the rules for SequenceType Matching, a type error is raised. [err:XP0004][err:XP0006] If the function call takes place in a module other than the module in which the function is defined, this rule must be satisfied in both the module where the function is called and the module where the function is defined (the test is repeated because the two modules may have different in-scope schema definitions.) Note that the rules for SequenceType Matching permit a value of a derived type to be substituted for a value of its base type.

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

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

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

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

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

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

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

3.1.6 XQuery Comments

XQuery comments can be used to provide informative annotation. These comments are lexical constructs only, and do not affect the processing of an expression. Comments are delimited by the symbols (: and :). Comments may be nested.

Comments may be used anywhere ignorable whitespace is allowed. See A.2 Lexical structure for the exact lexical states where comments are recognized.

The following is an example of a comment:

(: Houston, we have a problem :)

3.2.1 Steps

A step 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. Predicates are described in 3.2.2 Predicates. XQuery provides two kinds of steps, called filter steps and axis steps.

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

The result of an axis step is always a sequence of zero or more nodes, and these nodes are always returned in document order. An axis step may be either a forward step or a reverse step, followed by zero or more predicates. An axis step might be thought of as beginning at the context node and navigating to those 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. If the context item is not a node, a type error is raised.[err:XP0020]

In the abbreviated syntax for a step, the axis can be omitted and other shorthand notations can be used as described in 3.2.4 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 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.2.1.1 Axes. The available node tests are described in 3.2.1.2 Node Tests. Examples of steps are provided in 3.2.3 Unabbreviated Syntax and 3.2.4 Abbreviated Syntax.

3.2.2 Predicates

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

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

1. If the value of the predicate expression is an atomic value of a numeric type, the predicate truth value is true if the value of the predicate expression is equal to the context position, and is false otherwise.

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

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 a secretary child element:

  child::employee[secretary]
  

When using predicates with a sequence of nodes selected using a reverse axis, it is important to remember that the the context positions for such a sequence are assigned in reverse document order. For example, preceding::foo[1] returns the first foo element in reverse document order, because the axis that applies to the [1] predicate is the preceding axis. By contrast, (preceding::foo)[1] returns the first foo element in document order, because the axis that applies to the [1] predicate is the child axis. Similarly, ancestor::*[1] returns the nearest ancestor element, because the ancestor axis is a reverse axis.

Here are some examples of filter steps that contain predicates:

• List all the integers from 1 to 100 that are divisible by 5. (See 3.3.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]
  

3.2.3 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.2.4 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, whatever their node type

• 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 selects nothing

• 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="warning"]selects all para children of the context node that have a type attribute with value warning

• child::para[attribute::type='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="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.2.4 Abbreviated Syntax

The abbreviated syntax permits the following abbreviations:

1. The most important abbreviation is that the axis name can be omitted from an axis step. If the axis name is omitted from an axis step, the default axis is child unless the axis step contains an AttributeTest; in that case, the default axis is attribute. 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.

2. There is also an abbreviation for 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.

3. // is effectively replaced by /descendant-or-self::node()/ during processing of a path expression. For example, //para is an abbreviation for /descendant-or-self::node()/child::para and so will select any para element in the document (even a para element that is a document element will be selected by //para since the document element node is a child of the root node); 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 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.3.1 Constructing Sequences

One way to construct a sequence is by using the comma operator, which evaluates each of its operands and concatenates the resulting values, in order, into a single result sequence.

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

In places where the grammar calls for ExprSingle, such as the arguments of a function call, any expression that contains a top-level comma operator must be enclosed in parentheses. Empty parentheses can be used to denote an empty sequence.

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. A type error [err:XP0006] is raised if either operand cannot be converted to a single integer. 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. 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.3.2 Combining Node Sequences

XQuery provides several 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 of these operators return their result sequences in document order without duplicates based on node identity. If an operand of union, intersect, or except contains an item that is not a node, a type error is raised.[err:XP0006]

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

• $seq1 is bound to (A, B)

• $seq2 is bound to (A, B)

• $seq3 is bound to (B, C)

Then:

• $seq1 union $seq2 evaluates to the sequence (A, B).

• $seq2 union $seq3 evaluates to the sequence (A, B, C).

• $seq1 intersect $seq2 evaluates to the sequence (A, B).

• $seq2 intersect $seq3 evaluates to the sequence containing B only.

• $seq1 except $seq2 evaluates to the empty sequence.

• $seq2 except $seq3 evaluates to the sequence containing A only.

In addition to the sequence operators described here,[XQuery 1.0 and XPath 2.0 Functions and Operators] 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 values or nodes from a sequence.

3.5.1 Value Comparisons

The value comparison operators are eq, ne, lt, le, gt, and ge. Value comparisons are used for comparing single values. The result of a value comparison is defined by applying the following rules, in order:

1. Atomization is applied to each operand. If the result, called an atomized operand, does not contain exactly one atomic value, a type error is raised.[err:XP0004][err:XP0006]

2. Any atomized operand that has the dynamic type xdt:untypedAtomic is cast to the type xs:string.

3. 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. B.2 Operator Mapping defines which combinations of atomic types are comparable, and how the comparison operators are mapped into supporting functions. If the value of the first atomized operand is not comparable with the value of the second atomized operand, a type error is raised.[err:XP0004][err:XP0006]

Here are some examples of value comparisons:

• The following comparison is true only if $book1 has exactly one author subelement and its typed value is "Kennedy" as an instance of xs:string or xdt:untypedAtomic. If $book1 does not have exactly one author subelement, a type error is raised.[err:XP0004][err:XP0006]

  $book1/author eq "Kennedy"
  

• 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)
  

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

Atomization is applied to each operand of a general comparison. The result of the comparison is true if and only if there is a pair of atomic values, one belonging to the result of atomization of the first operand and the other belonging to the result of atomization of the second operand, that have the required magnitude relationship. Otherwise the result of the general comparison is false. The magnitude relationship between two atomic values is determined as follows:

1. If either atomic value has the dynamic type xdt:untypedAtomic, that value is cast to a required type, which is determined as follows:

   1. If the dynamic type of the other atomic value is a numeric type, the required type is xs:double.

   2. If the dynamic type of the other atomic value is xdt:untypedAtomic, the required type is xs:string.

   3. Otherwise, the required type is the dynamic type of the other atomic value.

   If the cast to the required type fails, a dynamic error is raised.[err:XP0021]

2. After any necessary casting, 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 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 for which the underlying value comparison is true. 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 xdt: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)
  

• Suppose that $a, $b, and $c are bound to element nodes with type annotation xdt: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.5.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 applying the following rules, in order:

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

2. If either operand is an empty sequence, the result of the comparison is an empty sequence.

3. A comparison with the is operator is true if the two operands have the same identity, and are thus the same node; otherwise it is false. See [XQuery 1.0 and XPath 2.0 Data Model] for a definition of node identity.

4. A comparison with the << operator returns true if the first operand node precedes the second operand node in document order; otherwise it returns false.

5. A comparison with the >> operator returns true if the first operand node follows the second 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:

  //book[isbn="1558604820"] is //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:

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

3.12.1 Instance Of

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

• 5 instance of xs:integer

  This example returns true because the given value is an instance of the given type.

• 5 instance of xs:decimal

  This example returns true because the given value is an integer literal, and xs:integer is derived by restriction from xs:decimal.

• <a>{5}</a> instance of xs:integer

  This example returns false because the given value is not an integer; instead, it is an element containing an integer.

• <a>{5}</a> instance of element(*, xs:integer)

  This example returns true if validation of the constructed element is successful and, after validation, the type annotation AT of the constructed element satisfies type-matches(xs:integer, AT) as described in 2.4.4 SequenceType Matching.

• . instance of element()

  This example returns true if the context item is an element node. If the context item is undefined, a dynamic error is raised.[err:XP0002]

3.12.3 Cast

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

1. Atomization is performed on the input expression.

2. If the result of atomization is a sequence of more than one atomic value, a type error is raised.[err:XP0004][err:XP0006]

3. If the result of atomization is an empty sequence:

   1. If ? is specified after the target type, the result of the cast expression is an empty sequence.

   2. If ? is not specified after the target type, a type error is raised.[err:XP0004][err:XP0006]

4. If the result of atomization is a single atomic value, the result of the cast expression depends on the input type and the target type. In general, the cast expression attempts to create a new value of the target type based on the input value. Only certain combinations of input type and target type are supported. A summary of the rules are listed below— the normative definition of these rules is given in [XQuery 1.0 and XPath 2.0 Functions and Operators]. For the purpose of these rules, we use the terms subtype and supertype in the following sense: if type B is derived from type A by restriction, then B is a subtype of A, and A is a supertype of B. An implementation may determine that one type is a subtype of another either by examining the in-scope schema definitions or by using an alternative, implementation-dependent mechanism such as a data dictionary.

   1. cast is supported for the combinations of input type and target type listed in [XQuery 1.0 and XPath 2.0 Functions and Operators]. For each of these combinations, both the input type and the target type are primitive schema types. For example, a value of type xs:string can be cast into the type xs:decimal. For each of these built-in combinations, the semantics of casting are specified in [XQuery 1.0 and XPath 2.0 Functions and Operators].

   2. cast is supported if the input type is a non-primitive atomic type and the target type is a supertype of the input type. In this case, the input value is mapped into the value space of the target type, unchanged except for its type. For example, if shoesize is derived by restriction from xs:integer, a value of type shoesize can be cast into the type xs:integer.

   3. cast is supported if the target type is a non-primitive atomic type and the input type is xs:string or xdt:untypedAtomic. The input value is first converted to a value in the lexical space of the target type by applying the whitespace normalization rules for the target type; a dynamic error [err:XP0029] is raised if the resulting lexical value does not satisfy the pattern facet of the target type. The lexical value is then converted to the value space of the target type using the schema-defined rules for the target type; a dynamic error[err:XP0029] is raised if the resulting value does not satisfy all the facets of the target type.

   4. cast is supported if the target type is a non-primitive atomic type and the input type is a supertype of the target type. The input value must satisfy all the facets of the target type (in the case of the pattern facet, this is checked by generating a string representation of the input value, using the rules for casting to xs:string). The resulting value is the same as the input value, but with a different dynamic type.

   5. If a primitive type P1 can be cast into a primitive type P2, then any subtype of P1 can be cast into any subtype of P2, provided that the facets of the target type are satisfied. First the input value is cast to P1 using rule (b) above. Next, the value of type P1 is cast to the type P2, using rule (a) above. Finally, the value of type P2 is cast to the target type, using rule (d) above.

   6. For any combination of input type and target type that is not in the above list, a cast expression raises a type error.[err:XP0004][err:XP0006]

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

3.12.4 Castable

XQuery provides a form of Boolean expression that tests whether a given value is castable into a given target type. The expression V castable as T returns true if the value V can be successfully cast into the target type T by using a cast expression; otherwise it returns false. The castable predicate can be used to avoid errors at evaluation time. It can also be used to select an appropriate type for processing of a given value, as illustrated in the following example:

if ($x castable as hatsize) 
   then $x cast as hatsize 
   else if ($x castable as IQ) 
   then $x cast as IQ 
   else $x cast as xs:string

3.12.5 Constructor Functions

Constructor functions provide an alternative syntax for casting.

A built-in constructor function is provided for each atomic type in the static context. The signature of the built-in constructor function for type T is as follows:

T($x as item) as T

The constructor function for type T accepts any single item (either a node or an atomic value) as input, and returns a value of type T (or raises a dynamic error). Its semantics are exactly the same as a cast expression with target type T. The built-in constructor functions are defined in [XQuery 1.0 and XPath 2.0 Functions and Operators]. The following are examples of built-in constructor functions:

• This example is equivalent to "2000-01-01" cast as xs:date.

  xs:date("2000-01-01")
  

• This example is equivalent to ($floatvalue * 0.2E-5) cast as xs:decimal.

  xs:decimal($floatvalue *
  0.2E-5)
  

• This example returns a xdt:dayTimeDuration value equal to 21 days. It is equivalent to "P21D" cast as xdt:dayTimeDuration.

  xdt:dayTimeDuration("P21D")
  

For each user-defined named atomic type definition T in the in-scope type definitions that is in a namespace, a constructor function is defined. Like the built-in constructor functions, the constructor functions for user-defined types have the same name (including namespace) as the type, accept any item as input, and have semantics identical to a cast expression with the user-defined type as target type. For example, if usa:zipcode is a user-defined atomic type in the in-scope type definitions, then the expression usa:zipcode("12345") is equivalent to the expression "12345" cast as usa:zipcode.

User-defined atomic types that are not in a namespace do not have implicit constructor functions. To construct an instance of such a type, it is necessary to use a cast expression. For example, if the user-defined type apple is derived from xs:integer but is not in a namespace, an instance of this type can be constructed as follows:

17 cast as apple

3.12.6 Treat

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

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

The semantics of expr1 treat as type1 are as follows:

• During static analysis:

  The static type of the treat expression is type1. This enables the expression to be used as an argument of a function that requires a parameter of type1.

• During expression evaluation:

  If expr1 matches type1, using the SequenceType Matching rules in 2.4 Types, the treat expression returns the value of expr1; otherwise, it raises a dynamic error.[err:XP0006] If the value of expr1 is returned, its identity is preserved. The treat expression ensures that the value of its expression operand conforms to the expected type at run-time.

• Example:

  $myaddress treat as element(*, USAddress)
  

  The static type of $myaddress may be element(*, Address), a less specific type than element(*, USAddress). However, at run-time, the value of $myaddress must match the type element(*, USAddress) using SequenceType Matching rules; otherwise a dynamic error is raised.[err:XP0050]