XML Path Language (XPath) 4.0 WG Review Draft

2.1.1 Static Context

[Definition: The static context of an expression is the information that is available during static analysis of the expression, prior to its evaluation.] This information can be used to decide whether the expression contains a static error.

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

• [Definition: XPath 1.0 compatibility mode. This value is true if rules for backward compatibility with XPath Version 1.0 are in effect; otherwise it is false. ]

• [Definition: Statically known namespaces. This is a mapping from prefix to namespace URI that defines all the namespaces that are known during static processing of a given expression.]

  The URI value is whitespace normalized according to the rules for the xs:anyURI type in Section 3.2.17 anyURI ^XS1-2 or Section 3.3.17 anyURI ^XS11-2.

  The statically known namespaces may include a binding for the zero-length prefix; however, this is only used in limited circumstances because the rules for resolving unprefixed QNames depend on the how such a name is used.

  Note the difference between in-scope namespaces, which is a dynamic property of an element node, and statically known namespaces, which is a static property of an expression.

• [Definition: Default element namespace. This is a namespace URI or absent^DM31. The namespace URI, if present, is used for any unprefixed QName appearing in a position where an element name is expected.] The URI value is whitespace normalized according to the rules for the xs:anyURI type in Section 3.2.17 anyURI ^XS1-2 or Section 3.3.17 anyURI ^XS11-2.

• [Definition: Default type namespace. This is a namespace URI or absent^DM31. The namespace URI, if present, is used for any unprefixed QName appearing in a position where a type name is expected.] The URI value is whitespace normalized according to the rules for the xs:anyURI type in Section 3.2.17 anyURI ^XS1-2 or Section 3.3.17 anyURI ^XS11-2.

• [Definition: Function name resolver. This is an algorithm that takes as input a lexical QName and arity, and delivers as its result an expanded QName.] The expanded QName and arity must uniquely identify a function signature in the statically known function signatures, or a static error is reported. This algorithm is used when function names are resolved statically, specifically when they appear in static function calls or function references. The

  Note:

  Different host languages or APIs may adopt different strategies for resolving unprefixed function names. Possible approaches include (but are not limited to):

  1. Treating all unprefixed names as references to functions in the namespace http://www.w3.org/2005/xpath-functions.

  2. Treating all unprefixed names as references to functions in a default namespace established in some way determined by the host language or API.

  3. Searching multiple namespaces, with some strategy for resolving conflicts.

  4. Giving different precedence to functions declared in different ways, for example giving locally-declared functions precedence over globally-declared functions.

  5. Resolving particular magic names (such as xsl:original) using host-language defined rules.

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

  • [Definition: In-scope schema types. Each schema type definition is identified either by an expanded QName (for a named type) or by an implementation-dependent type identifier (for an anonymous type). The in-scope schema types include the predefined schema types described in 3.1 Predefined Schema Types. ]

  • [Definition: In-scope element declarations. Each element declaration is identified either by an expanded QName (for a top-level element declaration) or by an implementation-dependent element identifier (for a local element declaration). ] An element declaration includes information about the element's substitution group affiliation.

    [Definition: Substitution groups are defined in Section 2.2.2.2 Element Substitution Group ^XS1-1 and Section 2.2.2.2 Element Substitution Group ^XS11-1. Informally, the substitution group headed by a given element (called the head element) consists of the set of elements that can be substituted for the head element without affecting the outcome of schema validation.]

  • [Definition: In-scope attribute declarations. Each attribute declaration is identified either by an expanded QName (for a top-level attribute declaration) or by an implementation-dependent attribute identifier (for a local attribute declaration). ]

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

  An expression that binds a variable extends the in-scope variables, within the scope of the variable, with the variable and its type. Within the body of an inline function expression , the in-scope variables are extended by the names and types of the function parameters.

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

• [Definition: Item type aliases. This is a mapping from expanded QName to ItemTypes.]

  [Definition: A type alias is an expanded QName that is mapped to an ItemType in the item type aliases of the static context.]

  Item type aliases allow frequently-used item types, especially complex item types such as record types, to be given simple names, so that the definition of the type is not repeated every time it is used.

  Note:

  Item type aliases can be defined in XQuery 4.0 and in XSLT 4.0, but not in XPath 4.0 itself.

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

  The statically known function signatures include the signatures of functions from a variety of sources, including the built-in functions. Implementations must ensure that no two functions have the same expanded QName and the same arity (even if the signatures are consistent).

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

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

• [Definition: Static Base URI. This is an absolute URI, used to resolve relative URI references. ] If E is a subexpression of F then the Static Base URI of E is the same as the Static Base URI of F. There are no constructs in XPath that require resolution of relative URI references during static analysis. The Static Base URI is available during dynamic evaluation by use of the fn:static-base-uri function, and is used implicitly during dynamic evaluation by functions such as fn:doc. Relative URI references are resolved as described in 2.4.6 Resolving a Relative URI Reference.

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

  Note:

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

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

  Note:

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

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

