2.1.1 静的コンテキスト

[Definition: The static context of an expression is the information that is available during static analysis of the expression, prior to its evaluation.] This information can be used to decide whether the expression contains a static error. If analysis of an expression relies on some component of the static context that has not been assigned a value, a static error is raised [err:XPST0001].

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

• [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 set of (prefix, URI) pairs that define all the namespaces that are known during static processing of a given expression.] The URI value is whitespace normalized according to the rules for the xs:anyURI type in [XML Schema]. 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/type namespace. This is a namespace URI or "none". The namespace URI, if present, is used for any unprefixed QName appearing in a position where an element or type name is expected.] The URI value is whitespace normalized according to the rules for the xs:anyURI type in [XML Schema].

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

• [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 processing of an expression.] It includes the following three parts:

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

  • [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 [XML Schema] Part 1, Section 2.2.2.2. 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 set of (expanded QName, type) pairs. 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 (such as a for, some, or every expression) extends the in-scope variables of its subexpressions with the new bound variable and its type.

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

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

  The function signatures include the signatures of constructor functions, which are discussed in 3.10.4 Constructor Functions.

• [Definition: Statically known collations. This is an implementation-defined set of (URI, collation) pairs. 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 [XQuery 1.0 and XPath 2.0 Functions and Operators].]

• [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: Base URI. This is an absolute URI, used when necessary in the resolution of relative URIs (for example, by the fn:resolve-uri function.)] The URI value is whitespace normalized according to the rules for the xs:anyURI type in [XML Schema].

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

  Note:

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

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

2.1.2 動的コンテキスト

[Definition: The dynamic context of an expression is defined as information that is available at the time the expression is evaluated.] If evaluation of an expression relies on some part of the dynamic context that has not been assigned a value, a dynamic error is raised [err:XPDY0002].

The individual components of the dynamic context are summarized below. Further rules governing the semantics of these components can be found in C.2 Dynamic Context Components.

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

[Definition: The first three components of the dynamic context (context item, context position, and context size) are called the focus of the expression. ] The focus enables the processor to keep track of which items are being processed by the expression.

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

• [Definition: The context item is the item currently being processed. An item is either an atomic value or a node.][Definition: When the context item is a node, it can also be referred to as the context node.] The context item is returned by 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 set of (expanded QName, value) pairs. 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: Function implementations. Each function in function signatures has a function implementation that enables the function to map instances of its parameter types into an instance of its result type. ]

• [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 [XML Schema] for the range of legal values of a timezone.]

• [Definition: Available documents. This is a mapping of strings onto document nodes. The string represents the absolute URI of a resource. The document node is the root of a tree that represents that resource using the data model. The document node is returned by the fn:doc function when applied to that URI.] The set of available documents is not 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 collections. This is a mapping of strings onto sequences of nodes. The string represents the absolute URI of a resource. The sequence of nodes represents the result of the fn:collection function when that URI is supplied as the argument. ] The set of available collections is not 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 nodes that would result from calling the fn:collection function with no arguments.] The value of default collection may be initialized by the implementation.

2.2.1 データモデル生成

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

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

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

The above steps provide an example of how an XDM 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 is defined in terms of the data model, but it does not place any constraints on how XDM instances are constructed.

[Definition: Each element node and attribute node in an XDM instance has a type annotation (referred to in [XQuery/XPath Data Model (XDM)] as its type-name property.) The type annotation of a node is a schema type that describes the relationship between the string value of the node and its typed value.] If the XDM instance was derived from a validated XML document as described in Section 3.3 Construction from a PSVI^DM, the type annotations of the element and attribute nodes are derived from schema validation. XPath does not provide a way to directly access the type annotation of an element or attribute node.

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

The value of an element is represented by the children of the element node, which may include text nodes and other element nodes. The type annotation of an element node indicates how the values in its child text nodes are to be interpreted. An element that has not been validated (such as might occur in a schemaless document) is annotated with the schema type xs:untyped. An element that has been validated and found to be partially valid is annotated with the schema type xs:anyType. If an element node is annotated as xs:untyped, all its descendant element nodes are also annotated 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 スキーマインポート処理

2.2.3 式処理

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

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

2.2.4 直列化

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

2.2.5 一貫性制約

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

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

• 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 data model schema. Furthermore, all types that are derived by extension from the given type in the data model schema must also be known by equivalent definitions in the ISSD.

• For every element name EN that is found both in an XDM instance and in the in-scope schema definitions (ISSD), all elements that are known in the data model schema to be in the substitution group headed by EN must also be known in the ISSD to be in the substitution group headed by EN.

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

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

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

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

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

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

• For each (variable, type) pair in in-scope variables and the corresponding (variable, value) pair in variable values such that the variable names are equal, the value must match the type, using the matching rules in 2.5.4 SequenceType 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.

2.3.1 エラーの種類

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

[Definition: A static error is an error that must be detected during the static analysis phase. A syntax error is an example of a static error.]

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

