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

  Some namespaces are predefined; additional namespaces can be added to the statically known namespaces by namespace declarations in a Prolog and by namespace declaration attributes in direct element constructors.

• [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 initial default element/type namespace may be provided by the external environment or by a declaration in a Prolog.

• [Definition: Default function namespace. This is a namespace URI that 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 a Prolog.]

• [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 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 type definitions include the predefined types described in 2.5.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 an expanded 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 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). 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 (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.]

  Variable declarations in a Prolog are added to in-scope variables. 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.

  The static type of a variable may be either declared in a query or (if the Static Typing Feature is enabled) inferred by static type inference rules as described in [XQuery 1.0 and XPath 2.0 Formal Semantics].

• 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.12.5 Constructor Functions.

• [Definition: Statically known 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.] [Definition: A collation is a specification of the manner in which character strings 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 string comparison functions and operators when no explicit collation is specified.]

• [Definition: Construction mode. The construction mode governs the behavior of element constructors. If construction mode is preserve, the type of a constructed element node is xs:anyType, and the attributes and descendants of the constructed element retain their original types. If construction mode is strip, the type of the constructed element node and all its descendants is xdt:untyped, and attributes of the constructed element have type xdt:untypedAtomic.]

• [Definition: Ordering mode. Ordering mode, which has the value ordered or unordered, affects the ordering of the result sequence returned by path expressions, union, intersect, and except expressions, and FLWOR expressions that have no order by clause.] Details are provided in the descriptions of these expressions.

• [Definition: Default ordering for empty sequences. This component controls whether an empty sequence is interpreted as the greatest value or as the least value during processing of an order by clause in a FLWOR expression, as described in 3.8.3 Order By and Return Clauses.] Its value may be greatest or least.

• [Definition: XMLSpace policy. This component controls the processing of whitespace by element constructors, as described in 3.7.1.4 Whitespace in Element Content.] Its value may be preserve or strip.

• [Definition: Namespace inheritance mode. This component controls the namespace bindings that are inherited when an existing element node is copied by an element constructor, as described in 3.7.1 Direct Element Constructors. Its value may be yes or no.]

• [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 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()*.

• XQuery Flagger status. This component has the value "on" if the XQuery Flagger is implemented and enabled; otherwise it has the value "off".

• XQuery Static Flagger status. This component has the value "on" if the XQuery Static Flagger is implemented and enabled; otherwise it has the value "off".

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

Certain language constructs, notably the path expression E1/E2 and the filter 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. 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.] 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.] 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. For a user-defined function, the function implementation is an XQuery expression. For a built-in function or external function, the function implementation is implementation-dependent.]

• [Definition: Current dateTime. This information represents an implementation-dependent point in time during the processing of a query, and includes an explicit timezone. It can be retrieved by the fn:current-dateTime function. If invoked multiple times during the execution of a query, 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 xdt:dayTimeDuration. 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.

• [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 must be initialized by the implementation.

2.2.1 Data Model Generation

Before a query can be processed, its input data must be represented as a data model instance. 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 a data model instance:

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

2. The Information Set or PSVI may be transformed into a data model instance 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 data model instance might be constructed. A data model instance 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 the data model, but it does not place any constraints on data model instances are constructed.

[Definition: Each atomic value, element node, and attribute node in a data model instance has a 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.]

[Definition: The type annotation of an element or attribute node is an implementation-dependent representation of its dynamic type.] If the data model instance was derived from an validated XML document as described in [XQuery 1.0 and XPath 2.0 Data Model], the type annotations of the element and attribute nodes are derived from schema validation. XQuery 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 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 that has not been validated (such as might occur in a schemaless document) is annotated with the type xdt:untyped. An element that has been validated and found to be partially valid is annotated with the type xs:anyType. If an element node is annotated xdt:untyped, all its descendant element nodes are also annotated xdt:untyped. However, if an element node is annotated xs:anyType, some of its descendant element nodes may have a more specific type annotation.

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). During the static analysis phase, static errors or type errors may be raised. During the dynamic evaluation phase, dynamic errors or type errors may be raised. These kinds of errors are defined in 2.3.1 Kinds of Errors.

In processing an expression, an implementation is free to use any strategy or algorithm whose result conforms to the specifications in this document.

2.2.4 Serialization

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

2.2.5 Consistency Constraints

In order for XQuery to be well defined, the input data model instance, 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. This specification does not define the result of a query 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 a data model 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 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 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 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 item type (i.e., every element, attribute, or type name) referenced in in-scope variables or function signatures 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.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.

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

• For each variable declared as external: If the variable declaration includes a declared type, the external environment must provide a value for the variable that matches the declared type, using the matching rules in 2.5.4 SequenceType Matching. If the variable declaration does not include a declared type, the external environment must provide a type and a matching value, using the same matching rules.

• For a given query, define a participating ISSD as the in-scope schema definitions of a module that is used in evaluating the query. If two participating ISSDs contain a definition for the same type name, element name, or attribute name, the definitions must be equivalent in both ISSDs. Furthermore, if two participating ISSDs each contain a definition of a type name T, the set of types derived by extension from T must be equivalent in both ISSDs. Also, if two participating ISSDs each contain a definition of an element name E, the substitution group headed by E must be equivalent in both ISSDs.

2.3.1 Kinds of Errors

As described in 2.2.3 Expression Processing, XQuery defines an analysis phase, which does not depend on input data, and an 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 analysis phase. A syntax error is an example of a static error. The means by which static errors are reported during the analysis phase is implementation-defined. ]

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

