XML Path Language (XPath) 2.0 (original) (raw)

1 Introduction

The primary purpose of XPath is to address the nodes of [XML 1.0] or [XML 1.1] trees. XPath gets its name from its use of a path notation for navigating through the hierarchical structure of an XML document. XPath uses a compact, non-XML syntax to facilitate use of XPath within URIs and XML attribute values.

[Definition: XPath operates on the abstract, logical structure of an XML document, rather than its surface syntax. This logical structure, known as the data model, is defined in [XQuery/XPath Data Model (XDM)].]

XPath is designed to be embedded in a host language such as [XSLT 2.0] or [XQuery]. XPath has a natural subset that can be used for matching (testing whether or not a node matches a pattern); this use of XPath is described in [XSLT 2.0].

XQuery Version 1.0 is an extension of XPath Version 2.0. Any expression that is syntactically valid and executes successfully in both XPath 2.0 and XQuery 1.0 will return the same result in both languages. Since these languages are so closely related, their grammars and language descriptions are generated from a common source to ensure consistency, and the editors of these specifications work together closely.

XPath also depends on and is closely related to the following specifications:

This document specifies a grammar for XPath, using the same basic EBNF notation used in [XML 1.0]. Unless otherwise noted (see A.2 Lexical structure), whitespace is not significant in expressions. Grammar productions are introduced together with the features that they describe, and a complete grammar is also presented in the appendix [A XPath Grammar]. The appendix is the normative version.

In the grammar productions in this document, named symbols are underlined and literal text is enclosed in double quotes. For example, the following production describes the syntax of a function call:

[48] FunctionCall ::= QName "(" (ExprSingle ("," ExprSingle)*)? ")"

The production should be read as follows: A function call consists of a QName followed by an open-parenthesis. The open-parenthesis is followed by an optional argument list. The argument list (if present) consists of one or more expressions, separated by commas. The optional argument list is followed by a close-parenthesis.

Certain aspects of language processing are described in this specification as implementation-defined orimplementation-dependent.

A language aspect described in this specification as implementation-defined or implementation dependentmay be further constrained by the specifications of a host language in which XPath is embedded.

This document normatively defines the dynamic semantics of XPath. The static semantics of XPath are normatively defined in[XQuery 1.0 and XPath 2.0 Formal Semantics]. In this document, examples and material labeled as "Note" are provided for explanatory purposes and are not normative.

2 Basics

The basic building block of XPath is the expression, which is a string of [Unicode] characters (the version of Unicode to be used is implementation-defined.) The language provides several kinds of expressions which may be constructed from keywords, symbols, and operands. In general, the operands of an expression are other expressions. XPath allows expressions to be nested with full generality.

Note:

This specification contains no assumptions or requirements regarding the character set encoding of strings of [Unicode] characters.

Like XML, XPath is a case-sensitive language. Keywords in XPath use lower-case characters and are not reserved—that is, names in XPath expressions are allowed to be the same as language keywords, except for certain unprefixed function-names listed in A.3 Reserved Function Names.

[Definition: In the data model, avalue is always a sequence.] [Definition: A sequence** is an ordered collection of zero or more items.] [Definition: An **item** is either an atomic value or anode.] [Definition: Anatomic value** is a value in the value space of an atomic type, as defined in [XML Schema].] [Definition: Anode is an instance of one of the node kinds defined in [XQuery/XPath Data Model (XDM)].] Each node has a unique node identity, a typed value, and astring value. In addition, some nodes have a name. The typed value of a node is a sequence of zero or more atomic values. The string value of a node is a value of typexs:string. The name of a node is a value of type xs:QName.

[Definition: A sequence containing exactly one item is called a singleton.] An item is identical to a singleton sequence containing that item. Sequences are never nested—for example, combining the values 1, (2, 3), and ( ) into a single sequence results in the sequence (1, 2, 3). [Definition: A sequence containing zero items is called an empty sequence.]

[Definition: The term **XDM instance** is used, synonymously with the term **value**, to denote an unconstrained sequence of nodes and/or atomic values in the data model.]

Names in XPath are called QNames, and conform to the syntax in [XML Names]. [Definition: Lexically, aQName consists of an optional namespace prefix and a local name. If the namespace prefix is present, it is separated from the local name by a colon.] A lexical QName can be converted into anexpanded QName by resolving its namespace prefix to a namespace URI, using the statically known namespaces[err:XPST0081]. [Definition: An expanded QNameconsists of an optional namespace URI and a local name. An expanded QName also retains its original namespace prefix (if any), to facilitate casting the expanded QName into a string.] The namespace URI value is whitespace normalized according to the rules for thexs:anyURI type in [XML Schema]. Two expanded QNames are equal if their namespace URIs are equal and their local names are equal (even if their namespace prefixes are not equal). Namespace URIs and local names are compared on a codepoint basis, without further normalization.

This document uses the following namespace prefixes to represent the namespace URIs with which they are listed. Use of these namespace prefix bindings in this document is not normative.

Element nodes have a property called in-scope namespaces. [Definition: The in-scope namespaces property of an element node is a set of namespace bindings, each of which associates a namespace prefix with a URI, thus defining the set of namespace prefixes that are available for interpreting QNames within the scope of the element. For a given element, one namespace binding may have an empty prefix; the URI of this namespace binding is the default namespace within the scope of the element.]

In [XPath 1.0], the in-scope namespaces of an element node are represented by a collection ofnamespace nodes arranged on a namespace axis. In XPath Version 2.0, the namespace axis is deprecated and need not be supported by a host language. A host language that does not support the namespace axis need not represent namespace bindings in the form of nodes.

[Definition: Within this specification, the term URI refers to a Universal Resource Identifier as defined in [RFC3986]and extended in [RFC3987] with the new nameIRI.] The term URI has been retained in preference to IRI to avoid introducing new names for concepts such as "Base URI" that are defined or referenced across the whole family of XML specifications.

2.1 Expression Context

[Definition: The expression context for a given expression consists of all the information that can affect the result of the expression.] This information is organized into two categories called the static context and the dynamic context.

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

The individual components of the static context are summarized below.A default initial value for each component may be specified by the host language. The scope of each component is specified in C.1 Static Context Components.

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

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 items are being processed by the expression.

Certain language constructs, notably the path expression E1/E2 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 timeE2 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 evaluatingE1 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.

2.2 Processing Model

XPath is defined in terms of the data model and the expression context.

Processing Model Overview

Figure 1: Processing Model Overview

Figure 1 provides a schematic overview of the processing steps that are discussed in detail below. Some of these steps are completely outside the domain of XPath; in Figure 1, these are depicted outside the line that represents the boundaries of the language, an area labeled external processing. The external processing domain includes generation of an XDM instance that represents the data to be queried (see 2.2.1 Data Model Generation), schema import processing (see 2.2.2 Schema Import Processing) and serialization (see 2.2.4 Serialization). The area inside the boundaries of the language is known as the XPath processing domain, which includes the static analysis and dynamic evaluation phases (see 2.2.3 Expression Processing). Consistency constraints on the XPath processing domain are defined in 2.2.5 Consistency Constraints.

2.2.1 Data Model Generation

Before an expression can be processed, its input data must be represented as an XDM instance. This process occurs outside the domain of XPath, 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 anXML 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 an XDM instance by a process described in [XQuery/XPath Data Model (XDM)]. (See DM2 in Fig. 1.)

The above steps provide an example of how an XDM instancemight 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.) XPath 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 (referred to in [XQuery/XPath Data Model (XDM)] as its type-name property.) The type annotation of a node is a schema type that describes the relationship between the string value of the node and its typed value.] If the XDM instance was derived from a validated XML document as described in Section 3.3 Construction from a PSVIDM, the type annotations of the element and attribute nodes are derived from schema validation. XPath 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 asxs: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 are provided by the host language (see step SI1 in Figure 1) and must satisfy the consistency constraints defined in 2.2.5 Consistency Constraints.

2.2.3 Expression Processing

XPath 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.3.1 Static Analysis Phase

[Definition: The static analysis phase** depends on the expression itself and on the static context. Thestatic analysis phase** does not depend on input data (other than schemas).]

