- このバージョン:
-
http://www.w3.org/TR/2007/REC-xpath20-20070123/
- 最新バージョン:
-
http://www.w3.org/TR/xpath20/
- 以前のバージョン:
-
http://www.w3.org/TR/2006/PR-xpath20-20061121/
- 編者:
- Anders Berglund (XSL WG), IBM Research <alrb@us.ibm.com>
- Scott Boag (XSL WG), IBM Research <scott_boag@us.ibm.com>
- Don Chamberlin (XML Query WG), IBM Almaden Research Center, via
http://www.almaden.ibm.com/cs/people/chamberlin/
- Mary F. Fernández (XML Query WG), AT&T Labs <mff@research.att.com>
- Michael Kay (XSL WG), Saxonica, via http://www.saxonica.com/
- Jonathan Robie (XML Query WG), DataDirect Technologies, via
http://www.ibiblio.org/jwrobie/
- Jérôme Siméon (XML Query WG), IBM T.J. Watson Research Center
<simeon@us.ibm.com>
このドキュメントの
最新の訂正
を参照してください。これには仕様の修正が含まれて居ます。
翻訳も参照。
このドキュメントは仕様外のフォーマットでも利用可能です:
XML.
Copyright © 2007
W3C® (MIT,
ERCIM,
Keio), All Rights Reserved.
W3C の 責任範囲、
商標、ドキュメントの適用の規定が適用されます。
概要
XPath 2.0 は [XQuery/XPath Data Model (XDM)] で定義されているデータモデルに則した値の処理を行うことのできる式言語である。データモデルは整数、文字列、ブール代数のような原子値と同じような XML ドキュメントのツリー表現、および XML ドキュメントのノード参照と原子値の両方を含むシーケンスを提供する。XPath 式の結果は入力ドキュメントからのノード選択や原子値、より一般的にはデータモデルで許されるあらゆるシーケンスである。この言語の名前は示差的特長である XML ツリーノードを階層的アドレッシングを意味するパス式に由来する。XPath 2.0 は [XPath 1.0] によりリッチなデータタイプのサポートと、ドキュメントが XML スキーマ検証された時に有効になる型情報の利用機能を追加したスーパーセットである。後方互換モードは XPath 2.0 においてでもほとんど全ての XPath 1.0 式が引き続き同じ結果を示すことを保障するために提供される; この方針に対する例外は [I Backwards Compatibility with XPath 1.0] に記す。
1 イントロダクション
XPath の第一の目的は [XML 1.0] や [XML
1.1] ツリーの一部を指示することである。XPath は XML 文章の階層構造を通じての操作するパス表記法という使用から名付けられている。XPath はコンパクトであり、URI や XML 属性値を含む使用を簡素化する非 XML 構文を使用している。
[定義:
XPath は表面的な構文ではなく XML ドキュメントの抽象・論理構造を扱う。データモデルとして知られるこの論理構造は [XQuery/XPath データモデル (XDM)] で定義されている。]
XPath は [XSLT 2.0] や [XQuery] のようなホスト言語に埋め込んで使用できるよう設計されている。XPath はマッチングに使用できる固有のサブセットを持っている (ノードがパターンに一致するかどうかを評価できる)。XPath のこの使用は [XSLT
2.0] で詳述されている。
XQuery バージョン 1.0 は XPath バージョン 2.0 の拡張仕様である。XPath 2.0 と XQuery 1.0 の両方で構文的に正しく正常に実行できるどんな式も両方の言語で同じ結果を返すだろう。これらの言語は密接に関連しているため、一貫性を保障するためにこれらの文法と言語説明は共通のソースから生成されている。またそれらの仕様策定者たちも共に作業している。
XPath も以下の仕様に依存し、そして密接に関わっている:
この文章は [XML 1.0] で使用されている基本 EBNF と同じ表記法を用いて記述している。特に明記しない限り (A.2 構文構造参照)、空白文字に表記上の意味はない。構文停止はそれらが記述する特徴と共に導入されている。完全な文法は付録 [A XPath 文法] で示している。付録は normative 版である。
このドキュメントの構文提示において、名前が付けられているシンボルは下線が引かれており、リテラルテキストはダブルクォートで囲まれている。例えば以下の提示は関数呼び出しの構文を記述している:
この提示は以下のように読む必要がある: 関数呼び出しは、後ろに開き括弧が続く QName で構成される。開き括弧には省略可能な引数リストが続く。(もし指定されるなら) 引数リストはコンマで区切られたひとつ以上の式で構成される。この引数リストは閉じ括弧が続く。
言語処理の特定の局面は、この仕様において実装定義か実装依存として記述される。
この仕様において実装定義や実装依存として記述されている言語局面は XPath が埋め込まれるホスト言語の仕様によって制限を受ける可能性がある。
この文章は XPath の動的セマンティクスを規定的に定義する。XPath の静的セマンティクスは [XQuery 1.0 と XPath 2.0 形式セマンティクス] で規定的に定義されている。この文章で "Note" と付けられている例や資料は説明的な目的で提供しているもので規定するものではない。
2 基本事項
XPath の基本的な材料は [Unicode] 文字の式である (使用される Unicode のバージョンは実装定義)。言語はキーワード、記号、演算子で構成される数種類の式を含むことができる。一般に、式の操作対象は他の式である。XPath は式を完全な短縮形で記述できる。
Note:
この仕様は [Unicode] 文字列の文字セットエンコーディングに関して仮定や必要条件を含みません。
XPath もXML のように大文字と小文字を区別する。XPath のキーワードは小文字であり、非予約語についても、
A.3 予約関数名に挙げられた接頭辞の付かない特定の関数名を除いて、XPath 式の名前は言語キーワードと同じであることを許している。
[定義:
データモデルにおいて、値はシーケンス (Sequence) を含む]
[定義: シーケンス は順序付けられた 0 以上の項目 (Item) である]
[定義: 項目は原子値 (Atomic Value) あるいはノード (Node) である]
[定義: 原子値は [XML Schema] で定義されている原子型 (Atomic Type) の値空間における値である]
[定義: ノードは [XQuery/XPath データモデル (XDM)] で定義されているノード種別 (Node Kind) のひとつのインスタンスである]
それぞれのノードはユニークなノード識別 (Node Identify) と型に関連付いた値 (Typed Value)、そして文字列値 (String Value)を持っている。加えていくつかのノードは名前を持っている。ノードの型に関連付いた値は 0 個以上の原子値のシーケンスである。ノードの文字列値は型 xs:string の値である。ノードの名前は型 xs:QName の値である。
[定義:
まさに 1 項目のみを含んでいるシーケンスは単体 (Singleton) と呼ばれる]
項目はその項目を含んでいる単体シーケンスと同一である。シーケンスがネストされることはない - 例えば、値 1, (2, 3) と ( ) を単一のシーケンスに結合すると (1, 2, 3) となる。
[定義:
ひとつも項目を含まないシーケンスは空シーケンスと呼ばれる]
[Definition: The term XDM
instance is used, synonymously with the term value, to
denote an unconstrained sequence of nodes and/or atomic values in the data model.]
Names in XPath are called QNames, and conform to the
syntax in [XML Names]. [Definition: Lexically, a
QName consists of an optional namespace prefix and a local
name. If the namespace prefix is present, it is separated from the
local name by a colon.] A lexical QName can be converted into an
expanded QName by resolving its namespace prefix to a
namespace URI, using the statically known namespaces
[err:XPST0081].
[Definition: An expanded QName
consists of an optional namespace URI and a local name. An expanded
QName also retains its original namespace prefix (if any), to
facilitate casting the expanded QName into a string.] The namespace
URI value is whitespace normalized according to the rules for the
xs:anyURI type in [XML
Schema]. Two expanded QNames are equal if their namespace URIs
are equal and their local names are equal (even if their namespace
prefixes are not equal). Namespace URIs and local names are
compared on a codepoint basis, without further normalization.
This document uses the
following namespace prefixes to represent the namespace URIs with
which they are listed. Use of these namespace prefix bindings in
this document is not normative.
Element nodes have a property called in-scope namespaces.
[Definition: The in-scope
namespaces property of an element node is a set of namespace
bindings, each of which associates a namespace prefix with a
URI, thus defining the set of namespace prefixes that are available
for interpreting QNames within the scope of the element. For a
given element, one namespace binding may have an empty prefix; the
URI of this namespace binding is the default namespace within the
scope of the element.]
In [XPath 1.0], the in-scope
namespaces of an element node are represented by a collection of
namespace nodes arranged on a namespace axis. In
XPath Version 2.0, the namespace axis is deprecated and need not be
supported by a host language. A host language that does not support
the namespace axis need not represent namespace bindings in the
form of nodes.
[Definition: Within
this specification, the term URI refers to a Universal
Resource Identifier as defined in [RFC3986]
and extended in [RFC3987] with the new name
IRI.] The term URI has been retained in preference to IRI to
avoid introducing new names for concepts such as "Base URI" that
are defined or referenced across the whole family of XML
specifications.
2.1 式コンテキスト
[Definition: 与えられた式に対する式コンテキストは式の結果に影響するすべての情報で構成されている。] この情報は静的コンテキスト、動的コンテキストと呼ばれる 2 つのカテゴリにまとめられる。
.
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 処理モデル
XPath は データモデルと式コンテキストに関して定められる。
Figure 1: 処理モデル概要
Figure 1 provides a schematic overview of the processing steps
that are discussed in detail below. Some of these steps are
completely outside the domain of XPath; in Figure 1, these are
depicted outside the line that represents the boundaries of the
language, an area labeled external processing. The external
processing domain includes generation of an XDM instance that represents the
data to be queried (see 2.2.1 Data Model
Generation), schema import processing (see 2.2.2 Schema Import
Processing) and serialization (see 2.2.4 Serialization). The area
inside the boundaries of the language is known as the XPath processing
domain, which includes the static analysis and
dynamic evaluation phases (see 2.2.3 Expression
Processing). Consistency constraints on the XPath processing domain
are defined in 2.2.5
Consistency Constraints.
2.2.1 データモデル生成
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:
-
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.)
-
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 PSVIDM, the type
annotations of the element and attribute nodes are derived from
schema validation. XPath does not provide a way to directly access
the type annotation of an element or attribute node.
The value of an attribute is represented directly within the
attribute node. An attribute node whose type is unknown (such as
might occur in a schemaless document) is given the type annotation
xs:untypedAtomic.
The value of an element is represented by the children of the
element node, which may include text nodes and other element nodes.
The type
annotation of an element node indicates how the values in its
child text nodes are to be interpreted. An element that has not
been validated (such as might occur in a schemaless document) is
annotated with the schema type xs:untyped. An element
that has been validated and found to be partially valid is
annotated with the schema type xs:anyType. If an
element node is annotated as xs:untyped, all its
descendant element nodes are also annotated 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.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.3.1 Static Analysis Phase
[Definition: The static analysis
phase depends on the expression itself and on the static context. The
static analysis phase does not depend on input data (other
than schemas).]
During the static analysis phase, the XPath expression is
parsed into an internal representation called the operation
tree (step SQ1 in Figure 1). A parse error is raised as a
static error
[err:XPST0003]. The
static
context is initialized by the implementation (step SQ2). The
static
context is used to resolve schema type names, function names,
namespace prefixes, and variable names (step SQ4). If a name of one
of these kinds in the operation tree is not found in the
static
context, a static error ([err:XPST0008] or [err:XPST0017]) is raised (however, see
exceptions to this rule in 2.5.4.3
Element Test and 2.5.4.5
Attribute Test.)
The operation tree is then normalized by making
explicit the implicit operations such as atomization and extraction of 有効ブール値s (step SQ5). The normalization process is described in
[XQuery 1.0 and XPath 2.0 Formal
Semantics].
Each expression is then assigned a static type (step SQ6). [Definition: The static type of an
expression is a type such that, when the expression is evaluated,
the resulting value will always conform to the static type.] If the
Static Typing Feature is
supported, the static
types of various expressions are inferred according to the
rules described in [XQuery 1.0 and
XPath 2.0 Formal Semantics]. If the Static Typing Feature is not
supported, the static types that are assigned are implementation-dependent.
During the static analysis phase, if the Static Typing Feature is in
effect and an operand of an expression is found to have a static type that is not
appropriate for that operand, a type error is raised [err:XPTY0004]. If static type checking
raises no errors and assigns a static type T to an expression, then
execution of the expression on valid input data is guaranteed
either to produce a value of type T or to raise a dynamic error.
The purpose of the Static Typing Feature is to
provide early detection of type errors and to infer type information that
may be useful in optimizing the evaluation of an expression.
2.2.3.2 Dynamic Evaluation Phase
[Definition: The dynamic
evaluation phase is the phase during which the value of an
expression is computed.] It occurs after completion of the
static
analysis phase.
The dynamic evaluation phase can occur only if no errors were
detected during the static analysis phase. If the Static Typing Feature is in
effect, all type
errors are detected during static analysis and serve to inhibit
the dynamic evaluation phase.
The dynamic evaluation phase depends on the operation
tree of the expression being evaluated (step DQ1), on the input
data (step DQ4), and on the dynamic context (step DQ5), which in turn
draws information from the external environment (step DQ3) and the
static
context (step DQ2). The dynamic evaluation phase may create new
data-model values (step DQ4) and it may extend the dynamic context
(step DQ5)—for example, by binding values to variables.
[Definition: A dynamic type is
associated with each value as it is computed. The dynamic type of a
value may be more specific than the static type of the expression that computed
it (for example, the static type of an expression might be
xs:integer*, denoting a sequence of zero or more
integers, but at evaluation time its value may have the dynamic
type xs:integer, denoting exactly one integer.)]
If an operand of an expression is found to have a dynamic type that is not
appropriate for that operand, a type error is raised [err:XPTY0004].
Even though static typing can catch many type errors before an expression is
executed, it is possible for an expression to raise an error during
evaluation that was not detected by static analysis. For example,
an expression may contain a cast of a string into an integer, which
is statically valid. However, if the actual value of the string at
run time cannot be cast into an integer, a dynamic error will result. Similarly,
an expression may apply an arithmetic operator to a value whose
static type is
xs:untypedAtomic. This is not a static error, but at run
time, if the value cannot be successfully cast to a numeric type, a dynamic error will be
raised.
When the Static Typing Feature is in
effect, it is also possible for static analysis of an expression to
raise a type error,
even though execution of the expression on certain inputs would be
successful. For example, an expression might contain a function
that requires an element as its parameter, and the static analysis
phase might infer the static type of the function parameter to be
an optional element. This case is treated as a type error and inhibits
evaluation, even though the function call would have been
successful for input data in which the optional element is
present.
2.2.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 エラー処理
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:
-
nnnn is a unique numeric code.
Note:
The namespace URI for XPath and XQuery errors is not expected to
change from one version of XPath to another. However, the contents
of this namespace may be extended to include additional error
definitions.
The method by which an XPath processor reports error information
to the external environment is implementation-defined.
An error can be represented by a URI reference that is derived
from the error QName as follows: an error with namespace URI
NS and local part 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.
Note:
Along with a code identifying an error, implementations may wish
to return additional information, such as the location of the error
or the processing phase in which it was detected. If an
implementation chooses to do so, then the mechanism that it uses to
return this information is implementation-defined.
2.3.3 動的エラーの処理
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.
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 コンセプト
このセクションでは XPath 式の処理において重要ないくつかの考え方を説明する。
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:
-
The root node is the first node.
-
Every node occurs before all of its children and
descendants.
-
Namespace nodes immediately follow the element node with which
they are associated. The relative order of namespace nodes is
stable but implementation-dependent.
-
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.
-
The relative order of siblings is the order in which they occur
in the children property of their parent node.
-
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:
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:
-
If its operand is an empty sequence, fn:boolean
returns false.
-
If its operand is a sequence whose first item is a node,
fn:boolean returns true.
-
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.
-
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.
-
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.
-
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.
Note:
The definition of 有効ブール値 is not used when
casting a value to the type xs:boolean, for example in
a cast expression or when passing a value to a
function whose expected parameter is of type
xs:boolean.
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:
2.5 型
The type system of XPath is based on [XML
Schema], and is formally defined in [XQuery 1.0 and XPath 2.0 Formal
Semantics].
[Definition: A sequence type is a type
that can be expressed using the SequenceType syntax. Sequence types
are used whenever it is necessary to refer to a type in an XPath
expression. The term sequence type suggests that this syntax
is used to describe the type of an XPath value, which is always a
sequence.]
[Definition: A schema type is a type
that is (or could be) defined using the facilities of [XML Schema] (including the built-in types of
[XML Schema]).] A schema type can be used
as a type annotation on an element or attribute node (unless it is
a non-instantiable type such as xs:NOTATION or
xs:anyAtomicType, in which case its derived types can
be so used). Every schema type is either a complex type or a
simple type; simple types are further subdivided into
list types, union types, and atomic types (see
[XML Schema] for definitions and
explanations of these terms.)
Atomic types represent the intersection between the categories
of sequence
type and schema
type. An atomic type, such as xs:integer or
my:hatsize, is both a sequence type and a schema type.
2.5.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.
-
[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.
-
[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.]
-
[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.]
-
[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" であろう。
読者への便宜として、さまざまな種類のノードに対する 型に関連付けられた値と文字列値の関係を下記でまとめて例示する。
-
テキストやドキュメントノードに対して xs:untypedAtomic 型のインスタンスとしてノードの型に関連付けられた値はその文字列値と等しい。ドキュメントノードの文字列値はそのすべての子孫テキストノードの文字列値をドキュメントで結合して作り出される。
-
コメント、名前空間および処理命令ノードの型に関連付けられた値はその文字列値と同じである。これは xs:string 型のインスタンスである。
-
型注釈に 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 のような)。
-
要素ノードに対して、型に関連付けられた値と文字列値との関係は以下のようにノードの型注釈に依存している:
-
型注釈が 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 のインスタンスである。
-
型注釈が単純型 (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:
もし実装がノードの文字列値のみを保持し、ノードの型注釈がユニオン型であるなら、実装は適切なメンバ型のインスタンスとしてノードの型に関連付けられた値を変換できなければならない。
-
もし型注釈が空の内容を持つ複合型を示すなら、ノードの型に関連付けられた値は空のシーケンスであり、文字列値は長さ 0 の文字列である。
-
もし型注釈が要素のみの内容を持つ複合型を示している場合、ノードの型に関連付けられた値は未定義である。fn:data 関数がそのようなノードに適用された場合、型エラー [err:FOTY0012] が発生する。そのようなノードの文字列値は、そのすべての子孫テキストノードをドキュメント順序で連結した文字列値と等しい。
例: E6 は element-only と指定された内容型の複合型を持つ型注釈 weather の要素ノードである。E6 は temprture (気温) と precipitation (降水量) という名前の 2 つの要素を持っている。このとき E6 の型に関連付けられた値は未定義であり、E6 への fn:data 関数の適用はエラーとなる。
2.5.3 SequenceType 構文
XPath 式では、型を参照する必要があるときはいつでも SequenceType 構文が使用される。
|