[Definition: A type error may be raised during the static analysis phase or the dynamic evaluation phase. During the static analysis phase, a type error occurs when the static type of an expression does not match the expected type of the context in which the expression occurs. During the dynamic evaluation phase, 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 expression, if evaluated, would necessarily raise a type error or a dynamic error, the implementation may (but is not required to) report that error during the static analysis phase. However, the fn:error() function must not be evaluated during the static analysis phase.

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

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

2.3.2 エラーの報告と識別

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.

• 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 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 動的エラーの処理

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

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

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

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

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

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

A dynamic error can also be raised explicitly by calling the fn:error function, which only raises an error and never returns a value. This function is defined in [XQuery 1.0 and XPath 2.0 Functions and Operators]. 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 エラーと最適化

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

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

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

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

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

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

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

The effect of these rules is that the processor is free to stop examining further items in a sequence as soon as it can establish that further items would not affect the result except possibly by causing an error. For example, the processor may 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 are free to rewrite expressions into equivalent expressions. Other than the raising or not raising of errors, the result of evaluating an equivalent expression must be the same as the result of evaluating the original expression. Expression rewrite is illustrated by the following examples.

• 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. Conditional expressions raise only dynamic errors that occur in the branch that is actually selected. Thus, unlike the previous example, the following example cannot raise a dynamic error if @x is not castable into an xs:date:

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

2.4.1 ドキュメント順序

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

Document order is a total ordering, although the relative order of some nodes is implementation-dependent. [Definition: Informally, document order is the order in which nodes appear in the XML serialization of a document.] [Definition: Document order is stable, which means that the relative order of two nodes will not change during the processing of a given expression, even if this order is implementation-dependent.]

Within a tree, document order satisfies the following constraints:

1. The root node is the first node.

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

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

4. Attribute nodes immediately follow the namespace nodes of 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 原子化

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

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

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

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

Atomization is used in processing the following types of expressions:

• Arithmetic expressions

• Comparison expressions

• Function calls and returns

• Cast expressions

2.4.3 効果的なブール値

Under certain circumstances (listed below), it is necessary to find the 有効ブール値 of a value. [Definition: The 有効ブール値 of a value is defined as the result of applying the fn:boolean function to the value, as defined in [XQuery 1.0 and XPath 2.0 Functions and Operators].]

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

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

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

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

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

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

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

The 有効ブール値 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 入力ソース

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

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

The input functions supported by XPath are as follows:

• The fn:doc function takes a string containing a URI. If that URI is associated with a document in available documents, fn:doc returns a document node whose content is the data model representation of the given document; otherwise it raises a dynamic error (see [XQuery 1.0 and XPath 2.0 Functions and Operators] for details).

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

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

2.5.1 事前定義済みスキーマ型

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

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

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

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

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

   Note:

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

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

図 2: XPath で使用されているスキーマ階層

2.5.2 型に関連付けられた値と文字列値

あらゆるノードは型に関連付けられた値 (Typed Value) と文字列値 (String Value) を持つ。[定義: ノードの型に関連付けられた値とは原子値のシーケンスであり、ノードに fn:data 関数を適用することで取り出すことができる。] [定義: ノードの文字列値は文字列であり、ノードに fn:string を適用することによって取り出す事ができる。] fn:data と fn:string の定義は [XQuery 1.0 と XPath 2.0 関数および演算子] で行っている。

実装はノードの型に関連付けられた値と文字列値の両方を保持するかもしれないし、それらのうちの一つだけを保持しておいて他は必要に応じて取り出すかもしれない。ノードの文字列値はノードの型に関連付けられた値の有効な語彙式 (lexical representation) でなければならないが、ノードは元のソース文章からの文字列式を持ち続ける必要はない。例えば、ノードの型に関連付けられた値が xs:integer 値 30 であるなら、その文字列値は "30" または "0030" であろう。

読者への便宜として、さまざまな種類のノードに対する 型に関連付けられた値と文字列値の関係を下記でまとめて例示する。

1. テキストやドキュメントノードに対して xs:untypedAtomic 型のインスタンスとしてノードの型に関連付けられた値はその文字列値と等しい。ドキュメントノードの文字列値はそのすべての子孫テキストノードの文字列値をドキュメントで結合して作り出される。

2. コメント、名前空間および処理命令ノードの型に関連付けられた値はその文字列値と同じである。これは xs:string 型のインスタンスである。

3. 型注釈に xs:anySimpleType または xs:untypedAtomic が付属する属性ノードの型に関連付けられた値は xs:untypedAtomic のインスタンスとしてその文字列値と同じである。それ以外の型注釈が付けられた属性ノードの型に関連付けられた値は、関連した型に対して [XML Schema] Part 2 で定義されている lexical-to-value-space マッピングを使用している文字列値と型注釈から派生している。

   例: A1 は文字列値 "3.14E-2" を持つ属性であり型注釈が xs:double である。A1 の型に関連付けられた値はその論理式が 3.14E-2 である xs:double 値となる。

   例: A2 は型注釈 xs:IDREFS の付けられた属性であり、それは原子データ型 xs:IDREF のリストデータ型である。その文字列値が "bar baz faz" である。A2 の型に関連付けられた値は xs:IDREF 型の 3 つの原子値のシーケンス ("bar", "baz", "faz") である。ノードの型に関連付けられた値が named リスト型のインスタンスと扱われることは決してないが、もしノードの型注釈がリスト型なら (xs:IDREFS のような)、その型に関連付けられた値は由来する原子型のシーケンスとして扱われる (xs:IDREF のような)。

4. 要素ノードに対して、型に関連付けられた値と文字列値との関係は以下のようにノードの型注釈に依存している:

   1. 型注釈が xs:untyped、xs:anySimpleType または混合内容 (xs:anyTypeを含む) の複合型の場合、ノード型に関連付けられた値はその文字列値と等しい xs:untypedAtomic のインスタンスとなる。ただし、ノードの nilled プロパティが true ならその型に関連付けられた値は空シーケンスである。

      例: E1 は型注釈 xs:untyped で文字列値 "1999-05-31" を持つ要素ノードである。E1 の型に関連付けられた値は "1999-05-31" となる xs:untypedAtomic のインスタンスである。

      例: E2 は型注釈 formula を持つ要素ノードであり、混合内容の複合型である。E2 の内容は文字 "H"、内容に文字列値 "2" を持つ subscript という名前の子要素、文字 "O" で構成されている。E2 の型に関連付けられた値は "H2O" という xs:untypedAtomic のインスタンスである。

   2. 型注釈が単純型 (simple type)、あるいは単純内容 (simple content) を持つ複合型 (complex type) ならば、ノードの型に関連付けられた値はその文字列値とスキーマ検証と一致している型注釈に由来している。ただし nilled プロパティに true が設定されているなら型に関連付けられた値は空シーケンスとなる。

      例: E3 は cost 型注釈を持つ要素ノードであり、いくつかの属性と xs:decimal の簡単な型を持つ複合型である。E3 の文字列値は 74.95 である。E3 の型に関連付けられた値は xs:decimal インスタンスの 74.95 である。

      例: E4 は原子型 hatsize から単純に派生した hatsizelist 型注釈を持つ要素ノードであり、さらにそれは xs:integer から派生している。E4 の文字列値は "7 8 9" である。E4 の型に関連付けられた値は 3 つの値 (7, 8, 9) のシーケンスであり、それぞれの型は hatsize である。

      例: E5 は xs:integer と xs:string 型メンバを持つユニオン型の my:integer-or-string 型注釈要素ノードである。E5 の文字列値が "47" の時、xs:ineger が E5 の内容として有効なメンバ型のため、E5 の型に関連付けられた値は xs:integer の 47 である。一般に、ノードの型注釈がユニオン型の場合、ノードの型に関連付けられた値はユニオンメンバ型の一つのインスタンスとなるだろう。

      Note:

      もし実装がノードの文字列値のみを保持し、ノードの型注釈がユニオン型であるなら、実装は適切なメンバ型のインスタンスとしてノードの型に関連付けられた値を変換できなければならない。

   3. もし型注釈が空の内容を持つ複合型を示すなら、ノードの型に関連付けられた値は空のシーケンスであり、文字列値は長さ 0 の文字列である。

   4. もし型注釈が要素のみの内容を持つ複合型を示している場合、ノードの型に関連付けられた値は未定義である。fn:data 関数がそのようなノードに適用された場合、型エラー [err:FOTY0012] が発生する。そのようなノードの文字列値は、そのすべての子孫テキストノードをドキュメント順序で連結した文字列値と等しい。

      例: E6 は element-only と指定された内容型の複合型を持つ型注釈 weather の要素ノードである。E6 は temprture (気温) と precipitation (降水量) という名前の 2 つの要素を持っている。このとき E6 の型に関連付けられた値は未定義であり、E6 への fn:data 関数の適用はエラーとなる。

2.5.3 SequenceType 構文

XPath 式では、型を参照する必要があるときはいつでも SequenceType 構文が使用される。

特別な型 empty-sequence() を除いて、シーケンス型はシーケンスの項目それぞれの型を制約する項目方 (Item Type) と、シーケンス内での項目の数を制約する要素数 (Cardinality) で構成されている。どのような種類の項目でも許可する item() 型項目は別として、項目型は (element() のような) ノード型 (Node Type)、または (xs:integer のような) 原子型 (Atomic Type) に分けられる。

要素と属性ノードを表している項目型は、スキーマ型の形式でこれらのノードの必須型注釈を指定することができる。従って、項目型 element(*, us:address) は型注釈 us:address という名前のスキーマ型である (あるいはそれから派生した) どの要素ノードも表している。

ここで XPath 式で使用される可能性のある シーケンス型のいくつかの例を挙げる:

• xs:date は xs:date という名前のビルトイン原子スキーマ型を参照する

• attribute()? は省略可能な属性ノードを参照する

• element() 任意数の要素ノードを参照する

• element(po:shipto, po:address) は po:shipto という名前で po:address という型注釈 (または po:address から派生したスキーマ型) を持つ一つの要素ノードを参照する

• element(*, po:address) は任意の名前で po:address という型注釈 (または po:address から派生したスキーマ型) を持つ一つの要素ノードを参照する

• element(customer) は customer という名前で任意の型注釈を持つ一つの要素ノードを参照する

• schema-element(customer) は、customer という名前 (または customer から始まる置換 (代理? Substitution) グループ) で、スコープ内要素宣言の customer 要素に対して宣言されているスキーマ型と一致する型注釈を持つ要素ノードを参照する

• node()* は任意の種類で 0 個以上のノードのシーケンスを参照する

• item()+ は 1 つ以上の原子値のシーケンスを参照する

2.5.4 SequenceType マッチング

[定義: 式を評価している時、しばしば既知の動的型を持つ値が期待するシーケンス型と "一致" しているかどうかを評価する必要性が出てくる。この処理はSequeceType マッチング (SequenceType Matching) と言う。] 例えば instance of 式は、与えられた値の動的型が与えられたシーケンス型と一致する場合 true を返すし、そうでなければ false を返す。

シーケンス型に出現する QName は、静的で既知の名前空間と (該当するなら) デフォルトの要素/型名前空間によって、名前空間 URI に展開される接頭辞を持っている。接頭辞の付けられていない属性 QName は特定の名前空間には所属しない。QName の等価性は eq 演算子によって定義される。

SequenceType マッチングの規則は、値の動的型と、それから期待するシーケンス型とを比較する。これらの規則は、Formal Semantics が値に対して SequenceType 構文を使用して式できない型と比較できなければいけないため、[XQuery 1.0 and XPath 2.0 Formal Semantics] で定義されている予期した型の値に一致する公式規則のサブセットである。

SequenceType マッチングに対する規則のいくつかは、与えられたスキーマ型が同じであるか、期待したスキーマ型から派生したものかを決定する必要がある。与えられたスキーマ型は (スコープ内スキーマ定義で定義されている) "既知" (known)、または (スコープ内スキーマ定義で定義されていない) "未知" (unknown) であろう。例えばソース文章が静的コンテキストにインポートされなかったスキーマを使って検証されているなら、未知のスキーマ型を検出することもありうる。この場合、実装は未知のスキーマ型が期待したスキーマ型から派生したものかどうかを決定するために実装依存メカニズムを提供することができる (必須ではない)。例えば、型階層に関する情報のデータディクショナリを実装で保持するかもしれない。

[定義: 期待した型から派生した動的型の値の使用はサブタイプ代入 (Subtype Substitution) と言う。] サブタイプ代入は値の実際の型を変更しない。例えば、xs:decimal 値を期待している部分で xs:integer 値が使用された場合、その値は xs:integer 型で保持される。

SequenceType マッチングは擬似関数 derives-from(AT, ET) を使用している。これは実際の単純スキーマ型または複合スキーマ型 AT と、期待する単純または複合スキーマ型 ET を取り、boolean 値か 型エラー [err:XPTY0004] を発生させる。擬似関数 derives-from は下記で定義し、公式には [XQuery 1.0 and XPath 2.0 Formal Semantics] で定義する。

• ET が既知の型で以下の条件の一つでも真となるなら derives-from(AT, ET) は true を返す:

  1. AT がスコープ内スキーマ定義に存在するスキーマであり、ET と同じか ET からの制約 (restriction) か拡張 (extension) として派生している

  2. AT がスコープ内スキーマ定義に存在しないスキーマであり、実装依存のメカニズムが AT が ET からの制約 (restriction) から派生していると確定できる

  3. derives-from(IT, ET) と derives-from(AT, IT) が共に真となるようなスキーマ型 IT が存在する

• もし ET が既知の型であり、下記の 1 と 3、または 2 と 3 が真となるなら、 derives-from(AT, ET) は false を返す:

  1. AT がスコープ内スキーマ定義に存在するスキーマ定義であり、ET と異なり、かつ ET から制約 (restriction) あるいは拡張 (extension) で派生した型でもない

  2. AT はスコープ内スキーマ定義に存在しないスキーマ型であり、実装依存メカニズムが AT が ET の制約 (restriction) から派生していないと確定できる

  3. derives-from(IT, ET) と derives-from(AT, IT) が真となるようなスキーマ型 IT が存在しない

• 以下の状況で derives-from(AT, ET) は型エラー [err:XPTY0004] を発生する:

  1. ET の型が不明、または

  2. AT の型が不明であり、AT が ET から制約 (restriction) 二よって派生しているかどうかを実装が決定できない

SequenceType マッチングに対する規則および例を下記に記述する (例は説明を目的としており、考えうるすべてのケースをカバーしているわけではない)。

3.1.1 リテラル

[定義: リテラル (literal) は原子値の直接的な統語式である。] XPath では 2 種類のリテラルをサポートしている。

"." や e、E の文字を含んでいない数値リテラル (Numeric Literal) の値は xs:integer 型の原子値である。"." を含むが e や E は含まない数値リテラルの値は xs:decimal 型の原子値である。e や E の文字を含む数値リテラルは xs:double 型の原子値である。数値リテラルの値は、xs:untypedAtmic から セクション 17.1.1 xs:string および xs:untypedAtmic からのキャスト^FO で詳述しているような数値型へのト規則に従った適切な型へのキャストによって決定される。

文字列リテラル (String Literal) の値は xs:string の型を持ち、アポストロフィまたはダブルクォートで囲まれることで意味付けされる文字列の原子値である。リテラルがアポストロフィによって区切られるなら、リテラル内の 2 つの連続したアポストロフィは単一のアポストロフィ文字として解釈される。同様にダブルクォートで区切られているなら 2 つの連続したダブルクォートは単一のダブルクォート文字として解釈される。

リテラル式の例をいくつか示す:

• "12.5" は '1'、'2'、'.'、'5' で構成される文字列を意味する。

• 12 は xs:integer 値の 12 を意味する。

• 12.5 は xs:decimal 値の 12.5 を意味する。

• 125E2 は xs:double 値の 125×10² (12,500) を意味する。

• "He said, ""I don't like it.""" は 2 つのダブルクォートと 1 つのアポストロフィを含む文字列を意味する。

  Note:

  XML 属性のような、これらの引用記号に特別な意味を持たせているコンテキストに XPath 式を埋め込む場合、更なるエスケープが必要となるだろう。

xs:boolean 値 true と false はそれぞれビルトイン関数 fn:true() と fn:false() を呼ぶことで表すことができる。

その他の原子型は所定の型のコンストラクタ関数を呼ぶことで構築することができる。XML Schema ビルトイン型に対するコンストラクタ関数は [XQuery 1.0 と XPath 2.0 関数および演算子] で定義されている。一般に、所定の型のコンストラクタ関数の名前は (その名前空間も含めて) 型の名前と同じである。例えば:

• xs:integer("12") は整数値 12 を返す。

• xs:date("2001-08-25") は xs:date 型で値が 2001 年 8 月 25 日を表す項目を返す。

• xs:dayTimeDuration("PT5H") は型が xs:dayTimeDuration で値が 5 時間を表す項目を返す。

コンストラクタ関数は、以下の例のようにリテラル式でない特別な値を作り出すために使うこともできる:

• xs:float("NaN") は浮動小数点の特別な値 "Not a Number" を返す。

• xs:double("INF") は倍精度浮動小数点の特別な値 "正の無限" を返す。

cast 式を使用することによってさまざまな型の値を構築することもできる。例えば:

• 9 cast as hatsize は hatsize 型の原子値 9 を返す。

3.1.2 変数参照

[定義: 変数参照 (Variable Reference) は $ 記号に続く QName である。] ローカル名が同じで、双方の名前空間接頭辞が同じ静的に既知の名前空間 URI に関連付けられているなら、それら 2 つの変数参照は同じである。接頭辞の付けられていない変数参照は名前空間に属さない。

あらゆる変数参照は スコープ内変数の名前と一致しなければならない。スコープ内変数は以下のソースからの変数を含んでいる:

1. スコープ内変数は実装定義変数によって増やすことができる。

2. 変数は XPath 式に結び付ける (bind) ことができる。変数に結び付けられた式種別は for 式 (3.7 for 式) と定量式 (3.9 定量式) である。

あらゆる変数バインディングは静的スコープを持つ。スコープは変数への参照が正しく見出される範囲を定義する。スコープに存在しない変数参照は 静的エラー [err:XPST0008] である。変数が式に対す静的コンテキストに結び付けられているなら、その変数は式の全体をスコープとして持っている。

もし変数参照がスコープ内の複数の変数バインディングと一致するなら、より小さいスコープを持つ、内々のバインディングの参照が選択される。変数バインディングのスコープは変数を結び付けられる式種別の各々で別に定義される。

3.1.3 括弧付けされた式

括弧は複数の演算子を持つ式において特定の優先順位を強いるのに使用することができる。例えば (2 + 4) * 5 は、先に括弧式 (2 + 4) が評価されてから 5 がかかるため 30 という結果になる。括弧がなければ加算演算子より乗算演算子が優先されるため、式 2 + 4 * 5 は 22 という結果になる。

中身のない括弧は 3.3.1 Constructing Sequences で詳述されている空シーケンスを意味する。

3.1.4 コンテキスト項目式

コンテキスト項目式 (Context Item Expression) はコンテキスト項目を評価し、それは (fn:doc("bib.xml")/books/book[fn:count(./author)>1] のような) ノード、または ((1 to 100)[. mod 5 eq 0] のような) 原子値である。

もしコンテキスト項目が定義されていないなら、コンテキスト項目式は動的エラー [err:XPDY0002] が発生する。

3.1.5 関数呼び出し

[定義: XPath がサポートしているビルトイン関数は [XQuery 1.0 と XPath 2.0 関数および演算子] で定義している。] 追加の関数が静的コンテキスト 追加の関数が functions may be provided in the 静的コンテキストで提供されるかもしれない。当然 XPath では関数を宣言する方法は提供しないが、ホスト言語でそのメカニズムを提供することができる。

関数呼び出し (Function Call) は、QName とそれに続く引数 (Argument) と呼ばれる 0 以上の式を連ねた括弧で構成されている。もし関数呼び出しの QName が名前空間接頭辞を持たないならデフォルトの関数名前空間であると見なされる。

関数呼び出しにおける展開 QName と引数の数が 静的コンテキスト内のどの関数シグネチャの名前および引数の数とも一致しない場合は静的エラー [err:XPST0017] が発生する。

関数呼び出しは以下のように評価される:

1. 引数の値を得るために引数式が評価される。引数の評価順序は実装依存であり、引数の評価を行うことなしに内部を実行する事ができるなら、関数は引数を評価する必要がない。

2. それぞれの引数値は後述の関数変換規則を適用することで変換される。

3. 関数は変換された引数値を使用して評価される。結果は関数で宣言されているリターン型か、もしくは動的エラーである。実行結果の動的型は宣言されたリターン型から派生した型とすることができる。関数で発生するエラーは [XQuery 1.0 と XPath 2.0 関数お呼び演算子] で定義している。

関数変換規則 (Fnction Conversion Rule) は引数値を関数が期待する型－つまり関数パラメータで宣言した型に変換するために使用される。期待する型はシーケンス型として表される。関数変換規則は以下の所定の値に適用される:

• もし XPath 1.0 互換モードが true かつ引数が期待した型でないなら、引数値 V に対して以下の変換が順に適用される:

  1. 期待した型が単一項目または省略可能な単一項目を必要とする場合 (例: xs:string, xs:string?, xs:untypedAtomic, xs:untypedAtomic?, node(), node()?, item(), item()?)、値 V は V[1] として有効に置き換えられる。

  2. もし期待する型が xs:string や xs:string? の場合、値 V は fn:string(V) によって有効に置き換えられる。

  3. 期待する型が xs:double や xs:double? の場合、値 V は fn:number(V) によって有効に置き換えられる。

• 期待した型が原子型のシーケンス (繰り返し指示 *、+、? かもしれない) の場合、以下の変換が適用される:

  1. 与えられた値に原子化が適用され、原子値のシーケンスをもたらす。

  2. xs:untypedAtomic 型の原子シーケンスのそれぞれの項目を期待した原子型にキャストする。数値として指定された型を期待しているビルトイン関数に対しては xs:untypedAtomic 型の引数は xs:double にキャストされる。

  3. B.1 型昇格で詳述されるような数値昇格を使用する、期待する原子型に昇格可能な原子シーケンスの数値項目それぞれに対しては昇格が行われる。

  4. B.1 型昇格で詳述されているような URI 昇格を使用する、期待する原子型に昇格可能な原子シーケンスの xs:anyURI 型項目それぞれに対しては昇格が行われる。

• 上記の変換後、結果として生じる値が SequenceType マッチングの規則に従って期待する型と一致しなければ、型エラー [err:XPTY0004] が発生する。SequenceType マッチングに対する規則では、派生型の値を基本型の値に代入できることに注意すること。

関数呼び出しの引数がコンマで区切られているため、トップレベルにコンマ演算子を持つ引数式を括弧内に含むことはできない。ここで関数呼び出しの実例をいくつか挙げる:

• my:three-argument-function(1, 2, 3) は 3 つの引数を持つ関数呼び出しを意味している。

• my:two-argument-function((1, 2), 3) は 2 つの引数を持つ関数呼び出しを意味しており、その最初のものは 2 つの値のシーケンスである。

• my:two-argument-function(1, ()) は 2 つの引数を持つ関数呼び出しを意味しており、その 2 つ目は空シーケンスである。

• my:one-argument-function((1, 2, 3)) は 3 つの値を持つシーケンスの引数 1 つの関数呼び出しを意味している。

• my:one-argument-function(( )) は空シーケンスを 1 つ持つ関数呼び出しを意味している。

• my:zero-argument-function( ) は引数を持たない関数呼び出しを意味している。

3.2.1 ステップ

[定義: ステップ (Step) は項目のシーケンスを生成し、0 個以上の述部 (Predicate) によってシーケンスをフィルタするパス式の一部である。ステップの値は述部の条件を満たす項目で構成されており、左から右に機能する。ステップは軸ステップかフィルタ式のどちらかとなりうる。] フィルタ式は 3.3.2 フィルタ式 で詳述する。

[定義: 軸ステップ (Axis Step) は指定された軸を経由してコンテキストノードから到達可能なノードのシーケンスを返す。このようなステップは 2 つの部分を持っている: ステップの "展開方向" を定義する軸 (Axis)、そしてノードの種類、名前、型注釈に基づいてノードを選択するノード判定である。] もしコンテキスト項目がノードなら、軸ステップは 0 個以上のノードのシー消すを返す; そうでなければ 型エラー [err:XPTY0020] が発生する。結果として生じるノードシーケンスはドキュメント順序で返される。軸ステップは 0 個以上の述部が続く順方向ステップ (Forward Step) あるいは逆方向ステップ (Reverse Step) のどちらかとなりうる。

ステップに対する省略構文 (Abbreviated Syntax) において軸は省略することができ、また3.2.4 Abbreviated Syntax で詳述するように他の略称表記を使用することができる。

軸ステップの省略されていない構文は二重 ( ふたえ )()のコロンで区切られた軸名とノード判定構成される。ステップの結果は、ノード判定で記述されたノードの種類、名前、それに型注釈を持つ指定された軸を経由した、コンテキストノードから到達可能なノードで構成される。例えば、ステップ child::para はコンテキストノードの子の para 要素を選択する: child は軸の名前であり、para はこの軸で選択される要素ノードの名前である。利用可能な軸は 3.2.1.1 軸 で、ノード判定は 3.2.1.2 ノード判定 で詳述する。またステップの例は 3.2.3 省略されていない構文 と 3.2.4 省略構文 で示す。

3.2.2 述部

[定義: 述部 (Predicate) は述部式 (Predicate Expression) と呼ばれる式で構成されており、角括弧で囲まれる。述部はシーケンス中のいくつかの項目を保持し他を捨てるフィルタとして使用される。複数の述部が隣接している場合、述部は左から右に適用され、個々の述部を適用した結果は後の述部への入力シーケンスとして使用される。

入力シーケンス中のそれぞれの項目に対して、述部は以下に定義するように内部フォーカス (Inner Focus) を使用して評価される: コンテキスト項目は述部によって現在評価されている項目である。コンテキストサイズは入力シーケンスの項目数である。コンテキストポジションは入力シーケンス内でのコンテキスト項目の位置である。述部内のコンテキストポジションを評価する目的で、入力シーケンスは以下のようにソートされると考えられる: 述部が前方軸ステップにあるならドキュメント順序、述部が後方軸ステップにあるなら逆ドキュメント順序、述部がステップにないなら元々の順序。

入力シーケンスのそれぞれの項目に対して、述部式の結果は後述するように述部真理値 (Predicate Truth Value) と呼ばれる xs:boolean 値を強制する。述部真理値が true となる項目のみが残され、false となるものは捨てられる。

述部真理値は以下の規則を順に適用することでもたらされる:

1. もし述部式の値が数値型かその派生型の単体原子値であり、述部式の値が評価項目のコンテキストポジション (Context Position) と演算子 eq で等しいなら、述部真理値は true である。そうでなければ false である。 [定義: 数値型を返す述部式の述部は数値述部 (Numeric Predicte) と呼ばれる。]

2. 数値型でないなら述部真理値は述部式の有効ブール値である。

以下は述部を含んでいる軸ステップの例である:

• コンテキストノードの子であり chapter 要素の 2 番目を選択する例:

  child::chapter[2]
  

• コンテキストノードの子孫で名前が "toy" で color 属性が "red" の全ての要素を選択する例:

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

• コンテキストノードの子で、子に secretary 要素と assistant 要素の両方を持つ employee という名前の全ての要素を選択する例:

  child::employee[secretary][assistant]
  

3.2.3 省略されていない構文

このセクションではそれぞれのステップで軸を明示的に指定するパス式のいくつかの例を示す。これらの例で使用する構文は省略されていない構文 (Unabbreviated Syntax) と呼ばれる。よく使われる例の多くは3.2.4 省略構文で説明する省略構文 (Abbreviated Syntax) を使ったより簡潔なパス式で書くことが可能である。

• child::para はコンテキストノードの子で para という名の要素を選択する。

• child::* はコンテキストノードの全ての子要素を選択する。

• child::text() はコンテキストノードの子テキストノードを選択する。

• child::node() はコンテキストノードの全ての子を選択する。属性は子ではないため属性ノードは選択対象ではないことに注意。

• attribute::name はコンテキストノードの name という名の属性を選択する。

• attribute::* はコンテキストノードの全ての属性を選択する。

• parent::node() はコンテキストノードの親を選択する。もしコンテキストノードが属性の場合、この構文はその属性ノードが付属する要素ノード (あるなら) を返す。

• descendant::para は名前が para であるコンテキストノードの子孫要素を選択する。

• ancestor::div はコンテキストノードの全ての div 祖先を選択する。

• ancestor-or-self::div はコンテキストノードに対する div という名前の祖先と、もしコンテキストノードが div 要素ならコンテキストノードも選択する。

• descendant-or-self::para はコンテキストノードに対する para という名前の子孫と、もしコンテキストオードが para 要素ならコンテキストノードも選択する。

• self::para はコンテキストノードが para 要素ならそれを選択するが、そうでなければ空のシーケンスを返す。

• child::chapter/descendant::para はコンテキストノードの子要素 chapter の子孫である para を選択する。

• child::*/child::para はコンテキストノードの孫となる全ての para 要素を選択する。

• / はコンテキストノードが所属しているツリーのルートを選択するが、ルートが文章ノードでないなら動的エラーが発生する。

• /descendant::para はコンテキストノードと同じ文章に所属する全ての para 要素を選択する。

• /descendant::list/child::member はコンテキストノードと同じ文章に所属し、親に list を持つ全ての member 要素を選択する。

• child::para[fn:position() = 1] はコンテキストノードで最初の子 para 要素を選択する。

• child::para[fn:position() = fn:last()] はコンテキストノードで最後の子 para 要素を選択する。

• child::para[fn:position() = fn:last()-1] はコンテキストノードで最後から 2 番目の子 para 要素を選択する。

• child::para[fn:position() > 1] はコンテキストノードの子で最初の para 要素以外の para 要素を選択する。

• following-sibling::chapter[fn:position() = 1] はコンテキストノードの兄弟で後ろに存在する最初の chapter 要素を選択する。

• preceding-sibling::chapter[fn:position() = 1] はコンテキストノードの兄弟で前に存在する最初の chapter 要素を選択する。

• /descendant::figure[fn:position() = 42] はコンテキスト要素が所属する文章内で 42 番目の figure 要素を選択する。

• /child::book/child::chapter[fn:position() = 5]/child::section[fn:position() = 2] はコンテキストノードが所属する文章のルートである book 要素の 5 番目の chapter 要素の 2 番目の section 要素を選択する。

• child::para[attribute::type eq "warning"] はコンテキストノードの子で para という名前を持ち、その type 属性が warning の全ての要素を選択する。

• child::para[attribute::type eq 'warning'][fn:position() = 5] はコンテキスト属性の子 para 要素で、type 属性に warning を持つものの 5 番目を選択する。

• child::para[fn:position() = 5][attribute::type eq "warning"] はコンテキストノードの 5 番目の子 para 要素で、もしその type 属性が warning ならそれを選択する。

• child::chapter[child::title = 'Introduction'] はコンテキストノードの子で、型に関連付けられた値が文字列 Introduction と等しい一つ以上の title 子要素を持つ chapter 要素を選択する。

• child::chapter[child::title] はコンテキストの子で一つ以上の title 要素を持つ chapter 要素を選択する。

• child::*[self::chapter or self::appendix] はコンテキストノードの子で chapter と appendix 要素の全てを選択する。

• child::*[self::chapter or self::appendix][fn:position() = fn:last()] はコンテキストノードの子で chapter または appendix 要素の最後の 1 つを選択する。

3.2.4 省略構文

省略構文 (Abbreviated Syntax) は以下の省略形を許可する

1. 属性軸 attribute:: は @ と省略される。例えば、パス式 para[@type="warning"] は child::para[attribute::type="warning"] の短縮であり、type 属性が warning である子要素 para を選択する。

2. 軸名ステップから軸名が省略されている場合のデフォルトの軸は child である; ただし軸ステップが AttributeTest や SchemaAttributeTest を含んでる場合は attribute である。例えば、パス式 section/para は child::section/child::para の省略形であり、同様に section/attribute(id) は child::section/attribute::attribute(id) の省略形である。後者の式が軸指定とノード判定の両方を含んでいることに注意。

3. 先頭ではない位置に出現する // のそれぞれは、パス式の処理中は /descendant-or-self::node()/ と置き換えられる。例えば、div1//para は child::div1/descendant-or-self::node()/child::para の短縮形であり、div1 の子の子孫である全ての para を選択する。

   Note:

   パス式 //para[1] はパス式 /descendant::para[1] と同じ意味ではない。後者は最初の子孫 para 要素のみを選択するが、前者は子孫 para 要素のうち、自分の親に対して最初の子 para 要素である全ての最初の子 para 要素を選択する。

4. .. で構成されるステップは parent::node の短縮形である。例えば、../title は para::node()/child::title の短縮形であり、コンテキストノードの親に対して子の title 要素を選択する。

   Note:

   コンテキスト項目式 (Context Item Expression) として知られる式 . は第一式であり、3.1.4 Context Item Expression で詳述している。

以下は省略構文を用いたパス式の例である:

• para はコンテキストノードの子 para 要素を選択する。

• * はコンテキストノードの全ての子要素を選択する

• text() はコンテキストノードの全てのテキストノードを選択する。

• @name はコンテキストノードの name 属性を選択する。

• @* はコンテキストノードの全ての属性値選択する。

• para[1] はコンテキストノードの最初の para 要素を選択する。

• para[fn:last()] はコンテキストノードの最後の para 要素を選択する

• */para はコンテキストノードの全ての孫 para 要素を選択する。

• /book/chapter[5]/section[2] はコンテキストノードの所属する文章ノードを親に持つ book の 5 番目の chapter の 2 番目の section を選択する。

• chapter//para はコンテキストノードの子 chapter 要素の子孫 para 要素を選択する。

• //para は文章ノードの全ての子孫 para 要素、つまりコンテキストノードが所属する文章の全ての para 要素を選択する。

• //@version はこのコンテキストノードが所属するドキュメント内の全ての version 属性を選択する。

• //list/member はコンテキストノードが所属する文章内で list を親に持つ全ての member 要素を選択する。

• .//para はコンテキストノードの子孫 para 要素を選択する。

• .. はコンテキストノードの親を選択する。

• ../@lang はコンテキストノードの親の lang 属性を選択する。

• para[@type="warning"] はコンテキストノードの子で属性 type に値 warning を持つ全ての para 要素を選択する。

• para[@type="warning"][5] はコンテキストノードの子で属性 type に値 warning を持つ 5 番目の para 要素を選択する。

• para[5][@type="warning"] はコンテキストノードの 5 番目の子 para 要素が属性 type に値 warning を持つならそれを選択する。

• chapter[title="Introduction"] はコンテキストノードの子で、型に関連付けられた値が文字列 Introduction と等しい一つ以上の子 title 要素を持っている chapter 要素を選択する。

• chapter[title] はコンテキストノードの子で一つ以上の子 title 要素を持っている chapter 要素を選択する。

• employee[@secretary and @assistant] はコンテキストノードの子で secretary 属性と assistant 属性の両方を持つ employee 要素を選択する。

• book/(chapter|appendix)/section はコンテキストノードの子 book 要素の子で chapter または appendix 要素の子 section 要素を選択する。

• もし E がノードのシーケンスを返す式なら、式 E/. はドキュメント順序で同じノードを返す。

3.3.1 シーケンスの構築

[Definition: One way to construct a sequence is by using the comma operator, which evaluates each of its operands and concatenates the resulting sequences, in order, into a single result sequence.] Empty parentheses can be used to denote an empty sequence.

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

Here are some examples of expressions that construct sequences:

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

  (10, 1, 2, 3, 4)
  

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

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

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

  (salary, bonus)
  

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

  ($price, $price)
  

A range expression can be used to construct a sequence of consecutive integers. Each of the operands of the to operator is converted as though it was an argument of a function with the expected parameter type xs:integer?. If either operand is an empty sequence, or if the integer derived from the first operand is greater than the integer derived from the second operand, the result of the range expression is an empty sequence. If the two operands convert to the same integer, the result of the range expression is that integer. Otherwise, the result is a sequence containing the two integer operands and every integer between the two operands, in increasing order.

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

  (10, 1 to 4)
  

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

  10 to 10
  

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

  15 to 10
  

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

  fn:reverse(10 to 15)
  

3.3.2 フィルタ式

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

Here are some examples of filter expressions:

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

  $products[price gt 100]
  

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

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

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

  (21 to 29)[5]
  

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

• The following example also illustrates the use of a filter expression as a step in a path expression. It returns the element node within the specified document whose ID value is tiger:

  fn:doc("zoo.xml")/fn:id('tiger')
  

3.3.3 Combining Node Sequences

XPath provides the following operators for combining sequences of nodes:

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

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

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

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

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

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

• $seq1 is bound to (A, B)

• $seq2 is bound to (A, B)

• $seq3 is bound to (B, C)

Then:

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

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

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

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

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

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

In addition to the sequence operators described here, [XQuery 1.0 and XPath 2.0 Functions and Operators] includes functions for indexed access to items or sub-sequences of a sequence, for indexed insertion or removal of items in a sequence, and for removing duplicate items from a sequence.

3.5.1 Value Comparisons

The value comparison operators are eq, ne, lt, le, gt, and ge. Value comparisons are used for comparing single values.

The first step in evaluating a value comparison is to evaluate its operands. The order in which the operands are evaluated is implementation-dependent. Each operand is evaluated by applying the following steps, in order:

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

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

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

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

   Note:

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

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

Finally, if the types of the operands are a valid combination for the given operator, the operator is applied to the operands. The combinations of atomic types that are accepted by the various value comparison operators, and their respective result types, are listed in B.2 Operator Mapping together with the operator functions that define the semantics of the operator for each type combination. The definitions of the operator functions are found in [XQuery 1.0 and XPath 2.0 Functions and Operators].

Informally, if both atomized operands consist of exactly one atomic value, then the result of the comparison is true if the value of the first operand is (equal, not equal, less than, less than or equal, greater than, greater than or equal) to the value of the second operand; otherwise the result of the comparison is false.

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

Here are some examples of value comparisons:

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

  $book1/author eq "Kennedy"
  

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

  //product[weight gt 100]
  

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

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

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

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

3.5.2 General Comparisons

The general comparison operators are =, !=, <, <=, >, and >=. General comparisons are existentially quantified comparisons that may be applied to operand sequences of any length. The result of a general comparison that does not raise an error is always true or false.

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

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

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

   1. If one of the atomic values is an instance of xs:untypedAtomic and the other is an instance of a numeric type, then the xs:untypedAtomic value is cast to the type xs:double.

   2. If one of the atomic values is an instance of xs:untypedAtomic and the other is an instance of xs:untypedAtomic or xs:string, then the xs:untypedAtomic value (or values) is (are) cast to the type xs:string.

   3. If one of the atomic values is an instance of xs:untypedAtomic and the other is not an instance of xs:string, xs:untypedAtomic, or any numeric type, then the xs:untypedAtomic value is cast to the dynamic type of the other value.

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

When evaluating a general comparison in which either operand is a sequence of items, an implementation may return true as soon as it finds an item in the first operand and an item in the second operand that have the required magnitude relationship. Similarly, a general comparison may raise a dynamic error as soon as it encounters an error in evaluating either operand, or in comparing a pair of items from the two operands. As a result of these rules, the result of a general comparison is not deterministic in the presence of errors.

Here are some examples of general comparisons:

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

  $book1/author = "Kennedy"
  

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

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

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

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

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

3.5.3 Node Comparisons

Node comparisons are used to compare two nodes, by their identity or by their document order. The result of a node comparison is defined by the following rules:

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

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

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

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

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

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

Here are some examples of node comparisons:

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

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

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

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

3.10.1 Instance Of

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

• 5 instance of xs:integer

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

• 5 instance of xs:decimal

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

• (5, 6) instance of xs:integer+

  This example returns true because the given sequence contains two integers, and is a valid instance of the specified type.

• . instance of element()

  This example returns true if the context item is an element node or false if the context item is defined but is not an element node. If the context item is undefined, a dynamic error is raised [err:XPDY0002].

3.10.2 Cast

Occasionally it is necessary to convert a value to a specific datatype. For this purpose, XPath provides a cast expression that creates a new value of a specific type based on an existing value. A cast expression takes two operands: an input expression and a target type. The type of the input expression is called the input type. The target type must be an atomic type that is in the in-scope schema types [err:XPST0051]. In addition, the target type cannot be xs:NOTATION or xs:anyAtomicType [err:XPST0080]. The optional occurrence indicator "?" denotes that an empty sequence is permitted. If the target type has no namespace prefix, it is considered to be in the default element/type namespace. The semantics of the cast expression are as follows:

1. Atomization is performed on the input expression.

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

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

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

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

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

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

      If the target type of a cast expression is xs:QName, or is a type that is derived from xs:QName or xs:NOTATION, and if the base type of the input is not the same as the base type of the target type, then the input expression must be a string literal [err:XPTY0004].

      Note:

      The reason for this rule is that construction of an instance of one of these target types from a string requires knowledge about namespace bindings. If the input expression is a non-literal string, it might be derived from an input document whose namespace bindings are different from the statically known namespaces.

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

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

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

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

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

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

3.10.3 Castable

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

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

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

3.10.4 Constructor Functions

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

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

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

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

The following examples illustrate the use of constructor functions:

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

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

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

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

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

  xs:dayTimeDuration("P21D")
  

• If usa:zipcode is a user-defined atomic type in the in-scope schema types, then the following expression is equivalent to the expression ("12345" cast as usa:zipcode?).

  usa:zipcode("12345")
  

3.10.5 Treat

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

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

The semantics of expr1 treat as type1 are as follows:

• During static analysis:

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

• During expression evaluation:

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

• Example:

  $myaddress treat as element(*, USAddress)
  

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