During the static analysis phase, the XPath expression is parsed into an internal representation called the operation tree (step SQ1 in Figure 1). A parse error is raised as astatic error[err:XPST0003]. Thestatic context is initialized by the implementation (step SQ2). Thestatic context is used to resolve schema type names, function names, namespace prefixes, and variable names (step SQ4). If a name of one of these kinds in the operation tree is not found in thestatic context, a static error ([err:XPST0008] or [err:XPST0017]) is raised (however, see exceptions to this rule in 2.5.4.3 Element Test and 2.5.4.5 Attribute Test.)

The operation tree is then normalized by making explicit the implicit operations such as atomization and extraction of Effective Boolean Values (step SQ5). The normalization process is described in[XQuery 1.0 and XPath 2.0 Formal Semantics].

Each expression is then assigned a static type (step SQ6). [Definition: The static type of an expression is a type such that, when the expression is evaluated, the resulting value will always conform to the static type.] If theStatic Typing Feature is supported, the static types of various expressions are inferred according to the rules described in [XQuery 1.0 and XPath 2.0 Formal Semantics]. If the Static Typing Feature is not supported, the static types that are assigned are implementation-dependent.

During the static analysis phase, if the Static Typing Feature is in effect and an operand of an expression is found to have a static type that is not appropriate for that operand, a type error is raised [err:XPTY0004]. If static type checking raises no errors and assigns a static type T to an expression, then execution of the expression on valid input data is guaranteed either to produce a value of type T or to raise a dynamic error.

The purpose of the Static Typing Feature is to provide early detection of type errors and to infer type information that may be useful in optimizing the evaluation of an expression.

2.2.3.2 Dynamic Evaluation Phase

[Definition: The dynamic evaluation phase is the phase during which the value of an expression is computed.] It occurs after completion of thestatic analysis phase.

The dynamic evaluation phase can occur only if no errors were detected during the static analysis phase. If the Static Typing Feature is in effect, all type errors are detected during static analysis and serve to inhibit the dynamic evaluation phase.

The dynamic evaluation phase depends on the operation tree of the expression being evaluated (step DQ1), on the input data (step DQ4), and on the dynamic context (step DQ5), which in turn draws information from the external environment (step DQ3) and thestatic context (step DQ2). The dynamic evaluation phase may create new data-model values (step DQ4) and it may extend the dynamic context(step DQ5)—for example, by binding values to variables.

[Definition: A **dynamic type** is associated with each value as it is computed. The dynamic type of a value may be more specific than the static type of the expression that computed it (for example, the static type of an expression might bexs:integer*, denoting a sequence of zero or more integers, but at evaluation time its value may have the dynamic type xs:integer, denoting exactly one integer.)]

If an operand of an expression is found to have a dynamic type that is not appropriate for that operand, a type error is raised [err:XPTY0004].

Even though static typing can catch many type errors before an expression is executed, it is possible for an expression to raise an error during evaluation that was not detected by static analysis. For example, an expression may contain a cast of a string into an integer, which is statically valid. However, if the actual value of the string at run time cannot be cast into an integer, a dynamic error will result. Similarly, an expression may apply an arithmetic operator to a value whosestatic type isxs:untypedAtomic. This is not a static error, but at run time, if the value cannot be successfully cast to a numeric type, a dynamic error will be raised.

When the Static Typing Feature is in effect, it is also possible for static analysis of an expression to raise a type error, even though execution of the expression on certain inputs would be successful. For example, an expression might contain a function that requires an element as its parameter, and the static analysis phase might infer the static type of the function parameter to be an optional element. This case is treated as a type error and inhibits evaluation, even though the function call would have been successful for input data in which the optional element is present.

2.2.4 Serialization

[Definition: **Serialization** is the process of converting an XDM instance into a sequence of octets (step DM4 in Figure 1.) ] The general framework for serialization is described in [XSLT 2.0 and XQuery 1.0 Serialization].

The host language may provide a serialization option.

2.2.5 Consistency Constraints

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

Some of the consistency constraints use the term data model schema. [Definition: For a given node in anXDM instance, 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 schema type definition that is represented by thetype annotation of the node.

2.3 Error Handling

2.3.1 Kinds of Errors

As described in 2.2.3 Expression Processing, XPath 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: A **static error** is an error that must be detected during the static analysis phase. A syntax error is an example of a static error.]