• [Definition: Statically known decimal formats. This is a mapping from QNames to decimal formats, with one default format that has no visible name, referred to as the unnamed decimal format. Each format is available for use when formatting numbers using the fn:format-number function.]

  Each decimal format defines a set of properties, which control the interpretation of characters in the picture string supplied to the fn:format-number function, and also specify characters to be used in the result of formatting the number.

  The following properties specify characters used both in the picture string, and in the formatted number. In each case the value is a single character:

  • [Definition: decimal-separator is the character used to separate the integer part of the number from the fractional part, both in the picture string and in the formatted number; the default value is the period character (.)]

  • [Definition: exponent-separator is the character used to separate the mantissa from the exponent in scientific notation both in the picture string and in the formatted number; the default value is the character (e).]

  • [Definition: grouping-separator is the character typically used as a thousands separator, both in the picture string and in the formatted number; the default value is the comma character (,)]

  • [Definition: percent is the character used both in the picture string and in the formatted number to indicate that the number is written as a per-hundred fraction; the default value is the percent character (%)]

  • [Definition: per-mille is the character used both in the picture string and in the formatted number to indicate that the number is written as a per-thousand fraction; the default value is the Unicode per-mille character (#x2030)]

  • [Definition: zero-digit is the character used to represent the digit zero; the default value is the Western digit zero (#x30). This character must be a digit (category Nd in the Unicode property database), and it must have the numeric value zero. This property implicitly defines the ten Unicode characters that are used to represent the values 0 to 9: Unicode is organized so that each set of decimal digits forms a contiguous block of characters in numerical sequence. Within the picture string any of these ten character can be used (interchangeably) as a place-holder for a mandatory digit. Within the final result string, these ten characters are used to represent the digits zero to nine.]

  The following properties specify characters to be used in the picture string supplied to the fn:format-number function, but not in the formatted number. In each case the value must be a single character.

  • [Definition: digit is a character used in the picture string to represent an optional digit; the default value is the number sign character (#)]

  • [Definition: pattern-separator is a character used to separate positive and negative sub-pictures in a picture string; the default value is the semi-colon character (;)]

  The following properties specify characters or strings that may appear in the result of formatting the number, but not in the picture string:

  • [Definition: infinity is the string used to represent the double value infinity (INF); the default value is the string "Infinity"]

  • [Definition: NaN is the string used to represent the double value NaN (not-a-number); the default value is the string "NaN"]

  • [Definition: minus-sign is the single character used to mark negative numbers; the default value is the hyphen-minus character (#x2D). ]

2.1.2 Dynamic Context

[Definition: The dynamic context of an expression is defined as information that is needed for the dynamic evaluation of an expression.] If evaluation of an expression relies on some part of the dynamic context that is absent^DM31, a dynamic error is raised [err:XPDY0002].

The individual components of the dynamic context are described 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. If any component in the focus is defined, both the context item and context position are known.

[Definition: A singleton focus is a focus that refers to a single item; in a singleton focus, context item is set to the item, context position = 1 and context size = 1.]

Certain language constructs, notably the path operator E1/E2, the simple map operator 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 time E2 is evaluated, it is evaluated with a different focus. The focus for evaluating E2 is referred to below as the inner focus, while the focus for evaluating E1 is referred to as the outer focus. The inner focus is used only for the evaluation of E2. Evaluation of E1 continues with its original focus unchanged.

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

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

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

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

• [Definition: Named functions. This is a mapping from (expanded QName, arity) to function^DM31. ] It supplies a function for each signature in statically known function signatures and may supply other functions (see 2.2.4 Consistency Constraints). Named functions can include external functions. [Definition: External functions are functions that are implemented outside the query environment.] For example, an implementation might provide a set of implementation-defined external functions in addition to the core function library described in [XQuery and XPath Functions and Operators 3.1]. [Definition: An implementation-defined function is an external function that is implementation-defined ]. [Definition: A host language function is an external function defined by the host language.]

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

• [Definition: Implicit timezone. This is the timezone to be used when a date, time, or dateTime value that does not have a timezone is used in a comparison or arithmetic operation. The implicit timezone is an implementation-defined value of type xs:dayTimeDuration. See Section 3.2.7.3 Timezones ^XS1-2 or Section 3.3.7 dateTime ^XS11-2 for the range of valid values of a timezone.]

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

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

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

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

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

  Note:

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

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

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

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

  Note:

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

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

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

  Note:

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

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

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

  Note:

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

2.2.1 Data Model Generation

The input data for an expression must be represented as one or more XDM instances. This process occurs outside the domain of XPath 4.0, which is why Figure 1 represents it in the external processing domain. Here are some steps by which an XML document might be converted to an XDM instance:

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

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

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

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

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

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

2.2.2 Schema Import Processing

The in-scope schema definitions in the static context are provided by the host language (see step SI1 in Figure 1) and must satisfy the consistency constraints defined in 2.2.4 Consistency Constraints.

2.2.3 Expression Processing

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

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

2.2.4 Consistency Constraints

In order for XPath 4.0 to be well defined, the input XDM instances, the static context, and the dynamic context must be mutually consistent. The consistency constraints listed below are prerequisites for correct functioning of an XPath 4.0 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.

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

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

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

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

• For each mapping of a string to a sequence of items in available collections, if there exists a mapping of the same string to a type in statically known collections, the sequence of items must match the type, using the matching rules in 3.5 Sequence Type Matching.

• The sequence of items in the default collection must match the statically known default collection type, using the matching rules in 3.5 Sequence Type Matching.

• The value of the context item must match the context item static type, using the matching rules in 3.5 Sequence Type Matching.

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

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

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

2.3.1 Kinds of Errors

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

[Definition: An error that can be detected during the static analysis phase, and is not a type error, is a static error.] A syntax error is an example of a static error.

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

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

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

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

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

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

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

error()

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

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

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

In addition to the errors defined in this specification, an implementation may raise a dynamic error for a reason beyond the scope of this specification. For example, limitations may exist on the maximum numbers or sizes of various objects. An error must be raised if such a limitation is exceeded [err:XPDY0130].

2.3.2 Identifying and Reporting Errors

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

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

• XP identifies the error as an XPath error (some errors, originally defined by XQuery and later added to XPath, use the code XQ instead).

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

  • ST denotes a static error.

  • DY denotes a dynamic error.

  • TY denotes a type error.

• nnnn is a unique numeric code.

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

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

2.3.3 Handling Dynamic Errors

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

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

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

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

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

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

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

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

2.3.4 Errors and Optimization

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

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

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

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

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

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

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

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

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

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

Examples:

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

  some $x in $expr1 satisfies $x = 47

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

  //product[id = 47]

For a variety of reasons, including optimization, implementations may rewrite expressions into a different form. There are a number of rules that limit the extent of this freedom:

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

  Note:

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

  Note:

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

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

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

  Of course, the condition must be evaluated in order to determine which branch is selected, and the query must not be rewritten in a way that would bypass evaluating the condition.

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

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

Expression rewrite is illustrated by the following examples.

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

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

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

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

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

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

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

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

2.4.1 Document Order

An ordering called document order is defined among all the nodes accessible during processing of a given expression, which may consist of one or more trees (documents or fragments). Document order is defined in Section 2.4 Document Order ^DM31, and its definition is repeated here for convenience. Document order is a total ordering, although the relative order of some nodes is implementation-dependent. [Definition: Informally, document order is the order in which nodes appear in the XML serialization of a document.] [Definition: Document order is stable, which means that the relative order of two nodes will not change during the processing of a given expression, even if this order is implementation-dependent.] [Definition: The node ordering that is the reverse of document order is called reverse document order.]

Within a tree, document order satisfies the following constraints:

1. The root node is the first node.

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

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

4. Attribute nodes immediately follow the namespace nodes of the element 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 but implementation-dependent, subject to the following constraint: If any node in a given tree T1 is before any node in a different tree T2, then all nodes in tree T1 are before all nodes in tree T2.

2.4.2 Atomization

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

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

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

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

• If the item is a function^DM31 (other than an array) or map a type error [err:FOTY0013]^FO31 is raised.

• If the item is an array $a, atomization is defined as $a?* ! fn:data(.), which is equivalent to atomizing the members of the array.

  Note:

  This definition recursively atomizes members that are arrays. Hence, the result of atomizing the array [ [1, 2, 3], [4, 5, 6] ] is the sequence (1, 2, 3, 4, 5, 6).

Atomization is used in processing the following types of expressions:

• Arithmetic expressions

• Comparison expressions

• Function calls and returns

• Cast 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 Section 7.3.1 fn:boolean ^FO31.]

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

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

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

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

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

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

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

   Note:

   For instance, fn:boolean raises a type error if the operand is a function, a map, or an array.

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

• Logical expressions (and, or)

• The fn:not function

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

• Conditional expressions (if)

• Quantified expressions (some, every)

• General comparisons, in XPath 1.0 compatibility mode.

2.4.4 Input Sources

XPath 4.0 has a set of functions that provide access to XML documents (fn:doc, fn:doc-available), collections (fn:collection, fn:uri-collection), text files (fn:unparsed-text, fn:unparsed-text-lines, fn:unparsed-text-available), and environment variables (fn:environment-variable, fn:available-environment-variables). These functions are defined in Section 14.6 Functions giving access to external information ^FO31.

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

2.4.5 URI Literals

XPath 4.0 requires a statically known, valid URI in a BracedURILiteral. An implementation may raise a static error [err:XQST0046] if the value of a Braced URI Literal is of nonzero length and is neither an absolute URI nor a relative URI.

Whitespace is normalized using the whitespace normalization rules of fn:normalize-space. If the result of whitespace normalization contains only whitespace, the corresponding URI consists of the empty string.

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

2.4.6 Resolving a Relative URI Reference

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

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

3.6.1 General item types

• item() matches any single item.

  Example: item() matches the atomic value 1, the element <a/>, or the function fn:concat#3.

• A ParenthesizedItemType matches an item if and only if the item matches the ItemType that is in parentheses.

  Note:

  Parenthesized item types are used primarily when defining nested item types in a function signature: for example a sequence of functions that return booleans might be denoted (function () as xs:boolean)*. In this example the parentheses are needed to indicate where the occurrence indicator belongs.

3.6.2 Atomic and Union Types

A generalized atomic type may be expressed as an in any of the following ways:

• Using the QName of a type in the in-scope schema definitions that is an atomic type or a pure union type

• Using a QName that identifies a type alias that resolves to a generalized atomic type.

• Using a where the parentheses enclose a generalized atomic type.

• Using a as described below.

• Using an as described below.

Example: The ItemType xs:decimal matches any value of type xs:decimal. It also matches any value of type shoesize, if shoesize is an atomic type derived by restriction from xs:decimal.

Example: Suppose ItemType dress-size is a union type that allows either xs:decimal values for numeric sizes (e.g. 4, 6, 10, 12), or one of an enumerated set of xs:strings (e.g. "small", "medium", "large"). The ItemType dress-size matches any of these values.

3.6.3 Node Types

Some of the constructs described in this section include a TypeName. This appears as T in:

• element(N, T)

• attribute(N, T)

• document-node(element(N, T))

In these constructs, the type name T is expanded using the in-scope namespaces in the static context, using the default type namespace if it is unprefixed. The resulting QName must identify a type in the in-scope schema definitions. This can be any schema type: either a simple type, or (except in the case of attributes) a complex type. If it is a simple type then it can be an atomic, union, or list type. It can be a built-in type (such as xs:integer) or a user-defined type. It must however be the name of a type defined in a schema; it cannot be a type alias.

3.6.4 Function, Map, and Array Tests

• The ItemType map(K, V) matches an item M if (a) M is a map, and (b) every entry in M has a key that matches K and an associated value that matches V. For example, map(xs:integer, element(employee)) matches a map if all the keys in the map are integers, and all the associated values are employee elements. Note that a map (like a sequence) carries no intrinsic type information separate from the types of its entries, and the type of existing entries in a map does not constrain the type of new entries that can be added to the map.

  Note:

  In consequence, map(K, V) matches an empty map, whatever the types K and V might be.

• The ItemType map(*) matches any map regardless of its contents. It is equivalent to map(xs:anyAtomicType, item()*).

• The ItemType record(K1 as T1, K2 as T2) matches a map having keys K1 and K2, with associated values matching T1 and T2 respectively. Record tests are described in more detail in 3.6.4.3 Record Test.

• The ItemType array(T) matches any array in which the type of every member is T.

• The ItemType array(*) matches any array regardless of its contents.

record(error-code as xs:QName, message as xs:string, cause? as ..)

record(left? as .., value, right? as ..)

declare item-type binary-tree as
    record(left? as .., value, right? as ..);                 
declare function flatten($tree as binary-tree?) as item()* {
    $tree ! (flatten(?left), ?value, flatten(?right))   
}

record(value, children as ..*)

declare item-type tree as
    record(value, children as ..*);                 
declare function flatten($tree as tree) as item()* {
    $tree?value, $tree?children ! flatten(.))   
}

3.6.5 xs:error

The type xs:error has an empty value space; it never appears as a dynamic type or as the content type of a dynamic element or attribute type. It was defined in XML Schema in the interests of making the type system complete and closed, and it is also available in XPath 4.0 for similar reasons.

3.7.1 The judgement subtype(A, B)

The judgement subtype(A, B) determines if the sequence type A is a subtype of the sequence type B. A can either be empty-sequence(), xs:error, or an ItemType, Ai, possibly followed by an occurrence indicator. Similarly B can either be empty-sequence(), xs:error, or an ItemType, Bi, possibly followed by an occurrence indicator. The result of the subtype(A, B) judgement can be determined from the table below, which makes use of the auxiliary judgement subtype-itemtype(Ai, Bi) defined in 3.7.2 The judgement subtype-itemtype(A, B) .

xs:error+ is treated the same way as xs:error in the above table. xs:error? and xs:error* are treated the same way as empty-sequence().

3.7.2 The judgement subtype-itemtype(A, B)

The judgement subtype-itemtype(A, B) determines whether the ItemType A is a subtype of the ItemType B.

Before applying these rules, any ItemType written as item-type(N) is replaced with the definition of the named item type N, recursively. The rules are written in terms of the lexical form of the two ItemTypes, but it is assumed that trivial variations are first eliminated: comments and unnecessary whitespace are removed, lexical QNames are replaced by URI-qualified names applying appropriate defaults in the case of unprefixed names, equivalent forms such as element() and element(*) are normalized.

A is a subtype of B if and only if at least one of the following conditions applies:

1. General rules:

   1. A is xs:error.

   2. B is item().

   3. A and B are the same ItemType.

   4. There is an ItemType C such that subtype-itemtype(A, C) and subtype-itemtype(C, B). (This is referred to below as the transitivity rule).

2. Conditions for atomic and union types:

   1. A and B are generalized atomic types, and derives-from(A, B) returns true.

   2. A is the name of a pure union type, and every type T in the transitive membership of A satisfies subtype-itemType(T, B).

   3. A is a LocalUnionType in the form union(T1, T2, ...) and every type T in (T1, T2, ...) satisfies subtype-itemType(T, B).

   4. A is an EnumerationType, and B matches every string literal in the enumeration of A.

      Note:

      This means, for example, that the type enum("red", "green", "blue") is a subtype of enum("red", "green", "blue", "yellow"), as well as being a subtype of xs:string.

3. Conditions for node types:

   1. A is a KindTest and B is node().

   2. A is processing-instruction(N) for any name N, and B is processing-instruction().

   3. A is document-node(E) for any ElementTest E, and B is document-node().

   4. All the following are true:

      1. A is document-node(Ae)

      2. B is document-node(Be)

      3. subtype-itemtype(Ae, Be)

   5. A is an ElementTest and B is element() (or element(*)).

   6. All the following are true:

      1. A is either element(An) or element(An, T) or element(An, T?) for some type T

      2. B is either element(Bn) or element(Bn, xs:anyType?)

      3. the expanded QName of An equals the expanded QName of Bn.

   7. All the following are true:

      1. A is element(An, At)

      2. B is element(Bn, Bt)

      3. the expanded QName of An equals the expanded QName of Bn

      4. derives-from(At, Bt).

      TODO: An and Bn as wildcards

   8. All the following are true:

      1. A is either element(An, At) or element(An, At?)

      2. B is element(Bn, Bt?)

      3. the expanded QName of An equals the expanded QName of Bn

      4. derives-from(At, Bt).

      TODO: An and Bn as wildcards

   9. All the following are true:

      1. Ai is either element(*, At) or element(N, At) for any name N

      2. Bi is element(*, Bt)

      3. derives-from(At, Bt).

   10. All the following are true:

       1. A is either element(*, At), element(*, At?), element(N, At), or element(N, At?) for any name N

       2. B is element(*, Bt?)

       3. derives-from(At, Bt).

   11. All the following are true:

       1. A is schema-element(An)

       2. B is schema-element(Bn)

       3. every element declaration that is an actual member of the substitution group of An is also an actual member of the substitution group of Bn

       Note:

       The fact that P is a member of the substitution group of Q does not mean that every element declaration in the substitution group of P is also in the substitution group of Q. For example, Q might block substitution of elements whose type is derived by extension, while P does not.

   12. A is an AttributeTest and B is either attribute() or attribute(*)

   13. All the following are true:

       1. A is either attribute(An) or attribute(An, T) for any type T.

       2. B is either attribute(Bn) or attribute(Bn, xs:anyType)

       3. the expanded QName of An equals the expanded QName of Bn

   14. All the following are true:

       1. A is attribute(An, At)

       2. B is attribute(Bn, Bt)

       3. the expanded QName of An equals the expanded QName of Bn

       4. derives-from(At, Bt).

   15. All the following are true:

       1. A is either attribute(*, At), or attribute(N, At) for any name N

       2. B is attribute(*, Bt)

       3. derives-from(At, Bt).

   16. All the following are true:

       1. A is schema-attribute(An)

       2. B is schema-attribute(Bn)

       3. the expanded QName of An equals the expanded QName of Bn

       4. derives-from(At, Bt).

4. Conditions for functions, maps and arrays:

   1. All the following are true:

      1. A is a FunctionTest

      2. Bi is function(*)

   2. All the following are true:

      1. A is function(Aa_1, Aa_2, ... Aa_M) as Ar

      2. B is function(Ba_1, Ba_2, ... Ba_N) as Br

      3. N (arity of B) equals M (arity of A)

      4. subtype(Ar, Br)

      5. for all values of I between 1 and N, subtype(Ba_I, Aa_I)

      Note:

      Function return types are covariant because this rule invokes subtype(Ar, Br) for return types. Function arguments are contravariant because this rule invokes subtype(Ba_I, Aa_I) for arguments.

   3. All the following are true:

      1. A is map(K, V), for any K and V

      2. B is map(*)

   4. All the following are true:

      1. A is map(Ka, Va)

      2. B is map(Kb, Vb)

      3. subtype-itemtype(Ka, Kb)

      4. subtype(Va, Vb)

   5. All the following are true:

      1. A is map(*) (or, because of the transitivity rules, any other map type)

      2. B is function(*)

   6. All the following are true:

      1. A is map(*) (or, because of the transitivity rules, any other map type)

      2. B is function(xs:anyAtomicType) as item()*

   7. All the following are true:

      1. A is map(K, V)

      2. B is function(xs:anyAtomicType) as V?

   8. All the following are true:

      1. A is array(X)

      2. B is array(*)

   9. All the following are true:

      1. A is array(X)

      2. B is array(Y)

      3. subtype(X, Y)

   10. All the following are true:

       1. A is array(*) (or, because of the transitivity rules, any other array type)

       2. B is function(*)

   11. All the following are true:

       1. A is array(*) (or, because of the transitivity rules, any other array type)

       2. Bi is function(xs:integer) as item()*

   12. All the following are true:

       1. A is array(X)

       2. B is function(xs:integer) as X

   13. All of the following are true:

       1. A is a record test

       2. B is map(*)

   14. All of the following are true:

       1. A is a record test

       2. A is not extensible

       3. B is map(K, V)

       4. K is either xs:string or xs:anyAtomicType

       5. For every field F in A, where T is the declared type of F (or its default, item()*, subtype(T, V) is true.

   15. All of the following are true:

       1. A is a record test

       2. B is a record test

       3. A is extensible

       4. B is extensible

       5. For every field F that is declared in B, where the declared type of F is U, one of the following is true:

          1. All of the following are true:

             1. F is also declared in A, with required type T

             2. If the field F in B is mandatory, then the field F in Ais also mandatory

             3. subtype(T, U)

          2. TODO: other possibilities?

   16. All of the following are true:

       1. A is a record test

       2. B is a record test

       3. A is not extensible

       4. B is extensible

       5. For every field F that is declared in B, where the declared type of F is U, one of the following is true:

          1. All of the following are true:

             1. F is also declared in A, with required type T

             2. If the field F in B is mandatory, then the field F in Ais also mandatory

             3. subtype(T, U)

          2. TODO: other possibilities?

   17. All of the following are true:

       1. A is a record test

       2. B is a record test

       3. A is not extensible

       4. B is not extensible

       5. For every field F that is declared in B, where the declared type of F is U, one of the following is true:

          1. All of the following are true:

             1. F is also declared in A, with required type T

             2. If the field F in B is mandatory, then the field F in Ais also mandatory

             3. subtype(T, U)

          2. TODO: other possibilities?

4.3.1 Literals

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

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

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

Here are some examples of literal expressions:

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

• 12 denotes the xs:integer value twelve.

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

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

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

  Note:

  When XPath expressions are embedded in contexts where quotation marks have special significance, such as inside XML attributes, additional escaping may be needed.

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

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

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

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

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

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

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

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

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

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

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

4.3.2 Variable References

[Definition: A variable reference is an EQName preceded by a $-sign.] An unprefixed variable reference is in no namespace. Two variable references are equivalent if their expanded QNames are equal (as defined by the eq operator). The scope of a variable binding is defined separately for each kind of expression that can bind variables.

Every variable reference must match a name in the in-scope variables.

Every variable binding has a static scope. The scope defines where references to the variable can validly occur. It is a static error [err:XPST0008] to reference a variable that is not in scope. If a variable is bound in the static context for an expression, that variable is in scope for the entire expression except where it is occluded by another binding that uses the same name within that scope.

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

4.3.3 Parenthesized Expressions

Parentheses may be used to override the precedence rules. For example, the expression (2 + 4) * 5 evaluates to thirty, since the parenthesized expression (2 + 4) is evaluated first and its result is multiplied by five. Without parentheses, the expression 2 + 4 * 5 evaluates to twenty-two, because the multiplication operator has higher precedence than the addition operator.

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

4.3.4 Context Item Expression

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

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

4.3.5 Enclosed Expressions

[Definition: An enclosed expression is an instance of the EnclosedExpr production, which allows an optional expression within curly braces.] [Definition: In an enclosed expression, the optional expression enclosed in curly braces is called the content expression.] If the content expression is not provided explicitly, the content expression is ().

4.4.1 Static Functions

The static context for an expression includes a set of named functions. Each function in the static context can be identified given knowledge of its name and arity. Every function in the static context has a name (which is a QName) and a range of permitted arities for calls on that function. Two functions having the same name must not have overlapping arity ranges: the rules are defined more precisely below.

Functions in the static context may include any or all of the following:

• Built-in functions defined in these specifications or in a host language referencing these specifications.

• User-defined functions declared using the syntax of a host language such as XQuery or XSLT.

• External functions made available in some implementation-defined way.

[Definition: The built-in functions are the functions defined in [XQuery and XPath Functions and Operators 3.1]in the http://www.w3.org/2005/xpath-functions, http://www.w3.org/2001/XMLSchema, http://www.w3.org/2005/xpath-functions/math, http://www.w3.org/2005/xpath-functions/map, and http://www.w3.org/2005/xpath-functions/array namespaces. ] The set of built-in functions is specified by the host language. Additional functions may be provided in the static context. XPath per se does not provide a way to declare named functions, but a host language may provide such a mechanism.

Static functions may be variadic. If a function is variadic, the number of arguments appearing in a function call may differ from the number of parameters declared in the function signature. Different kinds of variadic functions are defined, distinguished by the value of the annotation %variadic, which is present on all static functions, and takes one of four values:

• %variadic("no") indicates that the function is not variadic. In a function call, an argument must be supplied for every parameter in the function signature. It can be supplied either positionally or by keyword, but there must be a one-to-one mapping between arguments and parameter declarations.

• %variadic("bounded") indicates that the function is bounded-variadic. A bounded-variadic function declares zero or more required parameters and one or more optional parameters. In a function call, an argument must be supplied for every required parameter, and arguments may be supplied for optional parameters: in both cases, the argument may be supplied either positionally or by keyword.

• %variadic("sequence") indicates that the function is sequence-variadic. A sequence-variadic function declares one or more parameters, of which the last typically has an occurrence indicator of * or + to indicate that a sequence may be supplied. If the declaration includes N parameters, then a call on the function may supply N-1 or more arguments; the values of the Nth and subsequent arguments are concatenated to form a single sequence, which is supplied as the value of the last parameter in the declaration. In a sequence-variadic function, the last parameter is implicitly optional (it defaults to an empty sequence), and all other parameters are required. In a call of a sequence-variadic function, all arguments must be supplied positionally.

• %variadic("map") indicates that the function is map-variadic. A map-variadic function declares one or more parameters, of which the last must be a type that accepts a map. It may restrict what kind of map is accepted (for example, by using a RecordTest), and it may accept things other than maps, but it must accept a single map as the supplied value. The last parameter is implicitly optional (it defaults to an empty map). All other parameters are required, and must be supplied positionally. All keyword arguments in the function call are assembled into a map, and this map is supplied as the value of the last parameter. Alternatively, the last parameter can be supplied positionally (typically, as an already-assembled map).

  The names and types of the keyword arguments supplied to a map-variadic function may be constrained by declaring the required type in the function signature as a Record Test, which then allows static type checking. However, there is no requirement to use such a type.

A function has a declared arity which is the number of parameters defined in the function declaration. This value, together with the value of the variadic annotation, determine the number of positional arguments and keyword arguments that may appear in a function call. Specifically, for each function there are six properties that can be computed:

• The minimum number of arguments in total MinA.

• The maximum number of arguments in total MaxA.

• The minimum number of positional arguments MinP.

• The maximum number of positional arguments MaxP.

• The minimum number of keyword arguments MinK.

• The maximum number of keyword arguments MaxK.

The values of these properties are given by the following table, where A is the declared arity and R is the number of parameters that do not have a default value. The last parameter in a map-variadic or sequence-variadic value has an implicit default value, so it is not included in this count.

If two functions F and G in the static context have the same name, then both of the following conditions must be true:

• MinP(F) > MaxP(G) or MinP(G) > MaxP(F)

• MinK(F) > MaxK(G) or MinK(G) > MaxK(F)

In consequence, a function call with a known number of positional arguments and a known number of keyword arguments can never match more than one function in the static context.

Similarly, a named function reference such as fn#3 is a reference to a function in the static context with name fn having MinP ≤ 3 and MaxP ≥ 3, and there can be at most one such function.

Taking examples from the standard function library:

• The function fn:position takes no arguments. It has MinA=0, MaxA=0, MinP=0, MaxP=0, MinK=0, MaxK=0.

• The function fn:node-name is bounded-variadic. It has one optional argument, which can be supplied either by position or by keyword. It has MinA=0, MaxA=1, MinP=0, MaxP=1, MinK=0, MaxK=1.

• The function fn:format-date is bounded-variadic. It defines two required parameters (value and picture), followed by three optional parameters (language, calendar, and place). For all three optional parameters, the default value is an empty sequence. The function can be called with any number of positional arguments from 2 to 5. Alternatively the optional parameters can be supplied by keyword: for example format-date(current-date(), "[D1] [MNn] [Y0001]", place: "America/New_York"). It is also possible to supply the required parameters by keyword.

  The function thus has MinA=2, MaxA=5, MinP=0, MaxP=5, MinK=0, MaxK=5.

• The fn:concat function is sequence-variadic. This means that the function calls fn:concat("a", "b", "c"), fn:concat(("a", "b", "c")), and fn:concat(("a", "b"), "c") all have the same effect (delivering the result "abc"). Keyword arguments cannot be used with this function.

  The function thus has MinA=0, MaxA=unbounded, MinP=0, MaxP=unbounded, MinK=0, MaxK=0.

• The fn:serialize function is map-variadic. This means that the function call fn:serialize($doc, method: "xml", indent: true()) has the same effect as the function call fn:serialize($doc, map{"method":"xml", "indent":true()})

  The function thus has MinA=1, MaxA=unbounded, MinP=1, MaxP=2, MinK=0, MaxK=unbounded.

A static function call is bound to a function in the static context by matching the name and arity. If the function call has P positional arguments followed by K keyword arguments, then the static context must include a function whose name matches the name in the function call, and that satisfies all the following conditions:

• MinA ≤ P + K

• MaxA ≥ P + K

• MinP ≤ P

• MaxP ≥ P

• MinK ≤ K

• MaxK ≥ K

Similarly, a function reference of the form f#N binds to a function in the static context whose name matches f where MinP ≤ N and MaxP ≥ N. The result of evaluating a function reference is a (dynamic) function which can be invoked using a dynamic function call. Dynamic functions are never variadic and their arguments are always supplied positionally. For example, the function reference fn:concat#3 returns a function with arity 3, which is always invoked by supplying three positional arguments, and whose effect is the same as a static call on fn:concat with three positional arguments. The arity must not exceed the number of arguments that can be supplied positionally. Therefore, in the case of a function reference to a map-variadic functions such as fn:serialize#2, a dynamic call must supply the map-valued argument (the serialization parameters) in the form of a map; the function reference fn:serialize#3 is an error, because MaxP = 2.

The detailed rules for evaluating static function calls and function references are defined in subsequent sections.

4.4.2 Dynamic Functions

A dynamic function (or function, or function item) is an XDM value that can be bound to a variable, or manipulated in various ways by XPath 4.0 expressions. The most significant such expression is a dynamic function call, which supplies values of arguments and evaluates the function to produce a result.

The syntax of dynamic function calls is defined in 4.5.2 Dynamic Function Calls.

A number of constructs can be used to produce a dynamic function, notably:

• A named function reference (see 4.4.2.3 Named Function References) constructs a function that refers to a static function: for example fn:node-name#1 returns a function whose effect is to call the static fn:node-name function with one argument.

• An inline function (see 4.4.2.4 Inline Function Expressions) constructs a function whose implementation is defined locally. For example the construct ->($x){$x+1} returns a function whose effect is to increment the value of the supplied argument.

• A partial function application (see 4.4.2.2 Partial Function Application) derives one function from another by supplying the values of some of its arguments. For example, fn:ends-with(?, ".txt") returns a function with one argument that tests whether the supplied string ends with the substring ".txt".

• Maps and arrays are also functions. See 4.14.1.1 Map Constructors and 4.14.2.1 Array Constructors.

These constructs are described in detail in the following sections.

function($x as xs:integer, $y as xs:integer) as xs:integer {$x + $y}

function($x, $y) {$x + $y}

->($x, $y) {$x + $y}

fn:for-each-pair($A, $B, ->($a, $b) {$a + $b})

fn:for-each(1 to 5, ->{.+1})

4.4.3 Coercion Rules

[Definition: The coercion 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 coercion rules are applied to a given value as follows:

• In a static function call, if XPath 1.0 compatibility mode is true and an argument of a static function is not of the expected type, then the following conversions are applied sequentially to the argument value V:

  1. If the expected type calls for a single item or optional single item (examples: xs:string, xs:string?, xs:untypedAtomic, xs:untypedAtomic?, node(), node()?, item(), item()?), then the value V is effectively replaced by V[1].

  2. If the expected type is xs:string or xs:string?, then the value V is effectively replaced by fn:string(V).

  3. If the expected type is xs:double or xs:double?, then the value V is effectively replaced by fn:number(V).

  Note:

  XPath 1.0 compatibility mode has no effect on dynamic function calls, converting the result of an inline function to its required type, partial function application, or implicit function calls that occur when evaluating functions such as fn:for-each and fn:filter.

• If the expected type is a SequenceType whose ItemType is a generalized atomic type other than a union type or enumeration type, (possibly with an occurrence indicator *, +, or ?), then the following conversions are applied, in order:

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

  2. Each item in the atomic sequence that is of type xs:untypedAtomic is cast to the expected atomic type. If the expected atomic type is an EnumerationType, the value is cast to xs:string . If the item is of type xs:untypedAtomic and the expected type is namespace-sensitive, a type error [err:XPTY0117] is raised.

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

  4. For each item of type xs:anyURI in the atomic sequence that can be promoted to the expected atomic type using URI promotion as described in B.1 Type Promotion, the promotion is done.

  5. If the expected type is a sequence type whose item type is an atomic type D, where D is derived from the primitive type P, then any item in the atomic sequence that is an instance of P and that is within the value space of D is relabeled as an instance of D.

     Relabeling an atomic value changes the type annotation but not the value. For example, the xs:integer value 3 can be relabeled as an instance of xs:unsignedByte, because the value is within the value space of xs:unsignedByte.

     Relabeling is not the same as casting. For example, the xs:decimal value 10.1 can be cast to xs:integer, but it cannot be relabeled as xs:integer, because it is not within the value space of xs:integer.

     Note:

     The effect of this rule is that if, for example, a function parameter is declared with an expected type of xs:positiveInteger, then a call that supplies the literal value 3 will succeed, whereas a call that supplies -3 will fail.

     This differs from previous versions of this specification, where both these calls would fail.

     In principle this change allows the arguments of existing functions to be defined with a more precise type. For example, the $position argument of array:get could be defined as xs:positiveInteger rather than xs:integer. In practice, however, it is not always possible to do this, because it would change the error codes thrown when an invalid value is supplied.

     TODO: define the interaction of numeric promotion and relabeling. For example, required type = xs:unsignedByte, supplied value = xs:decimal 255.3.

• If the expected type is a RecordTest (possibly with an occurrence indicator *, +, or ?), then the supplied value must be a map or sequence of maps, and the values of any entries in these maps whose keys correspond to field declarations in the RecordTest are converted to the required type defined by that field declaration, by applying these rules recursively (but with XPath 1.0 compatibility mode treated as false).

  For example, if the required type is record(longitude as xs:double, latitude as xs:double) and the supplied value is map{"longitude": 0, "latitude":53.2}, then the map is converted to map{"longitude": 0.0e0, "latitude": 53.2e0}.

• If the expected type is a TypedFunctionTest (possibly with an occurrence indicator *, +, or ?), function coercion is applied to each function in the given value.

  Note:

  Maps and arrays are functions, so function coercion applies to them as well.

• If, after the above conversions, the resulting value does not match the expected type according to the rules for SequenceType Matching, a type error is raised [err:XPTY0004]. Note that the rules for SequenceType Matching permit a value of a derived type to be substituted for a value of its base type.

4.4.4 Function Coercion

Function coercion is a transformation applied to functions^DM31 during application of the coercion rules. [Definition: Function coercion wraps a function^DM31 in a new function whose signature is the same as the expected type. This effectively delays the checking of the argument and return types until the function is invoked.]

Function coercion is only defined to operate on functions^DM31. Given a function F, and an expected function type, function coercion proceeds as follows:

1. If F has higher arity than the expected type, a type error is raised [err:XPTY0004]

2. If F has lower arity than the expected type, then F is wrapped in a new function that declares and ignores the additional argument; the following steps are then applied to this new function.

   For example, if the expected type is function(node(), xs:boolean) as xs:string, and the supplied function is fn:name#1, then the supplied function is effectively replaced by function($n as node(), $b as xs:boolean) as xs:string {fn:name($n)}

   Note:

   This mechanism makes it easier to design versatile and extensible higher-order functions. For example, in previous versions of this specification, the second argument of the fn:filter function expected an argument of type function (item()) as xs:boolean. This has now been extended to function (item(), xs:integer) as xs:boolean, but existing code continues to work, because callback functions that are not interested in the value of the second argument simply ignore it.

   TODO: this change to fn:filter has not yet been made.

3. Function coercion then returns a new function with the following properties (as defined in Section 2.8.1 Functions ^DM31):

   • name: The name of F.

   • parameter names: The parameter names of F.

   • signature: Annotations is set to the annotations of F. TypedFunctionTest is set to the expected type.

   • implementation: In effect, a FunctionBody that calls F, passing it the parameters of this new function, in order.

   • nonlocal variable bindings: An empty mapping.

If the result of invoking the new function would necessarily result in a type error, that error may be raised during function coercion. It is implementation dependent whether this happens or not.

These rules have the following consequences:

• SequenceType matching of the function's arguments and result are delayed until that function is invoked.

• The coercion rules rules applied to the function's arguments and result are defined by the SequenceType it has most recently been coerced to. Additional coercion rules could apply when the wrapped function is invoked.

• If an implementation has static type information about a function, that can be used to type check the function's argument and return types during static analysis.

Since maps and arrays are also functions in XPath 4.0, function coercion applies to them as well. For instance, consider the following expression:

let $m := map {
  "Monday" : true(),
  "Wednesday" : true(),
  "Friday" : true(),
  "Saturday" : false(),
  "Sunday" : false()
},
$days := ("Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday")
return fn:filter($days,$m)
      

The map $m has a function signature of function(xs:anyAtomicType) as item()*. When the fn:filter() function is called, the following occurs to the map:

1. The map $m is treated as function ($f), equivalent to map:get($m,?).

2. The coercion rules result in applying function coercion to $f, wrapping $f in a new function ($p) with the signature function(item()) as xs:boolean.

3. $p is matched against the SequenceType function(item()) as xs:boolean, and succeeds.

4. When $p is invoked by fn:filter(), coercion and SequenceType matching rules are applied to the argument, resulting in an item() value ($a) or a type error.

5. $f is invoked with $a, which returns an xs:boolean or the empty sequence.

6. $p applies coercion rule and SequenceType matching to the result sequence from $f. When the result is an xs:boolean the SequenceType matching succeeds. When it is an empty sequence (such as when $m does not contain a key for "Tuesday"), SequenceType matching results in a type error [err:XPTY0004], since the expected type is xs:boolean and the actual type is an empty sequence.

Consider the following expression:

let $m := map {
   "Monday" : true(),
   "Tuesday" : false(),
   "Wednesday" : true(),
   "Thursday" : false(),
   "Friday" : true(),
   "Saturday" : false(),
   "Sunday" : false()
}
let $days := ("Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday")
return fn:filter($days,$m)
      

The result of the expression is the sequence ("Monday", "Wednesday", "Friday")

4.5.1 Filter Expressions

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

Here are some examples of filter expressions:

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

  $products[price gt 100]

• List all the integers from 1 to 100 that are divisible by 5. (See 4.7.1 Sequence Concatenation for an explanation of the to operator.)

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

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

  (21 to 29)[5]

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

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

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

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

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

For each item in the input sequence, the result of the predicate expression is coerced to an xs:boolean value, called the predicate truth value, as described below. Those items for which the predicate truth value is true are retained, and those for which the predicate truth value is false are discarded.

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

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

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

4.5.2 Dynamic Function Calls

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

A dynamic function call is evaluated as described in 4.4.2.1 Evaluating Dynamic Function Calls.

The following are examples of some dynamic function calls:

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

  $f(2, 3)

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

  $f[2]("Hi there")

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

  $f()[2]

4.6.1 Relative Path Expressions

A relative path expression is a path expression that selects nodes within a tree by following a series of steps starting at the context node (which, unlike an absolute path expression, may be any node in a tree).

Each non-initial occurrence of "//" in a path expression is expanded as described in 4.6.5 Abbreviated Syntax, leaving a sequence of steps separated by "/". This sequence of steps is then evaluated from left to right. So a path such as E1/E2/E3/E4 is evaluated as ((E1/E2)/E3)/E4. The semantics of a path expression are thus defined by the semantics of the binary "/" operator, which is defined in 4.6.1.1 Path operator (/).

The following example illustrates the use of relative path expressions.

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

4.6.2 Steps

[Definition: A step is a part of a path expression that generates a sequence of items and then filters the sequence by zero or more predicates. The value of the step consists of those items that satisfy the predicates, working from left to right. A step may be either an axis step or a postfix expression.] Postfix expressions are described in 4.5 Postfix Expressions.

[Definition: An axis step returns a sequence of nodes that are reachable from the context node via a specified axis. Such a step has two parts: an axis, which defines the "direction of movement" for the step, and a node test, which selects nodes based on their kind, name, and/or type annotation.] If the context item is a node, an axis step returns a sequence of zero or more nodes; otherwise, a type error is raised [err:XPTY0020]. 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 more predicates.

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

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

4.6.3 Predicates within Steps

A predicate within a Step has similar syntax and semantics to a predicate within a filter expression. The only difference is in the way the context position is set for evaluation of the predicate.

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

Here are some examples of axis steps that contain predicates:

• This example selects the second chapter element that is a child of the context node:

  child::chapter[2]

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

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

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

  child::employee[secretary][assistant]

4.6.4 Unabbreviated Syntax

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

4.6.5 Abbreviated Syntax

The abbreviated syntax permits the following abbreviations:

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

2. If the axis name is omitted from an axis step, the default axis is child, with two exceptions: (1) if the NodeTest in an axis step contains an AttributeTest or SchemaAttributeTest then the default axis is attribute; (2) if the NodeTest in an axis step is a NamespaceNodeTest then the default axis is namespace - in an implementation that does not support the namespace axis, an error is raised [err:XQST0134].

   Note:

   The namespace axis is deprecated as of XPath 2.0, but required in some languages that use XPath, including XSLT.

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

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

   Note:

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

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

   Note:

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