[Definition: A type error may be raised during the analysis or evaluation phase. During the 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 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 analysis phase is either success or one or more type errors and/or static errors. The result of the evaluation phase is either a result value, a type error, or a dynamic error.

If any expression (at any level) can be evaluated during the analysis phase (because all its explicit operands are known and it has no dependencies on the dynamic context), then any error in performing this evaluation may be reported as a static error. However, the fn:error() function must not be evaluated during the analysis phase. For example, an implementation is allowed (but not required) to treat the following expression as a static error, because it calls a constructor function with a constant string that is not in the lexical space of the target type:

xs:date("Next Tuesday")

If the Static Typing Feature is not in effect but an implementation can nevertheless determine during the analysis phase that an expression will necessarily raise a type error, the implementation may report that error during the analysis phase.

In addition to static errors, dynamic errors, and type errors, an XQuery implementation may raise warnings, either during the analysis phase or the 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 if insufficient resources are available for processing a given expression. For example, an implementation may specify limitations on the maximum numbers or sizes of various objects. These limitations, and the consequences of exceeding them, are implementation-dependent.

2.3.2 Identifying and Reporting Errors

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

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

• XX denotes the language in which the error is defined, using the following encoding:

  • XP denotes an error defined by XPath. Such an error may also occur XQuery since XQuery includes XPath as a subset.

  • XQ denotes an error defined by XQuery.

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

  • ST denotes a static error.

  • DY denotes a dynamic error.

  • TY denotes a type error.

• nnnn is a unique numeric code.

An error, if it occurs, is reported to the external processing environment in the form of a URI reference that is derived from the error QName. An error QName with namespace URI NS and local part LP will be returned as the URI reference NS#LP. The method by which the URI reference is returned to the external processing environment is implementation-defined.

As an example, an error identified in this document as err:XPST0017 would be returned to the external processing environment as http://www.w3.org/2004/10/xqt-errors#XPST0017.

2.3.3 Handling Dynamic Errors

Except as noted in this document, if any operand of an expression raises a dynamic error, the expression also raises a dynamic error. If an expression can validly return a value or raise a dynamic error, the implementation may choose to return the value or raise the dynamic error. 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.

A dynamic error is identified by a QName, and 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:

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

2.3.4 Errors and Optimization

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

When an implementation is able to evaluate an expression without evaluating some subexpression, the implementation is never required to evaluate that subexpression solely to determine whether it raises a dynamic error. For example, if a function parameter is never used in the body of the function, an implementation may choose whether to evaluate the expression bound to that parameter in a function call.

Similarly, in evaluating an expression, an implementation is not required to search for data whose only possible effect on the result would be to raise an error, as illustrated in the following examples.

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

  some $x in $expr1 satisfies $x = 47
  

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

  //product[id = 47]
  

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

In some cases, an optimizer may be able to achieve substantial performance improvements by rearranging an expression so that the underlying operations are performed in a different order than that in which they are written. In such cases, errors may be raised that would not have been raised if the expression were evaluated as written. However, an expression must not be rearranged in a way that changes its result value in the absence of errors.

• The expression in the following example cannot raise a casting error if it is evaluated exactly as written (i.e., left to right). An implementation is permitted, however, 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 reordering of expressions, tests that are designed to prevent dynamic errors should be expressed using conditional or typeswitch expressions. Conditional and typeswitch expressions raise only dynamic errors that occur in the branch that is actually selected.

• Unlike the previous example, the following example cannot raise a dynamic error if @x is not castable into an xs:date.

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

2.4.1 Document Order

An ordering called document order is defined among all the nodes accessible during a given query, 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. [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 query, even if this order is implementation-dependent.]

Within a tree, document order satisfies the following constraints:

1. The root node is the first node.

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

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

4. The relative order of siblings is the order in which they occur in the children property of their parent node.

5. Children and descendants occur before following siblings.

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

2.4.2 Atomization

The semantics of some XQuery 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. [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.

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.4.3 Effective Boolean Value

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

The 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.4.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 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 XQuery are as follows:

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

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

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

If a given input function is invoked repeatedly with arguments that resolve to the same absolute URI during the scope of a single query, each invocation must return the same node sequence.

2.5.1 Predefined Types

1. [Definition: xdt:untyped is used to denote the dynamic type of an element node that has not been validated, or has been validated in skip mode.] No predefined types are derived from xdt:untyped.

2. [Definition: xdt:untypedAtomic 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, or that has a PSVI property of xs:anySimpleType, is represented in the Data Model by an attribute node with the type xdt:untypedAtomic. No predefined types are derived from xdt:untypedAtomic.

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

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

5. [Definition: xdt:anyAtomicType includes all atomic values (and no values that are not atomic).] It is derived from 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 derived from xdt:anyAtomicType.

   Note:

   xdt:anyAtomicType will not appear as the type of an actual value in the Data Model.

The relationships among the types in the xs and xdt namespaces are illustrated 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.5.2 Typed Value and String Value

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

An implementation may store both the typed value and the string value of a node, or it may store only one of these and derive the other from it as needed. In general, the string value of a node must be a valid lexical representation of the typed value of the node, but the node is not required to preserve the string representation from the original source document. For example, if the typed value of a node is the xs:integer value 30, its string value might be "30" or "0030".

• If the node was created by mapping from an Infoset or PSVI, see rules in [XQuery 1.0 and XPath 2.0 Data Model].

• If the node was created by an XQuery node constructor, see rules in 3.7.1 Direct Element Constructors, 3.7.3.1 Computed Element Constructors, or 3.7.3.2 Computed Attribute Constructors.

• If the node was created by a validate expression, see rules in 3.13 Validate Expressions.

As a convenience to the reader, the relationship between typed value and string value for various kinds of nodes is summarized and illustrated by examples below.

1. For text and document nodes, the typed value of the node is the same as its string value, as an instance of the 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 using the lexical-to-value-space mapping defined in [XML Schema] Part 2 for the relevant type.

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

   Example: A2 is an attribute with type annotation xs:IDREFS, which is a list datatype whose item type is the atomic datatype xs:IDREF. Its string value is "bar baz faz". The typed value of A2 is a sequence of three atomic values ("bar", "baz", "faz"), each of type xs:IDREF. The typed value of a node is never treated as an instance of a named list type. Instead, if the type annotation of a node is a list type (such as xs:IDREFS), its typed value is treated as a sequence of the atomic type from which it is derived (such 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:untyped or denotes a complex type with mixed content (including xs:anyType), then the typed value of the node is equal to its string value, as an instance of xdt:untypedAtomic.

      Example: E1 is an element node having type annotation xdt:untyped 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.

      Example: E5 is an element node with the type annotation my:integer-or-string which is a union type with member types xs:integer and xs:string. The string value of E5 is "47". The typed value of E5 is 47 as an xs:integer, since xs:integer is the member type that validated the content of E5. In general, when the type annotation of a node is a union type, the typed value of the node will be an instance of one of the member types of the union.

      Note:

      If an implementation stores only the string value of a node, and the type annotation of the node is a union type, the implementation must be able to deliver the typed value of the node as an instance of the appropriate member type.

   3. If the type annotation denotes a complex type with empty content, then the typed value of the node is the empty sequence and its string value is the zero-length string.

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

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

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