[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, atype 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 () ordata(()) 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 an expression, if evaluated, would necessarily raise a type error or adynamic error, the implementation may (but is not required to) report that error during the static analysis phase. However, thefn:error() function must not be evaluated during thestatic analysis phase.

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

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

2.3.2 Identifying and Reporting Errors

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

Note:

The namespace URI for XPath and XQuery errors is not expected to change from one version of XPath to another. However, the contents of this namespace may be extended to include additional error definitions.

The method by which an XPath 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 LPcan be represented as the URI referenceNS# LP. For example, an error whose QName is err:XPST0017 could be represented ashttp://www.w3.org/2005/xqt-errors#XPST0017.

Note:

Along with a code identifying an error, implementations may wish to return additional information, such as the location of the error or the processing phase in which it was detected. If an implementation chooses to do so, then the mechanism that it uses to return this information is implementation-defined.

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 adynamic 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 expressionexpr1 and expr2 may return the valuefalse 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(y) + xs:decimal(y)+xs:decimal(z)

both the sub-expressions ($x div <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>y</mi><mo stretchy="false">)</mo><mi mathvariant="normal">‘</mi><mi>a</mi><mi>n</mi><mi>d</mi><mi mathvariant="normal">‘</mi><mi>x</mi><mi>s</mi><mo>:</mo><mi>d</mi><mi>e</mi><mi>c</mi><mi>i</mi><mi>m</mi><mi>a</mi><mi>l</mi><mo stretchy="false">(</mo></mrow><annotation encoding="application/x-tex">y) andxs:decimal(</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal" style="margin-right:0.03588em;">y</span><span class="mclose">)</span><span class="mord">‘</span><span class="mord mathnormal">an</span><span class="mord mathnormal">d</span><span class="mord">‘</span><span class="mord mathnormal">x</span><span class="mord mathnormal">s</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">:</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal">d</span><span class="mord mathnormal">ec</span><span class="mord mathnormal">ima</span><span class="mord mathnormal" style="margin-right:0.01968em;">l</span><span class="mopen">(</span></span></span></span>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.

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

A dynamic error can also be raised explicitly by calling thefn: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]. 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 the detection and reporting of dynamic errors are implementation-dependent, as described in this section.

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

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

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

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

There is an exception to this rule: 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 returntrue as the result of the expression S1 = S2 as soon as it finds a pair of equal values from the two sequences.

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

Examples:

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

2.4 Concepts

This section explains some concepts that are important to the processing of XPath expressions.

2.4.1 Document Order

An ordering called document order is defined among all the nodes accessible during processing of a given expression, which may consist of one or more trees (documents or fragments). Document order is defined in [XQuery/XPath Data Model (XDM)], and its definition is repeated here for convenience. [Definition: The node ordering that is the reverse of document order is called reverse document order.]

Document order is a total ordering, although the relative order of some nodes is implementation-dependent. [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 expression, 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. Every node occurs before all of its children and descendants.
  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 theelement node with which they are associated. The relative order of attribute nodes is stable but implementation-dependent.
  5. The relative order of siblings is the order in which they occur in the children property of their parent node.
  6. Children and descendants occur before following siblings.

The relative order of nodes in distinct trees is stable butimplementation-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 XPath operators depend on a process calledatomization. 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 atype error[err:FOTY0012]. [Definition: Atomization of a sequence is defined as the result of invoking the fn:datafunction 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:

Atomization is used in processing the following types of 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 1.0 and XPath 2.0 Functions and Operators].]

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

  1. If its operand is an empty sequence, fn:booleanreturns 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:booleanor derived from xs:boolean, fn:booleanreturns 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 returnsfalse 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:

Note:

The definition of effective boolean value is not used when casting a value to the type xs:boolean, for example in a cast expression or when passing a value to a function whose expected parameter is of typexs:boolean.

2.4.4 Input Sources

XPath 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 data either by calling one of the input functions or by referencing some part of the dynamic contextthat is initialized by the external environment, such as avariableor context item.

The input functions supported by XPath are as follows:

2.5 Types

The type system of XPath is based on [XML Schema], and is formally defined in [XQuery 1.0 and XPath 2.0 Formal Semantics].

[Definition: A **sequence type** is a type that can be expressed using the SequenceType syntax. Sequence types are used whenever it is necessary to refer to a type in an XPath expression. The term sequence type suggests that this syntax is used to describe the type of an XPath value, which is always a sequence.]

[Definition: A schema type is a type that is (or could be) defined using the facilities of [XML Schema] (including the built-in types of[XML Schema]).] A schema type can be used as a type annotation on an element or attribute node (unless it is a non-instantiable type such as xs:NOTATION orxs:anyAtomicType, in which case its derived types can be so used). Every schema type is either a complex type or asimple type; simple types are further subdivided intolist types, union types, and atomic types (see[XML Schema] for definitions and explanations of these terms.)

Atomic types represent the intersection between the categories of sequence type and schema type. An atomic type, such as xs:integer ormy:hatsize, is both a sequence type and a schema type.

2.5.1 Predefined Schema Types

The in-scope schema types in the static context are initialized with a set of predefined schema types that is determined by the host language. This set may include some or all of the schema types in the namespacehttp://www.w3.org/2001/XMLSchema, represented in this document by the namespace prefix xs. The schema types in this namespace are defined in [XML Schema] and augmented by additional types defined in [XQuery/XPath Data Model (XDM)]. The schema types defined in [XQuery/XPath Data Model (XDM)]are summarized below.

  1. [Definition: xs:untyped is used as thetype 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 fromxs:duration. The lexical representation ofxs:dayTimeDuration is restricted to contain only day, hour, minute, and second components.]
  4. [Definition:xs:yearMonthDuration is derived by restriction fromxs:duration. The lexical representation ofxs: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:anySimpleTypefrom which all simple types, including atomic, list, and union types, are derived. All primitive atomic types, such asxs:integer, xs:string, andxs:untypedAtomic, have xs:anyAtomicTypeas their base type.]
    Note:
    xs:anyAtomicType will not appear as the type of an actual value in an XDM instance.

The relationships among the schema types in the xsnamespace are illustrated in Figure 2. A more complete description of the XPath type hierarchy can be found in [XQuery 1.0 and XPath 2.0 Functions and Operators].

Type Hierarchy Diagram

Figure 2: Hierarchy of Schema Types used in XPath

2.5.2 Typed Value and String Value

Every node has a typed value and a string value. [Definition: The typed value of a node is a sequence of atomic values and can be extracted by applying thefn:data function to the node.] [Definition: The string value of a node is a string and can be extracted by applying thefn:string function to the node.] Definitions offn:data and fn:string can be found in[XQuery 1.0 and XPath 2.0 Functions and Operators].

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 thexs: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. If the node was created by mapping from an Infoset or PSVI, the relationships among these properties are defined by rules in [XQuery/XPath Data Model (XDM)].

As a convenience to the reader, the relationship betweentyped value andstring valuefor 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 typexs: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, namespace, or processing instruction node is the same as its string value. It is an instance of the typexs: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 ofxs: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] 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 annotationxs: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 atomic type from which it is derived (such asxs: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 orxs: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 ofxs:untypedAtomic. However, if the nilledproperty of the node is true, then its typed value is the empty sequence.
      Example: E1 is an element node having type annotationxs: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 annotationformula, 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 ofxs: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 thenilled property of the node is true, then its typed value is the empty sequence.
      Example: E3 is an element node with the type annotationcost, 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 ofxs:decimal.
      Example: E4 is an element node with the type annotationhatsizelist, which is a simple type derived from the atomic type hatsize, which in turn is derived fromxs: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 typehatsize.
      Example: E5 is an element node with the type annotationmy: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 is47 as an xs:integer, sincexs: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 undefined. Thefn: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 annotationweather, 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 undefined, and the fn:datafunction applied to E6 raises an error.

2.5.3 SequenceType Syntax

Whenever it is necessary to refer to a type in an XPath expression, the SequenceTypesyntax is used.

[50] SequenceType ::= ("empty-sequence" "(" ")")| (ItemType OccurrenceIndicator?)
[52] ItemType ::= KindTest | ("item" "(" ")") AtomicType
[51] OccurrenceIndicator ::= "?" | "*" "+"
[53] AtomicType ::= QName
[54] KindTest ::= DocumentTest| ElementTest AttributeTest
[56] DocumentTest ::= "document-node" "(" (ElementTest | SchemaElementTest)? ")"
[64] ElementTest ::= "element" "(" (ElementNameOrWildcard (","TypeName "?"?)?)? ")"
[66] SchemaElementTest ::= "schema-element" "(" ElementDeclaration")"
[67] ElementDeclaration ::= ElementName
[60] AttributeTest ::= "attribute" "(" (AttribNameOrWildcard (","TypeName)?)? ")"
[62] SchemaAttributeTest ::= "schema-attribute" "(" AttributeDeclaration")"
[63] AttributeDeclaration ::= AttributeName
[65] ElementNameOrWildcard ::= ElementName | "*"
[69] ElementName ::= QName
[61] AttribNameOrWildcard ::= AttributeName | "*"
[68] AttributeName ::= QName
[70] TypeName ::= QName
[59] PITest ::= "processing-instruction" "(" (NCName | StringLiteral)? ")"
[58] CommentTest ::= "comment" "(" ")"
[57] TextTest ::= "text" "(" ")"
[55] AnyKindTest ::= "node" "(" ")"

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

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

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

2.5.4 SequenceType Matching

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

QNames appearing in a sequence type have their prefixes expanded to namespace URIs by means of the statically known namespaces and (where applicable) the default element/type namespace. An unprefixed attribute QName is in no namespace. Equality of QNames is defined by the eq operator.

The rules for SequenceType matching compare thedynamic type of a value with an expected sequence type. These rules are a subset of the formal rules that match a value with an expected type defined in [XQuery 1.0 and XPath 2.0 Formal Semantics], because the Formal Semantics must be able to match values against types that are not expressible using theSequenceType syntax.

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

[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 atype error[err:XPTY0004]. The pseudo-function derives-from is defined below and is defined formally in [XQuery 1.0 and XPath 2.0 Formal Semantics].

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.4.1 Matching a SequenceType and a Value

An OccurrenceIndicator specifies the number of items in a sequence, as follows:

As a consequence of these rules, any sequence type whose OccurrenceIndicator is* or ? matches a value that is an empty sequence.

2.5.4.2 Matching an ItemType and an Item
2.5.4.3 Element Test

An ElementTest is used to match an element node by its name and/or type annotation. An ElementTest may take any of the following forms. In these forms, ElementName need not be present in thein-scope element declarations, but TypeName must be present in the in-scope schema types [err:XPST0008]. Note that substitution groups do not affect the semantics of ElementTest.

  1. element() and element(*) match any single element node, regardless of its name or type annotation.
  2. element(ElementName) matches any element node whose name is ElementName, regardless of its type annotation or nilled property.
    Example: element(person) matches any element node whose name is person.
  3. element(ElementName, TypeName) matches an element node whose name is ElementNameif derives-from(AT, TypeName ) istrue, where AT is the type annotation of the element node, and the nilled property of the node isfalse.
    Example: element(person, surgeon) matches a non-nilled element node whose name is person and whose type annotation is surgeon (or is derived fromsurgeon).
  4. element(ElementName, TypeName ?) matches an element node whose name is ElementName ifderives-from(AT, TypeName) istrue, where AT is the type annotation of the element node. The nilled property of the node may be either true or false.
    Example: element(person, surgeon?) matches a nilled or non-nilled element node whose name is person and whose type annotation is surgeon (or is derived fromsurgeon).
  5. element(*, TypeName) matches an element node regardless of its name, ifderives-from(AT, TypeName ) istrue, where AT is the type annotation of the element node, and the nilled property of the node isfalse.
    Example: element(*, surgeon) matches any non-nilled element node whose type annotation is surgeon (or is derived from surgeon), regardless of its name.
  6. element(*, TypeName ?) matches an element node regardless of its name, ifderives-from(AT, TypeName ) istrue, where AT is the type annotation of the element node. The nilled property of the node may be either true or false.
    Example: element(*, surgeon?) matches any nilled or non-nilled element node whose type annotation issurgeon (or is derived from surgeon), regardless of its name.
2.5.4.4 Schema Element Test

A SchemaElementTestmatches an element node against a corresponding element declaration found in the in-scope element declarations. It takes the following form:

schema-element(ElementName)

If the ElementNamespecified in the SchemaElementTest is not found in the in-scope element declarations, a static error is raised [err:XPST0008].

A SchemaElementTestmatches a candidate element node if all three of the following conditions are satisfied:

  1. The name of the candidate node matches the specified ElementName or matches the name of an element in a substitution group headed by an element named ElementName.
  2. derives-from(AT, ET) istrue, where AT is the type annotation of the candidate node and ET is the schema type declared for element ElementName in thein-scope element declarations.
  3. If the element declaration for ElementName in the in-scope element declarations is not nillable, then thenilled property of the candidate node isfalse.

Example: The SchemaElementTest schema-element(customer) matches a candidate element node if customer is a top-level element declaration in the in-scope element declarations, the name of the candidate node is customer or is in a substitution group headed by customer, the type annotation of the candidate node is the same as or derived from the schema type declared for the customer element, and either the candidate node is not nilled or customeris declared to be nillable.

2.5.4.5 Attribute Test

An AttributeTest is used to match an attribute node by its name and/or type annotation. An AttributeTest any take any of the following forms. In these forms, AttributeName need not be present in the in-scope attribute declarations, but TypeName must be present in the in-scope schema types [err:XPST0008].

  1. attribute() and attribute(*) match any single attribute node, regardless of its name or type annotation.
  2. attribute(AttributeName) matches any attribute node whose name is AttributeName, regardless of its type annotation.
    Example: attribute(price) matches any attribute node whose name is price.
  3. attribute(AttributeName, TypeName) matches an attribute node whose name is AttributeName ifderives-from(AT, TypeName ) istrue, where AT is the type annotation of the attribute node.
    Example: attribute(price, currency) matches an attribute node whose name is price and whose type annotation is currency (or is derived fromcurrency).
  4. attribute(*, TypeName) matches an attribute node regardless of its name, ifderives-from(AT, TypeName) istrue, where AT is the type annotation of the attribute node.
    Example: attribute(*, currency) matches any attribute node whose type annotation is currency (or is derived from currency), regardless of its name.
2.5.4.6 Schema Attribute Test

A SchemaAttributeTest matches an attribute node against a corresponding attribute declaration found in the in-scope attribute declarations. It takes the following form:

schema-attribute(AttributeName)

If the AttributeNamespecified in the SchemaAttributeTest is not found in the in-scope attribute declarations, a static error is raised [err:XPST0008].

A SchemaAttributeTest matches a candidate attribute node if both of the following conditions are satisfied:

  1. The name of the candidate node matches the specified AttributeName.
  2. derives-from(AT, ET) istrue, where AT is the type annotation of the candidate node and ET is the schema type declared for attribute AttributeName in the in-scope attribute declarations.

Example: The SchemaAttributeTest schema-attribute(color) matches a candidate attribute node if color is a top-level attribute declaration in the in-scope attribute declarations, the name of the candidate node is color, and the type annotation of the candidate node is the same as or derived from the schema type declared for the color attribute.

2.6 Comments

[77] Comment ::= "(:" (CommentContents | Comment)* ":)"
[82] CommentContents ::= (Char+ - (Char* ('(:' | ':)') Char*))

Comments may be used to provide informative annotation foran expression. Comments are lexical constructs only, and do not affect expression processing.

Comments are strings, delimited by the symbols (:and :). Comments may be nested.

A comment may be used anywhere ignorable whitespace is allowed (see A.2.4.1 Default Whitespace Handling).

The following is an example of a comment:

(: Houston, we have a problem :)

3 Expressions

This section discusses each of the basic kinds of expression. Each kind of expression has a name such as PathExpr, which is introduced on the left side of the grammar production that defines the expression. Since XPath is a composable language, each kind of expression is defined in terms of other expressions whose operators have a higher precedence. In this way, the precedence of operators is represented explicitly in the grammar.

The order in which expressions are discussed in this document does not reflect the order of operator precedence. In general, this document introduces the simplest kinds of expressions first, followed by more complex expressions. For the complete grammar, see Appendix [A XPath Grammar].

The highest-level symbol in the XPath grammar is XPath.

[1] XPath ::= Expr
[2] Expr ::= ExprSingle (","ExprSingle)*
[3] ExprSingle ::= ForExpr| QuantifiedExpr

The XPath operator that has lowest precedence is the comma operator, which is used to combine two operands to form a sequence. As shown in the grammar, a general expression (Expr) can consist of multiple ExprSingle operands, separated by commas. The name ExprSingledenotes an expression that does not contain a top-level comma operator(despite its name, an ExprSingle may evaluate to a sequence containing more than one item.)

The symbol ExprSingle is used in various places in the grammar where an expression is not allowed to contain a top-level comma. For example, each of the arguments of a function call must be an ExprSingle, because commas are used to separate the arguments of a function call.

After the comma, the expressions that have next lowest precedence are ForExpr, QuantifiedExpr, IfExpr, and OrExpr. Each of these expressions is described in a separate section of this document.

3.1 Primary Expressions

[Definition: Primary expressionsare the basic primitives of the language. They include literals, variable references, context item expressions, and function calls. A primary expression may also be created by enclosing any expression in parentheses, which is sometimes helpful in controlling the precedence of operators.]

[41] PrimaryExpr ::= Literal | VarRef ParenthesizedExpr ContextItemExpr FunctionCall

3.1.1 Literals

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

[42] Literal ::= NumericLiteral |StringLiteral
[43] NumericLiteral ::= IntegerLiteral |DecimalLiteral DoubleLiteral
[71] IntegerLiteral ::= Digits
[72] DecimalLiteral ::= ("." Digits) | (Digits "." [0-9]*)
[73] DoubleLiteral ::= (("." Digits) | (Digits ("." [0-9]*)?)) [eE] [+-]? Digits
[74] StringLiteral ::= ('"' (EscapeQuot | [^"])* '"') ("'" (EscapeApos
[75] EscapeQuot ::= '""'
[76] EscapeApos ::= "''"
[81] Digits ::= [0-9]+

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 eor E character is an atomic value of typexs: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 17.1.1 Casting from xs:string and xs:untypedAtomicFO.

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:

The xs:boolean values true andfalse 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 theconstructor function for the given type. The constructor functions 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:

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

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

3.1.2 Variable References

[44] VarRef ::= "$" VarName
[45] VarName ::= QName

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

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

  1. The in-scope variables may be augmented byimplementation-definedvariables.
  2. A variable may be bound by an XPath expression. The kinds of expressions that can bind variables are for expressions (3.7 For Expressions) and quantified expressions (3.9 Quantified Expressions).

Every variable binding has a static scope. The scope defines where references to the variable can validly occur. It is astatic 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.

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

3.1.3 Parenthesized Expressions

[46] ParenthesizedExpr ::= "(" Expr? ")"

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

[47] ContextItemExpr ::= "."

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

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

3.1.5 Function Calls

[Definition: The built-in functions supported by XPath are defined in [XQuery 1.0 and XPath 2.0 Functions and Operators].] Additional functions may be provided in the static context. XPath per se does not provide a way to declare functions, but a host language may provide such a mechanism.

[48] FunctionCall ::= QName "(" (ExprSingle ("," ExprSingle)*)? ")"

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

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

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. The function is evaluated using the converted argument values. The result is either an instance of the function's declared return type or a dynamic error. The dynamic type of a function result may be a type that is derived from the declared return type. Errors raised by functions are defined in [XQuery 1.0 and XPath 2.0 Functions and Operators].

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

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

3.2 Path Expressions

| [25] | PathExpr | ::= | ("/" RelativePathExpr?)| ("//" RelativePathExpr)| RelativePathExpr | | ------ | ------------------------------------------------ | --- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------- | | [26] | RelativePathExpr | ::= | StepExpr (("/" | "//")StepExpr)* |

[Definition: A **path expression** can be used to locate nodes within trees. A path expression consists of a series of one or more steps, separated by "/" or "//", and optionally beginning with "/" or "//".] An initial "/" or "//" is an abbreviation for one or more initial steps that are implicitly added to the beginning of the path expression, as described below.

A path expression consisting of a single step is evaluated as described in 3.2.1 Steps.

A "/" at the beginning of a path expression is an abbreviation for the initial step fn:root(self::node()) treat as document-node()/ (however, if the "/" is the entire path expression, the trailing "/" is omitted from the expansion.) The effect of this initial step is to begin the path at the root node of the tree that contains the context node. If the context item is not a node, a type error is raised [err:XPTY0020]. At evaluation time, if the root node above the context node is not a document node, a dynamic error is raised [err:XPDY0050].

A "//" at the beginning of a path expression is an abbreviation for the initial steps fn:root(self::node()) treat as document-node()/descendant-or-self::node()/(however, "//" by itself is not a valid path expression [err:XPST0003].) The effect of these initial steps is to establish an initial node sequence that contains the root of the tree in which the context node is found, plus all nodes descended from this root. This node sequence is used as the input to subsequent steps in the path expression. If the context item is not a node, a type error is raised [err:XPTY0020]. At evaluation time, if the root node above the context node is not a document node, a dynamic error is raised [err:XPDY0050].

Note:

The descendants of a node do not include attribute nodesor namespace nodes.

Each non-initial occurrence of "//" in a path expression is expanded as described in 3.2.4 Abbreviated Syntax, leaving a sequence of steps separated by "/". This sequence of steps is then evaluated from left to right. Each operation E1/E2 is evaluated as follows: Expression E1 is evaluated, and if the result is not a (possibly empty) sequence of nodes, a type error is raised [err:XPTY0019]. Each node resulting from the evaluation of E1 then serves in turn to provide an inner focus for an evaluation of E2, as described in 2.1.2 Dynamic Context. The sequences resulting from all the evaluations of E2 are combined as follows:

  1. If every evaluation of E2 returns a (possibly empty) sequence of nodes, these sequences are combined, and duplicate nodes are eliminated based on node identity. The resulting node sequence is returned in document order.
  2. If every evaluation of E2 returns a (possibly empty) sequence of atomic values, these sequences are concatenated, in order, and returned.
  3. If the multiple evaluations of E2 return at least one node and at least one atomic value, a type error is raised [err:XPTY0018].

Note:

Since each step in a path provides context nodes for the following step, in effect, only the last step in a path is allowed to return a sequence of atomic values.

As an example of a path expression,child::div1/child::para selects the paraelement children of the div1 element children of the context node, or, in other words, the para element grandchildren of the context node that have div1parents.

Note:

The "/" character can be used either as a complete path expression or as the beginning of a longer path expression such as "/*". Also, "*" is both the multiply operator and a wildcard in path expressions. This can cause parsing difficulties when "/" appears on the left hand side of "*". This is resolved using the leading-lone-slash constraint. For example, "/*" and "/ *" are valid path expressions containing wildcards, but "/*5" and "/ * 5" raise syntax errors. Parentheses must be used when "/" is used on the left hand side of an operator, as in "(/) * 5". Similarly, "4 + / * 5" raises a syntax error, but "4 + (/) * 5" is a valid expression. The expression "4 + /" is also valid, because / does not occur on the left hand side of the operator.

3.2.1 Steps

[27] StepExpr ::= FilterExpr | AxisStep
[28] AxisStep ::= (ReverseStep |ForwardStep) PredicateList
[29] ForwardStep ::= (ForwardAxis NodeTest) | AbbrevForwardStep
[32] ReverseStep ::= (ReverseAxis NodeTest) | AbbrevReverseStep
[39] PredicateList ::= Predicate*

[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 filter expression.] Filter expressions are described in 3.3.2 Filter 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]. The resulting node sequence is returned in document order. An axis step may be either a forward step or a reverse step, followed by zero or morepredicates.

In the abbreviated syntax for a step, the axis can be omitted and other shorthand notations can be used as described in3.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 annotationspecified by the node test. For example, the stepchild::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.1.1 Axes

| [30] | ForwardAxis | ::= | ("child" "::")| ("descendant" "::")| ("attribute" "::")| ("self" "::")| ("descendant-or-self" "::")| ("following-sibling" "::")| ("following" "::")| ("namespace" "::") | | ------ | -------------------------------------- | --- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | [33] | ReverseAxis | ::= | ("parent" "::")| ("ancestor" "::")| ("preceding-sibling" "::")| ("preceding" "::")| ("ancestor-or-self" "::") |

XPath defines a full set of axes for traversing documents, but a host language may define a subset of these axes. The following axes are defined:

Axes can be categorized as forward axes and reverse axes. An axis that only ever contains the context node or nodes that are after the context node in document order is a forward axis. An axis that only ever contains the context node or nodes that are before the context node in document order is a reverse axis.

The parent, ancestor,ancestor-or-self, preceding, andpreceding-sibling axes are reverse axes; all other axes are forward axes. The ancestor,descendant, following,preceding and self axes partition a document (ignoring attribute and namespace nodes): they do not overlap and together they contain all the nodes in the document.

[Definition: Every axis has aprincipal node kind. If an axis can contain elements, then the principal node kind is element; otherwise, it is the kind of nodes that the axis can contain.] Thus:

3.2.1.2 Node Tests

[Definition: A **node test** is a condition that must be true for each node selected by a step.] The condition may be based on the kind of the node (element, attribute, text, document, comment, or processing instruction), the name of the node, or (in the case of element, attribute, and document nodes), the type annotation of the node.

[35] NodeTest ::= KindTest | NameTest
[36] NameTest ::= QName | Wildcard
[37] Wildcard ::= "*"| (NCName ":" "*")

[Definition: A node test that consists only of a QName or a Wildcard is called a name test.] A name test is true if and only if the kind of the node is the principal node kind for the step axis and the expanded QName of the node is equal (as defined by the eq operator) to the expanded QNamespecified by the name test. For example, child::paraselects the para element children of the context node; if the context node has no para children, it selects an empty set of nodes. attribute:🔤href selects the attribute of the context node with the QName abc:href; if the context node has no such attribute, it selects an empty set of nodes.

A QName in a name test is resolved into an expanded QName using the statically known namespaces in the expression context. It is a static error [err:XPST0081] if the QName has a prefix that does not correspond to any statically known namespace. An unprefixed QName, when used as a name test on an axis whoseprincipal node kind is element, has the namespace URI of the default element/type namespace in the expression context; otherwise, it has no namespace URI.

A name test is not satisfied by an element node whose name does not match the expanded QName of the name test, even if it is in a substitution group whose head is the named element.

A node test * is true for any node of the principal node kind of the step axis. For example, child::* will select all element children of the context node, andattribute::* will select all attributes of the context node.

A node test can have the form NCName:*. In this case, the prefix is expanded in the same way as with a QName, using the statically known namespaces in thestatic context. If the prefix is not found in the statically known namespaces, a static error is raised [err:XPST0081]. The node test is true for any node of the principal node kind of the step axis whose expanded QName has the namespace URI to which the prefix is bound, regardless of the local part of the name.

A node test can also have the form *:NCName. In this case, the node test is true for any node of the principal node kind of the step axis whose local name matches the given NCName, regardless of its namespace or lack of a namespace.

[Definition: An alternative form of a node test called a **kind test** can select nodes based on their kind, name, and type annotation.] The syntax and semantics of a kind test are described in 2.5.3 SequenceType Syntax and2.5.4 SequenceType Matching. When a kind test is used in a node test, only those nodes on the designated axis that match the kind test are selected. Shown below are several examples of kind tests that might be used in path expressions:

3.2.2 Predicates

[40] Predicate ::= "[" Expr "]"

[Definition: 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.] In the case of multiple adjacent predicates, the predicates are applied from left to right, and the result of applying each predicate serves as the input sequence for the following predicate.

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

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 isfalse 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 anumeric 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.]
  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:

Note:

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

The fact that a reverse-axis step assigns context positions in reverse document order for the purpose of evaluating predicates does not alter the fact that the final result of the step is always in document order.

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 anabbreviated syntax, as explained in 3.2.4 Abbreviated Syntax.

3.2.4 Abbreviated Syntax

[31] AbbrevForwardStep ::= "@"? NodeTest
[34] AbbrevReverseStep ::= ".."

The abbreviated syntax permits the following abbreviations:

  1. The attribute axis attribute:: can be abbreviated by @. For example, a path expressionpara[@type="warning"] is short forchild::para[attribute::type="warning"] and so selectspara children with a type attribute with value equal to warning.
  2. If the axis name is omitted from an axis step, the default axis ischild unless the axis step contains an AttributeTest or SchemaAttributeTest; in that case, the default axis is attribute. For example, the path expression section/para is an abbreviation forchild::section/child::para, and the path expressionsection/@id is an abbreviation forchild::section/attribute::id. Similarly,section/attribute(id) is an abbreviation forchild::section/attribute::attribute(id). Note that the latter expression contains both an axis specification and anode 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 forchild::div1/descendant-or-self::node()/child::para and so will select all para descendants ofdiv1 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 firstpara children of their respective parents.
  4. A step consisting of .. is short forparent::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:

3.3 Sequence Expressions

XPath supports operators to construct, filter, and combinesequences of items. Sequences are never nested—for example, combining the values 1, (2, 3), and ( ) into a single sequence results in the sequence(1, 2, 3).

3.3.1 Constructing Sequences

[2] Expr ::= ExprSingle (","ExprSingle)*
[11] RangeExpr ::= AdditiveExpr ( "to"AdditiveExpr )?

[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 atomic values or nodes, but a sequence is never an item in another sequence. When a new sequence is created by concatenating two or more input sequences, the new sequence contains all the items of the input sequences and its length is the sum of the lengths of the input sequences.

Note:

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.

Here are some examples of expressions that construct sequences:

A range expression can be used to construct a sequence of consecutive integers. Each of the operands of the tooperator 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.

3.3.2 Filter Expressions

[38] FilterExpr ::= PrimaryExpr PredicateList
[39] PredicateList ::= Predicate*

[Definition: A **filter expression**consists simply of a **primary expression** followed by zero or more predicates. The result of the filter expression consists of the items returned by the primary expression, filtered by applying each predicate in turn, working from left to right.] If no predicates are specified, the result is simply the result of the primary expression. The ordering of the items returned by a filter expression is the same as their order in the result of the primary expression. Context positions are assigned to items based on their ordinal position in the result sequence. The first context position is 1.

Here are some examples of filter expressions:

3.3.3 Combining Node Sequences

| [14] | UnionExpr | ::= | IntersectExceptExpr ( ("union" | "|") IntersectExceptExpr)* | | ------ | ------------------------------------------------------ | --- | --------------------------------------------------------------------------------------------------------------------------------- | | [15] | IntersectExceptExpr | ::= | InstanceofExpr ( ("intersect" | "except") InstanceofExpr )* |

XPath provides the following operators for combining sequences of nodes:

All these operators eliminate duplicate nodes from their result sequences based on node identity. The resulting sequence is returned in document order.

If an operand of union, intersect, orexcept contains an item that is not a node, atype error is raised [err:XPTY0004].

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

Then:

In addition to the sequence operators described here, [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 items from a sequence.

3.4 Arithmetic Expressions

XPath provides arithmetic operators for addition, subtraction, multiplication, division, and modulus, in their usual binary and unary forms.

[12] AdditiveExpr ::= MultiplicativeExpr ( ("+" | "-") MultiplicativeExpr)*
[13] MultiplicativeExpr ::= UnionExpr ( ("*" | "div" "idiv" "mod") UnionExpr )*
[20] UnaryExpr ::= ("-" | "+")* ValueExpr
[21] ValueExpr ::= PathExpr

A subtraction operator must be preceded by whitespace if it could otherwise be interpreted as part of the previous token. For example, a-b will be interpreted as a name, buta - b and a -b will be interpreted as arithmetic expressions. (See A.2.4 Whitespace Rules for further details on whitespace handling.)

The first step in evaluating an arithmetic expression is to evaluate its operands. The order in which the operands are evaluated is implementation-dependent.

If XPath 1.0 compatibility mode istrue, 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 theatomized operand.
  2. If the atomized operand is an empty sequence, the result of the arithmetic expression is the xs:double valueNaN, 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, any items after the first item in the sequence are discarded.
  4. If the atomized operand is now an instance of typexs:boolean, xs:string,xs:decimal (including xs:integer),xs:float, or xs:untypedAtomic, then it is converted to the type xs:double by applying thefn:number function. (Note that fn:numberreturns the value NaN if its operand cannot be converted to a number.)

If XPath 1.0 compatibility mode is false, 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 theatomized operand.
  2. If the atomized operand is an empty sequence, the result of the arithmetic expression 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 erroris raised [err:XPTY0004].
  4. If the atomized operand is of typexs:untypedAtomic, it is cast toxs:double. If the cast fails, a dynamic error is raised. [err:FORG0001]

After evaluation of the operands, if the types of the operands are a valid combination for the given arithmetic operator, the operator is applied to the operands, resulting in an atomic value or a dynamic error (for example, an error might result from dividing by zero.) The combinations of atomic types that are accepted by the various arithmetic operators, and their respective result types, are listed in B.2 Operator Mappingtogether with the operator functions that define the semantics of the operator for each type combination, including the dynamic errors that can be raised by the operator. The definitions of the operator functions are found in [XQuery 1.0 and XPath 2.0 Functions and Operators].

If the types of the operands, after evaluation, are not a valid combination for the given operator, according to the rules inB.2 Operator Mapping, a type error is raised [err:XPTY0004].

XPath supports two division operators named div andidiv. Each of these operators accepts two operands of any numeric type. As described in [XQuery 1.0 and XPath 2.0 Functions and Operators], $arg1 idiv <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>a</mi><mi>r</mi><mi>g</mi><mn>2</mn><mi mathvariant="normal">‘</mi><mi>i</mi><mi>s</mi><mi>e</mi><mi>q</mi><mi>u</mi><mi>i</mi><mi>v</mi><mi>a</mi><mi>l</mi><mi>e</mi><mi>n</mi><mi>t</mi><mi>t</mi><mi>o</mi><mi mathvariant="normal">‘</mi><mo stretchy="false">(</mo></mrow><annotation encoding="application/x-tex">arg2 is equivalent to (</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal">a</span><span class="mord mathnormal" style="margin-right:0.02778em;">r</span><span class="mord mathnormal" style="margin-right:0.03588em;">g</span><span class="mord">2‘</span><span class="mord mathnormal">i</span><span class="mord mathnormal">se</span><span class="mord mathnormal" style="margin-right:0.03588em;">q</span><span class="mord mathnormal">u</span><span class="mord mathnormal">i</span><span class="mord mathnormal" style="margin-right:0.03588em;">v</span><span class="mord mathnormal">a</span><span class="mord mathnormal" style="margin-right:0.01968em;">l</span><span class="mord mathnormal">e</span><span class="mord mathnormal">n</span><span class="mord mathnormal">tt</span><span class="mord mathnormal">o</span><span class="mord">‘</span><span class="mopen">(</span></span></span></span>arg1 div $arg2) cast as xs:integer?except for error cases.

Here are some examples of arithmetic expressions:

Note:

Multiple consecutive unary arithmetic operators are permitted by XPath for compatibility with[XPath 1.0].

3.5 Comparison Expressions

Comparison expressions allow two values to be compared. XPath provides three kinds of comparison expressions, called value comparisons, general comparisons, and node comparisons.

| [10] | ComparisonExpr | ::= | RangeExpr ( (ValueComp| GeneralComp| NodeComp) RangeExpr )? | | | | | | ------ | -------------------------------------------- | --- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---- | ---- | ---- | ---- | | [23] | ValueComp | ::= | "eq" | "ne" | "lt" | "le" | "gt" | "ge" | | [22] | GeneralComp | ::= | "=" | "!=" | "<" | "<=" | ">" | ">=" | | [24] | NodeComp | ::= | "is" | "<<" | ">>" | | | |

Note:

When an XPath expression is written within an XML document, the XML escaping rules for special characters must be followed; thus "<" must be written as "&lt;".

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 first step in evaluating a value comparison is to evaluate its operands. The order in which the operands are evaluated isimplementation-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 theatomized 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 erroris raised [err:XPTY0004].
  4. If the atomized operand is of typexs:untypedAtomic, it is cast toxs: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 ofxs:untypedAtomic operands. Users should also be aware that transitivity of value comparisons may be compromised by loss of precision during type conversion (for example, twoxs:integer values that differ slightly may both be considered equal to the same xs:float value becausexs:float has less precision thanxs: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 typehatsize (derived from xs:integer) andshoesize (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 Mappingtogether 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 1.0 and XPath 2.0 Functions and Operators].

Informally, if both atomized operands consist of exactly one atomic value, then the result of the comparison istrue 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 inB.2 Operator Mapping, a type error is raised [err:XPTY0004].

Here are some examples of value comparisons:

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

If XPath 1.0 compatibility mode istrue, a general comparison is evaluated by applying the following rules, in order:

  1. If either operand is a single atomic value that is an instance of xs:boolean, then the other operand is converted toxs:boolean by taking its effective boolean value.
  2. Atomization is applied to each operand. After atomization, each operand is a sequence of atomic values.
  3. If the comparison operator is <,<=, >, or >=, then each item in both of the operand sequences is converted to the typexs:double by applying the fn:numberfunction. (Note that fn:number returns the valueNaN if its operand cannot be converted to a number.)
  4. 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 relationshipbetween 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]
    1. If at least one of the two atomic values is an instance of anumeric type, then both atomic values are converted to the type xs:double by applying the fn:number function.
    2. If at least one of the two atomic values is an instance ofxs:string, or if both atomic values are instances ofxs:untypedAtomic, then both atomic values are cast to the type xs:string.
    3. If one of the atomic values is an instance ofxs:untypedAtomic and the other is not an instance ofxs:string, xs:untypedAtomic, or anynumeric type, then thexs:untypedAtomic value is cast to the dynamic type of the other value.
    4. After performing the conversions described above, the atomic values are compared using one of the value comparison operatorseq, 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.

If XPath 1.0 compatibility mode is false, ageneral 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 relationshipbetween 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]
    1. If one of the atomic values is an instance ofxs:untypedAtomic and the other is an instance of anumeric type, then thexs:untypedAtomic value is cast to the typexs:double.
    2. If one of the atomic values is an instance ofxs:untypedAtomic and the other is an instance ofxs:untypedAtomic or xs:string, then thexs:untypedAtomic value (or values) is (are) cast to the type xs:string.
    3. If one of the atomic values is an instance ofxs:untypedAtomic and the other is not an instance ofxs:string, xs:untypedAtomic, or anynumeric type, then thexs:untypedAtomic value is cast to the dynamic type of the other value.
    4. After performing the conversions described above, the atomic values are compared using one of the value comparison operatorseq, 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 trueas 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 adynamic erroras 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:

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 the following rules:

  1. The operands of a node comparison are evaluated in implementation-dependentorder.
  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 istrue if the two operand nodes have the same identity, and are thus the same node; otherwise it is false. See[XQuery/XPath Data Model (XDM)] for a definition of node identity.
  5. A comparison with the << operator returnstrue if the left operand node precedes the right operand node in document order; otherwise it returnsfalse.
  6. A comparison with the >> operator returnstrue if the left operand node follows the right operand node in document order; otherwise it returnsfalse.

Here are some examples of node comparisons:

3.6 Logical Expressions

A logical expression is either an and-expressionor an or-expression. If a logical expression does not raise an error, its value is always one of the boolean valuestrue or false.

[8] OrExpr ::= AndExpr ( "or" AndExpr )*
[9] AndExpr ::= ComparisonExpr ( "and" ComparisonExpr)*

The first step in evaluating a logical expression is to find theeffective boolean value of each of its operands (see 2.4.3 Effective Boolean Value).

The value of an and-expression is determined by the effective boolean values (EBV's) of its operands, as shown in the following table:

AND: EBV2 = true EBV2 = false error in EBV2
EBV1 = true true false error
EBV1 = false false false if XPath 1.0 compatibility mode is true, thenfalse; otherwise either false or error.
error in EBV1 error if XPath 1.0 compatibility mode is true, then error; otherwise either false or error. error

The value of an or-expression is determined by the effective boolean values (EBV's) of its operands, as shown in the following table:

OR: EBV2 = true EBV2 = false error in EBV2
EBV1 = true true true if XPath 1.0 compatibility mode is true, thentrue; otherwise either true or error.
EBV1 = false true false error
error in EBV1 if XPath 1.0 compatibility mode is true, then error; otherwise either true or error. error error

If XPath 1.0 compatibility mode istrue, the order in which the operands of a logical expression are evaluated is effectively prescribed. Specifically, it is defined that when there is no need to evaluate the second operand in order to determine the result, then no error can occur as a result of evaluating the second operand.

If XPath 1.0 compatibility mode is false, the order in which the operands of a logical expression are evaluated isimplementation-dependent. In this case, an or-expression can returntrue if the first expression evaluated is true, and it can raise an error if evaluation of the first expression raises an error. Similarly, an and-expression can return falseif the first expression evaluated is false, and it can raise an error if evaluation of the first expression raises an error. As a result of these rules, a logical expression is not deterministic in the presence of errors, as illustrated in the examples below.

Here are some examples of logical expressions:

In addition to and- and or-expressions, XPath provides a function named fn:not that takes a general sequence as parameter and returns a boolean value. The fn:notfunction is defined in [XQuery 1.0 and XPath 2.0 Functions and Operators]. The fn:notfunction reduces its parameter to an effective boolean value. It then returns true if the effective boolean value of its parameter is false, andfalse if the effective boolean value of its parameter is true. If an error is encountered in finding the effective boolean value of its operand, fn:not raises the same error.

3.7 For Expressions

XPath provides an iteration facility called a for expression.

[4] ForExpr ::= SimpleForClause"return" ExprSingle
[5] SimpleForClause ::= "for" "$" VarName "in"ExprSingle ("," "$" VarName "in" ExprSingle)*

A for expression is evaluated as follows:

  1. If the for expression uses multiple variables, it is first expanded to a set of nested for expressions, each of which uses only one variable. For example, the expressionfor <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>x</mi><mi>i</mi><mi>n</mi><mi>X</mi><mo separator="true">,</mo></mrow><annotation encoding="application/x-tex">x in X, </annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8778em;vertical-align:-0.1944em;"></span><span class="mord mathnormal">x</span><span class="mord mathnormal">in</span><span class="mord mathnormal" style="margin-right:0.07847em;">X</span><span class="mpunct">,</span></span></span></span>y in Y return <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>x</mi><mo>+</mo></mrow><annotation encoding="application/x-tex">x + </annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6667em;vertical-align:-0.0833em;"></span><span class="mord mathnormal">x</span><span class="mord">+</span></span></span></span>y is expanded tofor <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>x</mi><mi>i</mi><mi>n</mi><mi>X</mi><mi>r</mi><mi>e</mi><mi>t</mi><mi>u</mi><mi>r</mi><mi>n</mi><mi>f</mi><mi>o</mi><mi>r</mi></mrow><annotation encoding="application/x-tex">x in X return for </annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8889em;vertical-align:-0.1944em;"></span><span class="mord mathnormal">x</span><span class="mord mathnormal">in</span><span class="mord mathnormal" style="margin-right:0.07847em;">X</span><span class="mord mathnormal">re</span><span class="mord mathnormal">t</span><span class="mord mathnormal">u</span><span class="mord mathnormal" style="margin-right:0.02778em;">r</span><span class="mord mathnormal">n</span><span class="mord mathnormal" style="margin-right:0.10764em;">f</span><span class="mord mathnormal" style="margin-right:0.02778em;">or</span></span></span></span>y in Y return <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>x</mi><mo>+</mo></mrow><annotation encoding="application/x-tex">x + </annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6667em;vertical-align:-0.0833em;"></span><span class="mord mathnormal">x</span><span class="mord">+</span></span></span></span>y.
  2. In a single-variable for expression, the variable is called the range variable, the value of the expression that follows the in keyword is called the binding sequence, and the expression that follows thereturn keyword is called the return expression. The result of the for expression is obtained by evaluating the return expression once for each item in the binding sequence, with the range variable bound to that item. The resulting sequences are concatenated (as if by the comma operator) in the order of the items in the binding sequence from which they were derived.

The following example illustrates the use of afor expression in restructuring an input document. The example is based on the following input:

TCP/IP Illustrated Stevens Addison-Wesley Advanced Programming in the Unix Environment Stevens Addison-Wesley Data on the Web Abiteboul Buneman Suciu

The following example transforms the input document into a list in which each author's name appears only once, followed by a list of titles of books written by that author. This example assumes that the context item is the bib element in the input document.

for $a in fn:distinct-values(book/author) return (book/author[. = a][1],book[author=a][1], book[author = a][1],book[author=a]/title)

The result of the above expression consists of the following sequence of elements. The titles of books written by a given author are listed after the name of the author. The ordering ofauthor elements in the result is implementation-dependent due to the semantics of the fn:distinct-values function.

Stevens

TCP/IP Illustrated Advanced Programming in the Unix environment Abiteboul Data on the Web Buneman Data on the Web Suciu Data on the Web

The following example illustrates a for expression containing more than one variable:

for $i in (10, 20), $j in (1, 2) return ($i + $j)

The result of the above expression, expressed as a sequence of numbers, is as follows: 11, 12, 21, 22

The scope of a variable bound in a for expression comprises all subexpressions of the for expression that appear after the variable binding. The scope does not include the expression to which the variable is bound. The following example illustrates how a variable binding may reference another variable bound earlier in the same for expression:

for xinx in xinz, yinf(y in f(yinf(x) return g($x, $y)

Note:

The focus for evaluation of the return clause of afor expression is the same as the focus for evaluation of the for expression itself. The following example, which attempts to find the total value of a set of order-items, is therefore incorrect:

fn:sum(for $i in order-item return @price * @qty)

Instead, the expression must be written to use the variable bound in the for clause:

fn:sum(for $i in order-item return i/@price∗i/@price * i/@price∗i/@qty)

3.8 Conditional Expressions

XPath supports a conditional expression based on the keywordsif, then, and else.

[7] IfExpr ::= "if" "(" Expr ")" "then"ExprSingle "else" ExprSingle

The expression following the if keyword is called the test expression, and the expressions following thethen and else keywords are called thethen-expression and else-expression, respectively.

The first step in processing a conditional expression is to find the effective boolean value of the test expression, as defined in 2.4.3 Effective Boolean Value.

The value of a conditional expression is defined as follows: If the effective boolean value of the test expression istrue, the value of the then-expression is returned. If the effective boolean value of the test expression isfalse, the value of the else-expression is returned.

Conditional expressions have a special rule for propagatingdynamic errors. If the effective value of the test expression istrue, the conditional expression ignores (does not raise) any dynamic errors encountered in the else-expression. In this case, since the else-expression can have no observable effect, it need not be evaluated. Similarly, if the effective value of the test expression is false, the conditional expression ignores any dynamic errors encountered in the then-expression, and the then-expression need not be evaluated.

Here are some examples of conditional expressions:

3.9 Quantified Expressions

Quantified expressions support existential and universal quantification. The value of a quantified expression is alwaystrue or false.

[6] QuantifiedExpr ::= ("some" | "every") "$" VarName "in" ExprSingle ("," "$" VarName "in" ExprSingle)* "satisfies" ExprSingle

A quantified expression begins with a quantifier, which is the keyword some or every, followed by one or more in-clauses that are used to bind variables, followed by the keyword satisfies and a test expression. Each in-clause associates a variable with an expression that returns a sequence of items, called the binding sequence for that variable. The in-clauses generate tuples of variable bindings, including a tuple for each combination of items in the binding sequences of the respective variables. Conceptually, the test expression is evaluated for each tuple of variable bindings. Results depend on the effective boolean value of the test expressions, as defined in 2.4.3 Effective Boolean Value. The value of the quantified expression is defined by the following rules:

  1. If the quantifier is some, the quantified expression is true if at least one evaluation of the test expression has the effective boolean value true; otherwise the quantified expression is false. This rule implies that, if the in-clauses generate zero binding tuples, the value of the quantified expression is false.
  2. If the quantifier is every, the quantified expression is true if every evaluation of the test expression has the effective boolean value true; otherwise the quantified expression is false. This rule implies that, if the in-clauses generate zero binding tuples, the value of the quantified expression is true.

The scope of a variable bound in a quantified expression comprises all subexpressions of the quantified expression that appear after the variable binding. The scope does not include the expression to which the variable is bound.

The order in which test expressions are evaluated for the various binding tuples is implementation-dependent. If the quantifier is some, an implementation may returntrue as soon as it finds one binding tuple for which the test expression has an effective boolean value of true, and it may raise a dynamic error as soon as it finds one binding tuple for which the test expression raises an error. Similarly, if the quantifier is every, an implementation may return false as soon as it finds one binding tuple for which the test expression has an effective boolean value of false, and it may raise a dynamic error as soon as it finds one binding tuple for which the test expression raises an error. As a result of these rules, the value of a quantified expression is not deterministic in the presence of errors, as illustrated in the examples below.

Here are some examples of quantified expressions:

3.10 Expressions on SequenceTypes

sequence types are used in instance of, cast,castable, and treat expressions.

3.10.1 Instance Of

[16] InstanceofExpr ::= TreatExpr ( "instance" "of" SequenceType)?

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

3.10.2 Cast

[19] CastExpr ::= UnaryExpr ( "cast" "as" SingleType )?
[49] SingleType ::= AtomicType"?"?

Occasionally it is necessary to convert a value to a specific datatype. For this purpose, XPath provides a castexpression that creates a new value of a specific type based on an existing value. A cast expression takes two operands: an input expression and a target type. The type of the input expression is called the input type. The target type must be an atomic type that is in the in-scope schema types [err:XPST0051]. In addition, the target type cannot be xs:NOTATION or xs:anyAtomicType[err:XPST0080]. The optional occurrence indicator "?" denotes that an empty sequence is permitted. If the target type has no namespace prefix, it is considered to be in the default element/type namespace. The semantics of the castexpression 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:XPTY0004].
  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, atype error is raised [err:XPTY0004].
  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, an implementation may determine that one type is derived by restriction from another type either by examining the in-scope schema definitions or by using an alternative, implementation-dependentmechanism such as a data dictionary.
    1. cast is supported for the combinations of input type and target type listed in Section 17.1 Casting from primitive types to primitive typesFO. For each of these combinations, both the input type and the target type are primitiveschema types. For example, a value of type xs:string can be cast into the schema 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].
      If the target type of a cast expression isxs:QName, or is a type that is derived fromxs:QName or xs:NOTATION, and if the base type of the input is not the same as the base type of the target type, then the input expression must be a string literal [err:XPTY0004].
      Note:
      The reason for this rule is that construction of an instance of one of these target types from a string requires knowledge about namespace bindings. If the input expression is a non-literal string, it might be derived from an input document whose namespace bindings are different from the statically known namespaces.
    2. cast is supported if the input type is a non-primitive atomic type that is derived by restriction from the target 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 fromxs:integer, a value of type shoesize can be cast into the schema type xs:integer.
    3. cast is supported if the target type is a non-primitive atomic type and the input type isxs:string or xs: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 (as defined in [XML Schema]); a dynamic error [err:FORG0001] 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:FORG0001] 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 that is derived by restriction from the input 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 type derived by restriction from P1 can be cast into any type derived by restriction from 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:XPTY0004].

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

3.10.3 Castable

[18] CastableExpr ::= CastExpr ( "castable" "as" SingleType )?
[49] SingleType ::= AtomicType"?"?

XPath provides an expression that tests whether a given value is castable into a given target type. The target type must be an atomic type that is in the in-scope schema types [err:XPST0051]. In addition, the target type cannot be xs:NOTATION or xs:anyAtomicType[err:XPST0080]. The optional occurrence indicator "?" denotes that an empty sequence is permitted.

The expression V castable as T returnstrue if the value V can be successfully cast into the target type T by using acast expression; otherwise it returnsfalse. The castable expression can be used as a predicateto 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

Note:

If the target type of a castable expression isxs:QName, or is a type that is derived fromxs:QName or xs:NOTATION, and the input argument of the expression is of type xs:string but it is not a literal string, the result of the castableexpression is false.

3.10.4 Constructor Functions

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

T($arg as xs:anyAtomicType?) as T?

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

The constructor functions for xs:QName and for types derived from xs:QName andxs:NOTATION require their arguments to be string literals or to have a base type that is the same as the base type of the target type; otherwise a type error [err:XPTY0004] is raised. This rule is consistent with the semantics of cast expressions for these types, as defined in 3.10.2 Cast.

The following examples illustrate the use of constructor functions:

Note:

An instance of an atomic type that is not in a namespace can be constructed in either of the following ways:

3.10.5 Treat

[17] TreatExpr ::= CastableExpr ( "treat" "as" SequenceType)?

XPath 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. Unlikecast, however, treat does not change thedynamic type or value of its operand. Instead, the purpose of treat is to ensure that an expression has an expected dynamic type at evaluation time.

The semantics of expr1 treat as type1 are as follows: