XQuery 1.0: An XML Query Language

2.1.1 Static Context

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

The individual components of the static context are summarized below. Further rules governing the semantics of these components can be found in C.1 Static Context Components.

• [Definition: XPath 1.0 compatibility mode. This component must be set by all host languages that include XPath 2.0 as a subset, indicating whether rules for compatibility with XPath 1.0 are in effect. XQuery sets the value of this component to false. ]

• [Definition: In-scope namespaces. This is a set of (prefix, URI) pairs. The in-scope namespaces are used for resolving prefixes used in QNames within the expression.]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  Note:

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

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

  Note:

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

2.1.2 Dynamic Context

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

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

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

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

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

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

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

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

• [Definition: Dynamic variables. This is a set of (QName, value) pairs. It contains the same QNames as the in-scope variables in the static context for the expression. The QName is the name of the variable and the value is the dynamic value of the variable.]

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

• [Definition: Current date and time. This information represents an implementation-dependent point in time during processing of a query or transformation. It can be retrieved by the fn:current-date, fn:current-time, and fn:current-dateTime functions. If invoked multiple times during the execution of a query or transformation, these functions always return the same result.]

• [Definition: Implicit timezone. This is the timezone to be used when a date, time, or dateTime value that does not have a timezone is used in a comparison or in any other operation. This value is an instance of xdt:dayTimeDuration that is implementation-defined . See [ISO 8601] for the range of legal values of a timezone.]

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

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

2.2.1 Data Model Generation

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

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

2. The Information Set or PSVI may be transformed into the data model by a process described in [XQuery 1.0 and XPath 2.0 Data Model]. (See DM2 in Fig. 1.)

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

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

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

The value of an element is represented by the children of the element node, which may include text nodes and other element nodes. The dynamic type of an element node indicates how the values in its child text nodes are to be interpreted. An element whose type is unknown (such as might occur in a schemaless document) is annotated with the type xdt:untypedAny.

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

2.2.2 Schema Import Processing

2.2.3 Expression Processing

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

2.2.4 Serialization

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

2.2.5 Consistency Constraints

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

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

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

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

• Every item type (i.e., every element, attribute, or type name) referenced in in-scope variables or in-scope functions must be in the in-scope schema definitions.

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

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

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

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

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

2.3.1 Document Order

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

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

Within a tree, document order satisfies the following constraints:

1. The root node is the first node.

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

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

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

5. Element nodes occur before their children; children occur before following-siblings.

The relative order of nodes in distinct trees is stable but implementation-dependent, subject to the following constraint: If any node in tree T1 is before any node in tree T2, then all nodes in tree T1 are before all nodes in tree T2.

2.3.2 Atomization

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

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

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

• If the item is a node, its typed value is returned.

Atomization is used in processing the following types of expressions:

• Arithmetic expressions

• Comparison expressions

• Function calls and returns

• Cast expressions

• Computed element and attribute constructors.

2.3.3 Effective Boolean Value

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

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

• An empty sequence

• The boolean value false

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

• A numeric value that is equal to zero

• The xs:double or xs:float value NaN

Otherwise, fn:boolean returns true.

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

• Logical expressions (and, or)

• The fn:not function

• The where clause of a FLWOR expression

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

• Conditional expressions (if)

• Quantified expressions (some, every)

2.3.4 Input Sources

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

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

The input functions supported by XQuery are as follows:

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

• The fn:collection function takes a string containing a URI, and returns the data model representation of the collection identified by the URI. A collection may be any sequence of nodes. For example, the expression fn:collection("http://example.org")//customer identifies all the customer elements that are descendants of nodes found in the collection whose URI is http://example.org.

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

2.4.1 Predefined Types

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

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

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

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

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

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

Figure 2: Summary of XQuery Type Hierarchy

2.4.2 Typed Value and String Value

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

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

1. For text, document, and namespace nodes, the typed value of the node is the same as its string value, as an instance of the type xdt:untypedAtomic. (The string value of a document node is formed by concatenating the string values of all its descendant text nodes, in document order.)

2. The typed value of a comment or processing instruction node is the same as its string value. It is an instance of the type xs:string.

3. The typed value of an attribute node with the type annotation xdt:untypedAtomic is the same as its string value, as an instance of xdt:untypedAtomic. The typed value of an attribute node with any other type annotation is derived from its string value and type annotation in a way that is consistent with schema validation.

   Example: A1 is an attribute having string value "3.14E-2" and type annotation xs:double. The typed value of A1 is the xs:double value whose lexical representation is 3.14E-2.

   Example: A2 is an attribute with type annotation xs:IDREFS, which is a list datatype derived from the atomic datatype xs:IDREF. Its string value is "bar baz faz". The typed value of A2 is a sequence of three atomic values ("bar", "baz", "faz"), each of type xs:IDREF. The typed value of a node is never treated as an instance of a named list type. Instead, if the type annotation of a node is a list type (such as xs:IDREFS), its typed value is treated as a sequence of the atomic type from which it is derived (such as xs:IDREF).

4. For an element node, the relationship between typed value and string value depends on the node's type annotation, as follows:

   1. If the type annotation is xdt:untypedAtomic, or denotes a complex type with mixed content, then the typed value of the node is equal to its string value, as an instance of xdt:untypedAtomic.

      Note:

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

      Example: E1 is an element node having type annotation xdt:untypedAny and string value "1999-05-31". The typed value of E1 is "1999-05-31", as an instance of xdt:untypedAtomic.

      Example: E2 is an element node with the type annotation formula, which is a complex type with mixed content. The content of E2 consists of the character "H", a child element named subscript with string value "2", and the character "O". The typed value of E2 is "H2O" as an instance of xdt:untypedAtomic.

   2. If the type annotation denotes a simple type or a complex type with simple content, then the typed value of the node is derived from its string value and its type annotation in a way that is consistent with schema validation.

      Example: E3 is an element node with the type annotation cost, which is a complex type that has several attributes and a simple content type of xs:decimal. The string value of E3 is "74.95". The typed value of E3 is 74.95, as an instance of xs:decimal.

      Example: E4 is an element node with the type annotation hatsizelist, which is a simple type derived from the atomic type hatsize, which in turn is derived from xs:integer. The string value of E4 is "7 8 9". The typed value of E4 is a sequence of three values (7, 8, 9), each of type hatsize.

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

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

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

2.4.3 SequenceType Syntax

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

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

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

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

• attribute()? refers to an optional attribute

• element() refers to any element

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

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

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

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

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

2.4.4 SequenceType Matching

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

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

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

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

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

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

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

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

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

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

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

  1. ET is an unknown type, or

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

The rules for SequenceType matching are given below, with examples (the examples are for purposes of illustration, and do not cover all possible cases).