XQuery 1.0 and XPath 2.0 Functions and Operators -- Review Version

1 Introduction

[XML Schema Part 2: Datatypes] defines a number of primitive and derived datatypes, collectively known as built-in datatypes. This document defines operations on these datatypes as well as the twodatatypes defined in 1.3 xdt:anyAtomicType and xdt:untypedAtomic and the two totally ordered subtypes of xs:duration defined in 9.2 Two Totally Ordered Subtypes of Duration, for use in XQuery, XPath, XSLT and related XML standards. This document also discusses operators and functions on nodes and node sequences as defined in the [XQuery 1.0 and XPath 2.0 Data Model] for use in XQuery, XPath, XSLT and other related XML standards.

1.1 Terminology

The terminology used to describe the functions and operators on [XML Schema Part 2: Datatypes] is defined in the body of this specification. The terms defined in the following list are used in building those definitions:

[Definition] for compatibility: A feature of this specification included to ensure that implementations that use this feature remain compatible with [XPath 1.0]
[Definition] may: Conforming documents and processors are permitted to, but need not, behave as described.
[Definition] must: Conforming documents and processors are required to behave as described; otherwise, they are non-conformant or in error.
[Definition] implementation defined: Possibly differing between implementations, but specified by the implementor for each particular implementation.
[Definition] implementation dependent: Possibly differing between implementations, but not specified by this or other W3C specification, and not required to be specified by the implementor for any particular implementation.
[Definition] stable: Most of the functions in the core library have the property that calling the same function twice with the same arguments returns the same result: these functions are said to be stable. This category includes a number of functions such as fn:doc(), fn:collection(), fn:input(), fn:current-dateTime(), fn:current-date and fn:current-time() whose result depends on the external environment. Where the function returns nodes, stability means that the returned nodes are identical, not merely equal. The scope over which the results are stable depends on the processing context. In XSLT, it applies to any two calls on the function executed during the same transformation. In XQuery, it applies to any two calls executed during the evaluation of a top-level expression i.e. an expression not contained in any other expression. In other contexts, the scope is specified by the host environment that invokes the function library.

Some other functions, for example fn:position() and fn:last(), have an explicit dependency on the dynamic context, and may therefore produce different results each time they are called. These functions are said to be contextual.

1.2 Datatypes

The diagram below shows the built-in [XML Schema Part 2: Datatypes]. Solid lines connect a base datatype above to a derived datatype below. Dashed lines connect a datatype created as a list of an item type above.

Diagram courtesy Asir Vedamuthu, webMethods and Jim Melton, Oracle

1.3 xdt:anyAtomicType and xdt:untypedAtomic

1.3.1 xdt:anyAtomicType

The abstract datatype xdt:anyAtomicType is a child of xs:anySimpleType and is the base type for all the primitive atomic types described in [XML Schema Part 2: Datatypes]. This datatype cannot be used in [XML Schema Part 1: Structures] type declarations, nor can it be used as a base for user-defined atomic types. It can be used in the [XQuery 1.0: An XML Query Language] SequenceType production to define a required type (for example in a function signature) to indicate that any of the primitive atomic types or xdt:untypedAtomic is acceptable. This datatype resides in the namespace http://www.w3.org/2003/05/xquery-datatypes.

1.3.2 xdt:untypedAtomic

The abstract datatype xdt:untypedAtomic is a child of xdt:anyAtomicType and serves as a special type annotation to indicate atomic values that have not been validated by a XML Schema or a DTD or have received an instance type annotation of xs:anySimpleType in the PSVI. This datatype cannot be used in [XML Schema Part 1: Structures] type declarations, nor can it be used as a base for user-defined atomic types. It can be used in the [XQuery 1.0: An XML Query Language] SequenceType production to define a required type (for example in a function signature) to indicate that only an untyped atomic value is acceptable. This datatype resides in the namespace http://www.w3.org/2003/05/xquery-datatypes.

1.4 xs:dateTime, xs:date and xs:time values

xs:dateTime, xs:date and xs:time values are represented in the [XQuery 1.0 and XPath 2.0 Data Model] as tuples: a normalized value with timezone Z and a timezone represented as a xdt:dayTimeDuration value. Lexical representations of xs:dateTime, xs:date and xs:time that have a timezone are converted to timezone Z as defined by [XML Schema Part 2: Datatypes] and the timezone in the lexical representation is converted to a xdt:dayTimeDuration value. Lexical representations that do not contain a timezone are given a normalized value with the timezone Z and the timezone part of the value set to the empty sequence "()".

1.4.1 Examples

A dateTime with lexical representation 1999-05-31T05:00:00 has a value represented by the tuple (1999-05-31T05:00:00Z, ())
A dateTime with lexical representation 1999-05-31T13:20:00-05:00 has a value represented by the tuple (1999-05-31T18:20:00Z, -PT5H)

1.5 Syntax

The purpose of this document is to catalog the functions and operators required for XPath 2.0, XML Query 1.0 and XSLT 2.0. The exact syntax used to invoke these functions and operators is specified in [XPath 2.0], [XQuery 1.0: An XML Query Language]and [XSLT 2.0].

In general, the specifications named above do not support function overloading. Consequently, there are no overloaded functions in this document except for legacy [XPath 1.0] functions such as string(), which takes a single argument of a variety of types, and concat() which takes a variable number of xs:stringarguments. Inaddition, the functions defined in 6 Functions and Operators on Numericsthattake numeric arguments take arguments of type xs:integer,xs:decimal,xs:floator xs:double. Operatorssuch as "+" may be overloaded.

1.6 Notations

This document defines a few newdatatypes, constructor functions and functions that take typed values as arguments. Someof the functions back up operators defined in [XQuery 1.0: An XML Query Language].Each function is defined by specifying its signature, a description of each of its arguments and its semantics. For many functions, examples are included to illustrate their use.

Each function's signature is presented in a form like this:

fn:function-name($parameter-name as parameter-type, ...) as return-type

In this notation, function-name is the name of the function whose signature is being specified. If the function takes no parameters, then the name is followed by an empty set of parentheses: "()"; otherwise, the name is followed by a parenthesized list of parameter declarations, each declaration specifying the static type of the parameter and a non-normative name used to describethe function's semantics.If there are two or more parameter declarations, they are separated by a comma. The return-type specifies the static type of the value returned by the function. In most cases, the dynamic type returned by the function is the same as its static type.

For most functions there is a paragraph describing what the function does followed by semanticrules. These rulesare meant to be followed in the order that they appear in this document.

In some cases, the dynamic type returned by a function depends on the type(s) of its argument(s). These special functions are indicated by using bold italics for the return type. The semantic rules specifying the typeof the value returned are documented in the function definition. The rules are described more formally in Section 6.2 of [XQuery 1.0 and XPath 2.0 Formal Semantics].

The function name is a QName as defined in [XML 1.0 Recommendation (Second Edition)] and must adhere to its syntactic conventions. Following [XPath 1.0], function names are composed of English words separated by hyphens,"-". If a function name contains a [XML Schema Part 2: Datatypes] datatype name, it may have intercapitalized spelling and is used in the function name as such. For example, fn:get-timezone-from-dateTime.

As is customary, the parameter type name indicates that the function accepts arguments of that type, or types derived from it, in that position. This is called subtype substitution. Details of the semantics of passing parameters to functions are discussed in Appendix B of [XQuery 1.0: An XML Query Language].

Some functions accept the empty sequence as an argument and some may return the empty sequence. This is indicated in the function signature by following the parameter or return type name with a question mark: "?"

fn:function-name($parameter-name as parameter-type?) as return-type?

1.7 Namespace Prefix

The functions and operators discussed in this document are contained in one of three namespaces (see [Namespaces in XML]) and referenced using a QName. Constructor functions for the built-in datatypes defined in [XML Schema Part 2: Datatypes] discussed in 5 Constructor Functions are in the XML Schema namespace and named in this document using the xs: prefix. The namespace prefix used in this document is fn: for the functions available to users and op: for the operator functions.The functions indicated by the op: prefix back up operators in the host languagesand are not directly accessible by the user.

The datatypes described in this document are contained in a fourth namespace and are named using the prefix xdt:.

The namespace prefix for these functions and datatypes can vary, as long as the prefix is bound to the correct URI.

The URIs of the namespaces are:

http://www.w3.org/2001/XMLSchema for constructors
http://www.w3.org/2003/05/xpath-operators; for operators
http://www.w3.org/2003/05/xpath-functions for functions.
- http://www.w3.org/2003/05/xpath-datatypes for the datatypes.

The functions defined with an fn: prefix are callable by the user. Functions defined with the op: prefix are described here to underpin the definitions of the operators in [XPath 2.0], [XQuery 1.0: An XML Query Language]and [XSLT 2.0]. These functions are not available directly to users, and there is no requirement that implementations should actually provide these functions. For example, multiplication is generally associated with the * operator, but it is described as a function in this document. For example:

op:multiply($operand1 as numeric, $operand2 as numeric) as numeric

2 Accessors

The [XQuery 1.0 and XPath 2.0 Data Model] describes accessors on different types of nodes and defines their semantics. Some of these accessors are exposed to the user through the functions described below.

Function	Accessor	Accepts	Returns
`fn:node-kind`	`node-kind`	any kind of node
`fn:node-name`	`node-name`	any kind of node
`fn:string`	`string-value`	item
`fn:data`	`typed-value`	zero or more nodes	a sequence of atomic values
`fn:base-uri`	`base-uri`	Element, documentElement or PI node or no argument
`fn:document-uri`	`document-uri`

2.1 fn:node-kind

fn:node-kind($srcval as node) as xs:string

This function returns a xs:stringrepresenting the node's kind: either "document", "element", "attribute", "text", "namespace", "processing-instruction", or "comment".

2.2 fn:node-name

fn:node-name($srcval as node) as xs:QName?

This function returns an expanded-QName for node kinds that can have names. For other node kinds, it returns the empty sequence. Expanded-QName is defined in [XQuery 1.0 and XPath 2.0 Data Model], and consists of a pair of values: a namespace URI and a local name.

2.3 fn:string

fn:string() as xs:string

fn:string($srcval as item?) as xs:string

Returns the value of $srcval represented as a xs:string.If no argument is supplied, $srcval defaults to the context item (.).

If $srcval is the empty sequence, the zero-length string is returned.

If $srcval is a node, the function returns the string-valueof the node, as obtained using the string-value accessor defined in the [XQuery 1.0 and XPath 2.0 Data Model].

If $srcval is an atomic value, then the function returns the same string as is returned by the expression cast as xs:string ($srcval), except in the cases listed below:

If the type of $srcval is xs:anyURI, the URI is converted to a string without any escaping of special characters.

Note:

The reason for the special rule for xs:anyURI is that, although XML Schema strongly discourages the use of spaces within URI values, the escaping of spaces can cause problems with legacy applications (for example, this applies to spaces within fragment identifiers in many HTML browsers), and should therefore be under user control.

Note:

The string representation of xs:doublevalues is not backwards-compatible with the representation of number values in [XPath 1.0]. Ordinary xs:doublevalues are now represented using scientific notation; the representations of positive and negative infinity are now 'INF' and '-INF' rather than 'Infinity' and '-Infinity'. (It should be observed that '+INF' is not supported as a lexical form of infinity in [XML Schema Part 2: Datatypes] and is thus not supported by this specification; if that lexical form is added in a future version of [XML Schema Part 2: Datatypes], then it will be supported by a future version of this specification that aligns with that future version of [XML Schema Part 2: Datatypes].) However, most expressions that would have produced a number in [XPath 1.0] will produce a decimal (or integer) in [XPath 2.0], so unless there is a loss of precision caused by numeric approximation, the result of the expression will in most simple cases be the same after conversion to a string.

2.4 fn:data

fn:data(

$srcval as item*

) as xdt:anyAtomicType*

fn:data takes a sequence of items and returns a sequenceof atomic values.

The result offn:data is the sequenceof atomicvalues produced by applyingthe following rules to each item in $srcval:

If theitem is anatomic value, itisreturned.
If theitem is a node, fn:data()returns the typed value of thenode as defined by the accessor function dm:typed-value in[XQuery 1.0 and XPath 2.0 Data Model].

2.5 fn:base-uri

fn:base-uri($srcval as node) as xs:string?

Returnsthe value of the base-uriproperty for $srcvalas defined by the accessor function dm:base-urifor that kindof node in [XQuery 1.0 and XPath 2.0 Data Model]. Document, element and processing-instruction nodes have abase-uri property. If that property is non-empty, its valueis returned.The base-uriof allother node typesis theempty sequence.

Ifthe accessor is called on a node that doesnot have a base-uri property, or whosebase-uri propertyis empty,the base-uri of that node's parent is returned. If the node hasno parent, the empty sequence is returned.

fn:base-uri() as xs:string?

Thisversion of the function returns the value of the base-uri property from the staticcontext using the preceding rules.

2.6 fn:document-uri

fn:document-uri($srcval as node) as xs:string?

Returnsthe value of the document-uriproperty for $srcvalas defined by the accessorfunction dm:document-uriin [XQuery 1.0 and XPath 2.0 Data Model]. Theempty sequenceis returned if the node doesnot have a document-uri property or if the document-uri property is a relative URI. Otherwise, returns an absolute URI expressed as an xs:string.

Ifthe document-uri property of$srcvalis notthe empty sequence, then the following expression always holds:

fn:doc(fn:document-uri($srcval)) is $srcval

3 The Error Function

In this document, as well as in [XQuery 1.0: An XML Query Language], [XPath 2.0],and [XQuery 1.0 and XPath 2.0 Formal Semantics], the phrase "an error is raised" is used whenever the semantics being described encounter an error. The occurrence of that phrase implicitly causes the invocation of the fn:error function defined in this section. Whenever the raising of an error is accompanied by a specific error, the phrase "an error is raised (name-of-error)" is used, and the value name-of-error is passed as an argument to the fn:error function invocation. Invocation of this function causes the evaluation phase of the outermost XQuery or transformation to be terminated. For a more detailed treatment of error handing see section 2.5.1 of [XQuery 1.0: An XML Query Language] and section 6.2.1 of [XQuery 1.0 and XPath 2.0 Formal Semantics].

The fn:error function may also be invoked from XQuery and XPath 2.0 applications.

fn:error() as none

fn:error($srcval as item?) as none

The fn:error function accepts any item (e.g., an atomic value or an element) as an argument. An alternate version of the function takes no arguments. The fn:error function never returns a value.

Note that "none" is a special type defined in the [XQuery 1.0 and XPath 2.0 Formal Semantics] and is not available to the user. It indicates that the function never returns and ensures that it has the correct static type.

3.1 Examples

fn:error()
fn:error("Invalid argument")
fn:error(<a>Really <emph>dumb</emph> decision!</a>)

4 The Trace Function

This function is intended to be used in debugging queries by providing a trace of their execution.

fn:trace($value as item*, $label as xs:string) as item*

The input $value is returned, unchanged, as the result of the function. In addition, the inputs $value and $label are directed to a trace data set. The location and format of the trace data set are ·implementation defined·. The ordering of output from invocations of the fn:trace() function is ·implementation defined·.

4.1 Examples

Consider a situation in which a user wants to investigate the actual value passed to a function. Assume that in a particular execution, $v is an xs:decimal with value 124.84. Writing fn:trace($v, 'the value of $v is:') will put the strings "124.84" and "the value of $v is" in the trace data set in implementation defined order.

5 Constructor Functions

5.1 Constructor Functions for XML Schema Built-in Types

Every built-in atomic type that is defined in [XML Schema Part 2: Datatypes], except xs:NOTATION, as well as xdt:untypedAtomicand the two derived types xdt:yearMonthDuration and xdt:dayTimeDuration defined in this specification, has an associated constructor function. The form of that function for a type pref:TYPE is:

pref:TYPE($srcval as xdt:anyAtomicType) as pref:TYPE

For example, the signature of the constructor function corresponding to the xs:unsignedInt type defined in [XML Schema Part 2: Datatypes] is:

xs:unsignedInt($srcval as xdt:anyAtomicType) as xs:unsignedInt

Invoking the constructor function xs:unsignedInt(12) returns the xs:unsignedInt value 12. Another invocation of that constructor function that returns the same xs:unsignedInt value is xs:unsignedInt("12"). The same result would also be returned if the constructor function were to be invoked with a node that had a value equal to the xs:unsignedInt 12. The standard features described in [XQuery 1.0: An XML Query Language] would 'atomize' the node to extract its value and then call the constructor with that value. If the value passed to a constructor is illegal for the datatype to be constructed, an error is raised ("Illegal value for constructor").

If the argument to a constructor function is a string literal, the literal must be a valid lexical form for its type, as specified in [XML Schema Part 2: Datatypes] and the semantics of the function are identical to XML Schema validation. In the case of xs:dateTime, xs:date and xs:time, the value returned differs from [XML Schema Part 2: Datatypes] and is defined in 1.4 xs:dateTime, xs:date and xs:time values. Whitespace normalization is applied before validation as indicated by the value of the whitespace facet for the datatype.

If the argument to a constructor function is a literal, the result of the function may be evaluated statically; if an error is found during such evaluation, it may be reported as a static error.

The semantics of the constructor function xs:TYP(xdt:anyAtomicType)are identical to the semantics of "cast as xs:TYP (xdt:anyAtomicType)". See 17 Casting Functions

The following constructor functions for the built-in types are supported:

xs:string($srcval as xdt:anyAtomicType) as xs:string
xs:boolean($srcval as xdt:anyAtomicType) as xs:boolean
xs:decimal($srcval as xdt:anyAtomicType) as xs:decimal
xs:float($srcval as xdt:anyAtomicType) as xs:float

Implementations ·may· return negative zero for xs:float(-0.0E0).
xs:double($srcval as xdt:anyAtomicType) as xs:double

Implementations ·may· return negative zero for xs:double(-0.0E0).
xs:duration($srcval as xdt:anyAtomicType) as xs:duration
xs:dateTime( $srcval as xdt:anyAtomicType) as (xs:dateTime, xdt:dayTimeDuration)
xs:time($srcval as xdt:anyAtomicType) as (xs:time, xdt:dayTimeDuration)
xs:date($srcval as xdt:anyAtomicType) as (xs:date, xdt:dayTimeDuration)
xs:gYearMonth($srcval as xdt:anyAtomicType) as xs:gYearMonth
xs:gYear($srcval as xdt:anyAtomicType) as xs:gYear
xs:gMonthDay($srcval as xdt:anyAtomicType) as xs:gMonthDay
xs:gDay($srcval as xdt:anyAtomicType) as xs:gDay
xs:gMonth($srcval as xdt:anyAtomicType) as xs:gMonth
xs:hexBinary($srcval as xdt:anyAtomicType) as xs:hexBinary
xs:base64Binary($srcval as xdt:anyAtomicType) as xs:base64Binary
xs:anyURI($srcval as xdt:anyAtomicType) as xs:anyURI
xs:anyURI($srcval as xdt:anyAtomicType) as xs:QName

See 17.14 Casting to xs:QName for semantics of xs:anyURI.

xs:normalizedString($srcval as xdt:anyAtomicType) as xs:normalizedString
xs:token($srcval as xdt:anyAtomicType) as xs:token
xs:language($srcval as xdt:anyAtomicType) as xs:language
xs:NMTOKEN($srcval as xdt:anyAtomicType) as xs:NMTOKEN
xs:Name($srcval as xdt:anyAtomicType) as xs:Name
xs:NCName($srcval as xdt:anyAtomicType) as xs:NCName
xs:ID($srcval as xdt:anyAtomicType) as xs:ID
xs:IDREF($srcval as xdt:anyAtomicType) as xs:IDREF
xs:ENTITY($srcval as xdt:anyAtomicType) as xs:ENTITY
xs:integer($srcval as xdt:anyAtomicType) as xs:integer
xs:nonPositiveInteger($srcval as xdt:anyAtomicType) as xs:nonPositiveInteger
xs:negativeInteger($srcval as xdt:anyAtomicType) as xs:negativeInteger
xs:long($srcval as xdt:anyAtomicType) as xs:long
xs:int($srcval as xdt:anyAtomicType) as xs:int
xs:short($srcval as xdt:anyAtomicType) as xs:short
xs:byte($srcval as xdt:anyAtomicType) as xs:byte
xs:nonNegativeInteger($srcval as xdt:anyAtomicType) as xs:nonNegativeInteger
xs:unsignedLong($srcval as xdt:anyAtomicType) as xs:unsignedLong
xs:unsignedInt($srcval as xdt:anyAtomicType) as xs:unsignedInt
xs:unsignedShort($srcval as xdt:anyAtomicType) as xs:unsignedShort
xs:unsignedByte($srcval as xdt:anyAtomicType) as xs:unsignedByte
xs:positiveInteger($srcval as xdt:anyAtomicType) as xs:positiveInteger

xdt:yearMonthDuration($srcval as xdt:anyAtomicType) as xdt:yearMonthDuration
xdt:dayTimeDuration($srcval as xdt:anyAtomicType) as xdt:dayTimeDuration
- xdt:untypedAtomic($srcval as xdt:anyAtomicType) as xdt:untypedAtomic

5.2 Constructor Functions for User-Defined Types

For every globally-defined atomic typein the static context (See [XQuery 1.0: An XML Query Language] that is derived by restriction from a primitive type, there is a constructor function (whose name is the same as the name of the type) whose effect is to create a value of that type from the supplied argument. The rules are defined in the same way as for built-in derived types as discussed in 5.1 Constructor Functions for XML Schema Built-in Types.

Consider a situation where the static context contains a type called hatSize defined in a schema that is bound to the prefix my. In such a case the constructor function:

my:hatSize($srcval as xdt:anyAtomicType) as my:hatSize

is available to users.

6 Functions and Operators on Numerics

This section discusses arithmetic operators on the numeric datatypes defined in [XML Schema Part 2: Datatypes]. It uses an approach that permits lightweight implementation whenever possible.

6.1 Numeric Types

The operators described in this section are defined on the following numeric types. Each type whose name is indented is derived from the type whose name appears nearest above with one less level of indent.

xs:decimal
	xs:integer
xs:float
xs:double

They also apply to types derived by restriction from these types.

Note:

The value space for xs:float and xs:double, as defined in the errata to [XML Schema Part 2: Datatypes], defines only a single zero. [IEEE 754-1985] arithmetic, however, can produce distinct results of positive zero and negative zero. The value space for atomic values of type xs:float and xs:double, as defined in this suite of documents, contains this extra value of negative zero which compares equal to positive zero. The value negative zero will never be obtained from the typed value of a node. However, negative zero may be produced as the result of a computation; for example, the unary minus operator produces negative zero if its operand is positive zero.

6.2 Operators on Numeric Values

The following functions are defined to back up operators defined in [XQuery 1.0: An XML Query Language] and [XPath 2.0] on these numeric types.

The arguments and return types for the arithmetic operators are the basic numeric types: xs:integer, xs:decimal, xs:floatand xs:double, and types derived from them. For simplicity, each operator is defined to operate on operands of the same type and to return the same type. The one exception is op:numeric-divide, which returns an xs:decimalif called with two xs:integeroperands.)

Operands of type xdt:untypedAtomic are converted to xs:double, except for arguments to 6.2.5 op:numeric-integer-divide which are converted to xs:integer. If the two operands are not of the same type, subtype substitution and type promotion may be used to obtain two operands of the same type. Appendix B of [XQuery 1.0: An XML Query Language] describes the semantics of these operations in detail.

Subtype substitution: A derived type may substitute for its base type. In particular, xs:integer may be used where xs:decimal is expected.
Type promotion: xs:decimal may be promoted to xs:float, and xs:float may be promoted to xs:double.

The result type of operations depends on their argument datatypes and is defined in the following table:

Operator	Returns
`op:operation(xs:integer, xs:integer)`
`op:operation(xs:decimal, xs:decimal)`
`op:operation(xs:float, xs:float)`
`op:operation(xs:double, xs:double)`
`op:operation(xs:integer)`
`op:operation(xs:decimal)`
`op:operation(xs:float)`
`op:operation(xs:double)`

These rules define any operation on any pair of arithmetic types. Consider the following example:

op:operation(xs:int, xs:double) => op:operation(xs:double, xs:double)

For this operation, xs:int must be converted to xs:double. This can be done, since by the rules above: xs:int can be substituted for xs:integer, xs:integer can be promoted to xs:decimal, xs:decimal can be promoted to xs:float, and xs:float can be promoted to xs:double. As far as possible, the promotions should be done in a single step. Specifically, when a decimal is promoted to a double, it must not be converted to a float and then to double, as this risks lossof precision.

As another example, a user may define height as a derived type of xs:integer with a minimum value of 20 and a maximum value of 100. He may then derive oddHeight using a pattern to restrict the value to odd integers.

op:operation(oddHeight, xs:integer) => op:operation(xs:integer, xs:integer)

oddHeight can be substituted for its base type height and height can be substituted for its base type xs:integer.

On overflowand underflow situations during arithmeticoperationsconforming implementations ·must·behave as follows:

For xs:float and xs:doubleoperations, overflow behavior ·must·be conformant with [IEEE 754-1985].This specification allows a number of options:
- Raisingan error ("overflow on float or doubleoperation") via an overflow trap.
- ReturningINFor -INF.
- Returning thelargest (positive ornegative) non-infinite number.
For xs:floatand xs:doubleoperations, underflow behavior ·must·be conformant with [IEEE 754-1985]. This specification allows a number of options:
- Raising an error ("underflow on float or double operation") via an underflowtrap.
- Returning 0.0E0or +/-2**Eminor a denormalized value; where Emin isthe smallest possible xs:float or xs:doubleexponent.
For xs:decimaloperations, overflow behavior ·must·raise an error ("overflow on decimal operation"). Onunderflow, 0.0must be returned.
For xs:integer operations, implementations ·may· choose to always raise an error("overflow on integer operation"). Alternatively, implementations ·may· provide an ·implementation defined· mechanism that allows users to choose between raising an errorand returning a result that is modulo the largest representable integer value. See [ISO 10967].

The functions op:numeric-add, op:numeric-subtract, op:numeric-multiply, op:numeric-divide, op:numeric-integer-divideand op:numeric-mod are each defined for pairs of numeric operands, each of which has the same type: xs:integer, xs:decimal,xs:float,or xs:double.The functions op:numeric-unary-plus and op:numeric-unary-minus are defined for a single operand whose type is one of those same numeric types.

For xs:float and xs:double arguments, if either argument is NaN, the result is NaN.

The number of digits of precision returned by various numeric functions is ·implementation dependent·.

6.2.1 op:numeric-add

op:numeric-add($operand1 as numeric, $operand2 as numeric) as numeric

Backs up the "+" operator and returns the arithmetic sum of its operands: ($operand1 + $operand2).

6.2.2 op:numeric-subtract

op:numeric-subtract($operand1 as numeric, $operand2 as numeric) as numeric

Backs up the "-" operator and returns the arithmetic difference of its operands: ($operand1 - $operand2).

6.2.3 op:numeric-multiply

op:numeric-multiply($operand1 as numeric, $operand2 as numeric) as numeric

Backs up the "*" operator and returns the arithmetic product of its operands: ($operand1 * $operand2).

6.2.4 op:numeric-divide

op:numeric-divide($operand1 as numeric, $operand2 as numeric) as numeric

Backs up the "div" operator and returns the arithmetic quotient of its operands: ($operand1 div $operand2).

As a special case,if the types of both $operand1 and $operand2 are xs:integer, then the return type is xs:decimal.

For xs:decimal and xs:integer operands, if the divisor is 0, then an error is raised ("Division by zero"). For xs:float and xs:double operands, floating point division is performed as specified in [IEEE 754-1985] and INF or -INF is returned if the divisor is zero.

6.2.5 op:numeric-integer-divide

`op:numeric-integer-divide`(	`$operand1`	`as` `xs:integer`,
`op:numeric-integer-divide`(	`$operand2`	`as` `xs:integer`) `as` `xs:integer`

Backs up the "idiv" operator and returns the arithmetic quotient of its operands: ($operand1 idiv $operand2). If the numerator is not evenly divided by the divisor, then the quotient is the xs:integervalue obtained, ignoring any remainder that results from the division (that is, no rounding is performed).

If the divisor is 0, then an error is raised ("Division by zero").

6.2.5.1 Examples

op:numeric-integer-divide(10,3) returns 3
op:numeric-integer-divide(3,-2) returns -1
op:numeric-integer-divide(-3,2) returns -1
op:numeric-integer-divide(-3,-2) returns 1

6.2.6 op:numeric-mod

op:numeric-mod($operand1 as numeric, $operand2 as numeric) as numeric

Backs up the "mod" operator. Informally,this functionreturns the remainder resulting fromdividing $operand1, the dividend,by $operand2, the divisor. The operation amod b for operands that are xs:integer or xs:decimal, or types derived from them, produces a result suchthat (a/b)*b+(a mod b)is equalto a and the magnitude of the result is always less than the magnitude of the divisor. This identity holds even inthe special case that thedividend is thenegativeinteger oflargest possible magnitude for its type andthe divisor is -1 (the remainder is 0). It follows from this rule that the sign of the result is the sign of the dividend. If $operand2 is 0, then an error is raised ("Division by zero").

For xs:float and xs:double operands the following rules apply:

If either operand is NaN,the result is NaN.
If the dividend is positive or negative infinity, or the divisor is positive or negative zero (0), or both, the result is NaN.
If the dividend is finite and the divisor is an infinity, the result equals the dividend.
If the dividend is positive or negative zero and the divisor is finite, the result is the same as the dividend.
In the remaining cases, where neither positive or negative infinity, nor positive or negative zero, nor NaN is involved, the resultobeys (a/b)*b+(amod b)= a. Divisionis truncating division, analogous to integer division, not [IEEE 754-1985] rounding division.

6.2.6.1 Examples

op:numeric-mod(10,3) returns 1.
op:numeric-mod(6,-2) returns 0.
op:numeric-mod(4.5,1.2) returns 0.9.
op:numeric-mod(1.23E2, 0.6E1) returns 3.0E0.

6.2.7 op:numeric-unary-plus

op:numeric-unary-plus($operand as numeric) as numeric

Backs up the unary "+" operator and returns its operand with the sign unchanged: (+ $operand). Semantically, this operation performs no operation.

6.2.8 op:numeric-unary-minus

op:numeric-unary-minus($operand as numeric) as numeric

Backs up the unary "-" operator and returns its operand with the sign reversed: (- $operand). If $operand is positive, its negative is returned; if it is negative, its positive is returned.

For xs:integer and xs:decimal arguments, 0 and 0.0 return 0 and 0.0, respectively. For xs:float and xs:double arguments, NaN returns NaN, 0.0E0 returns -0.0E0 and vice versa. INF and +INF return -INF. -INF returns INF.

6.3 Comparison of Numeric Values

This specification definesthe following comparison operators on numeric values. Comparisons take two arguments of the same type. Arguments of type xdt:untypedAtomic are converted to xs:double. If the arguments are of different types, one argument is promoted to the type of the other as described above in 6.2 Operators on Numeric Values.Each comparison operator returns a boolean value. If either, or both, operands are NaN,false is returned.

6.3.1 op:numeric-equal

op:numeric-equal($operand1 as numeric, $operand2 as numeric) as xs:boolean

Returns true if and only if the value of $operand1 is equal to the value of $operand2. For xs:float and xs:double values, 0 (zero), +0 (positive zero) and -0 (negative zero) all compare equal. NaN does not equal itself.

This function backs up the "eq" and "ne" operators on numeric values.

6.3.2 op:numeric-less-than

op:numeric-less-than($operand1 as numeric, $operand2 as numeric) as xs:boolean

Returns true if and only if $operand1 is less than $operand2. For xs:float and xs:double values, positive infinity is greater than all other non-NaNvalues; negative infinity is less than all other non-NaN values. If $operand1or $operand2is NaN,the function returns false.

This function backs up the "lt" and "ge" operators on numeric values.

6.3.3 op:numeric-greater-than

`op:numeric-greater-than`(	`$operand1`	`as` `numeric`,
`op:numeric-greater-than`(	`$operand2`	`as` `numeric`) `as` `xs:boolean`

Returns true if and only if $operand1 is greater than $operand2. For xs:float and xs:double values, positive infinity is greater than all other non-NaNvalues; negative infinity is less than all other non-NaN values. If $operand1or $operand2is NaN,the function returns false.

This function backs up the "gt" and "le" operators on numeric values.

6.4 Functions on Numeric Values

The following functions are defined on numeric types. Each function returns a value of the same type as the typeof its argument.

If the argument is the empty sequence, the empty sequence is returned.
If the argument is xdt:untypedAtomic it is converted to xs:double.
- For xs:float and xs:double arguments, if the argument is "NaN", "NaN" is returned.
For xs:float and xs:double arguments, ifthe argument is positive or negative infinity, positive or negative infinity is returned.

fn:floor

fn:ceiling

fn:round

fn:round-half-to-even

6.4.1 fn:floor

fn:floor($srcval as numeric?) as numeric?

Returns a value of the same type as $srcval. Specifically, returns the largest (closest to positive infinity) number with no fractional partthat is not greater than the value of $srcval.

For float and double arguments, if the argument is positive zero (+0), then positive zero (+0) is returned. Ifthe argument is negative zero (-0), then negative zero (-0) is returned.

For detailed semantics, see section 6.2.6 of [XQuery 1.0 and XPath 2.0 Formal Semantics].

6.4.1.1 Examples

fn:floor(10.5) returns 10.
fn:floor(-10.5) returns -11.

6.4.2 fn:ceiling

fn:ceiling($srcval as numeric?) as numeric?

Returns a value of the same type as $srcval. Specifically, returns the smallest (closest to negative infinity) number with no fractional partthat is not less than the value of $srcval.

For xs:float and xs:double arguments, ifthe argument is positive zero (+0), then positive zero (+0) is returned. If the argument is negative zero (-0), then negative zero (-0) isreturned. If the argument is less than zero (0), but greater than or equal to -0.5, then negative zero (-0) is returned.

For detailed semantics, see section 6.2.6 of [XQuery 1.0 and XPath 2.0 Formal Semantics].

6.4.2.1 Examples

fn:ceiling(10.5) returns 11.
fn:ceiling(-10.5) returns -10.

6.4.3 fn:round

fn:round($srcval as numeric?) as numeric?

Returns a value of the same type as $srcval. Specifically, returns the number with no fractional part that is closest to the argument. If there are two such numbers, then the one that is closest to positive infinity is returned. More formally, fn:round(x) produces the same result as fn:floor(x+0.5).

For xs:float and xs:double arguments,if the argument is positive zero (+0), then positive zero (+0)is returned. If the argument is negative zero (-0),then negative zero (-0) is returned. If the argument is less than zero (0), but greater thanor equal to -0.5, then negative zero (-0) is returned.

For detailed semantics, see section 6.2.6 of [XQuery 1.0 and XPath 2.0 Formal Semantics].

6.4.3.1 Examples

fn:round(2.5) returns 3.
fn:round(2.4999) returns 2.
fn:round(-2.5) returns -2 (not the possible alternative, -3).

6.4.4 fn:round-half-to-even

fn:round-half-to-even($srcval as numeric?) as numeric?

fn:round-half-to-even($srcval as numeric?, $precision as integer) as numeric?

The first signature of this function produces the sameresult as the second signature with $precision=0.

Returns a value of the same type as $srcval.

For arguments of type xs:float and xs:double, if the argument is positive zero (+0), then positive zero (+0) is returned. If the argument is negative zero (-0), then negative zero (-0) is returned.

The value returned is the nearest (that is, numerically closest) numeric to $srcvalthat is a multiple of ten to the power of minus $precision.If two such values are equally near (i.e. if the fractional part in $srcval is exactly .500...), returns the one whose least significant digit is even.

If $srcvalis of type xs:float or xs:double, rounding occurs on the value of the mantissa computed with exponent = 0.

For detailed semantics, see section 6.2.6 of [XQuery 1.0 and XPath 2.0 Formal Semantics].

6.4.4.1 Examples

fn:round-half-to-even(1.5) returns the value corresponding to 2.
fn:round-half-to-even(2.5) returns the value correspondingto 2.
fn:round-half-to-even(3.567812E+3, 2) returns the value corresponding to 3567.81E0.
fn:round-half-to-even(4.7564E-3, 2)returns the value corresponding to0.0E0.
fn:round-half-to-even(35612.25, -2) returns the value corresponding to 35600.

7 Functions on Strings

This section discusses functions and operators on the [XML Schema Part 2: Datatypes] xs:stringdatatype and the datatypes derived from it.

7.1 String Types

The operators described in this section are defined on the following types. Each type whose name is indented is derived from the type whose name appears nearest above with one less level of indent.

xs:string
	xs:normalizedString
		xs:token
			xs:language
			xs:NMTOKEN
			xs:Name
				xs:NCName
					xs:ID
					xs:IDREF
					xs:ENTITY

They also apply to user-defined types derived by restriction from these types.

Note:

This document uses the term "code point" as a synonym for "Unicode scalar value". [The Unicode Standard]sometimes spells this term "codepoint". Code points range from #x0000 to #x10FFFF inclusive, except for the range #xD800 to #xDFFF inclusive, which is the range reserved for surrogate pairs.The use of the word 'character' in this document is in the sense of production [2] of [XML 1.0 Recommendation (Second Edition)].

7.2 Functions to Assemble and Disassemble Strings

Function	Meaning
`fn:codepoints-to-string`
`fn:string-to-codepoints`

7.2.1 fn:codepoints-to-string

fn:codepoints-to-string($srcval as xs:integer*) as xs:string

Creates an xs:stringfrom a sequence of code points. Returns the zero-length string if $srcval is the empty sequence. If any of the codepoints in $srcval is not a legal XML character, an error is raised ("codepoint not legal").

7.2.2 fn:string-to-codepoints

fn:string-to-codepoints($srcval as xs:string) as xs:integer*

Returns the sequence of code points that constitute an xs:string. If $srcval is a zero-length string, the empty sequence is returned.

7.3 Equality and Comparison of Strings

When values whose type is xs:stringor a type derived from xs:stringare compared (or, equivalently, sorted), the comparisons are inherently performed according to some collation (even if that collation is defined entirely on code point values or on the binary representations of the characters of the string). The [Character Model for the World Wide Web 1.0] observes that some applications may require different comparison and ordering behaviors than other applications. Similarly, some users having particular linguistic expectations may require different behaviors than other users. Consequently, the collation must be taken into account when comparing strings in any context. Several functions in this and the following section make use of a collation.

Collations can indicate that some characters that are rendered differently are, in fact, equal for collation purpose (e.g., "uve" and "uwe" are considered equivalent in some European languages). Strings can be compared character-by-character or in a logical manner, as defined by the collation.

Some collations, especially those based on the [Unicode Collation Algorithm] can be "tailored" for various purposes. This document does not discuss such tailoring. Instead, it assumes that the collation argument to the various functions below is a tailored and named collation. A specific collation with a distinguished name, http://www.w3.org/2003/05/xpath-functions/collation/codepoint,provides the ability to compare strings based on code point values. Every implementation of XQuery must support the collation based on code point values.

While the [Character Model for the World Wide Web 1.0] recommends that all strings be subjected to early Unicode normalization, it is not possible to guarantee that all strings in all XML documents are, in fact, normalized, or that they are normalized in the same manner. In order to maximize interoperable results of operations on XML documents in general, there may be collations that operate on unnormalized strings, other collations that raise runtime errors when unnormalized strings are encountered, and still other collations that implicitly normalize strings for the purposes of collating them. For alignment with the [Character Model for the World Wide Web 1.0], applications may choose collations that treat unnormalized strings as though they were normalized (that is, that implicitly normalize the strings). Note that collations based on the Unicode collation algorithm produce equivalent results regardless of a string's normalization.

This specification assumes that collations are named and that the collation name may be provided as an argument to string functions. Functions that allow specification of a collation do so with an argument whose type is xs:string but whose lexical representation must conform to xs:anyURI.If the collation is specified using a relative URI, it is assumed to be relative to the value of the base-uri property in the static context. This specification also defines the manner in which a default collation is determined if the collation argument is not specified in invocations of functions that use a collation but allow it to be omitted.

The XQuery/XPath static context includes provision for a default collation that can be used for string comparisons (including ordering operations). However, the static context is not required to have a default collation specified; an implementation might choose to provide a default collation only under certain circumstances, or not at all. The static context default collation, if provided, is determined by ·implementation defined· means. Such means might include determination from the host operating system environment, determination during XQuery/XPath installation, determination when the XQuery/XPath implementation was created, determination from the locale of some user environment, or even ·implementation defined· language through which the user can specify that collation.

The decision of what collation to use for a given comparison or ordering operation is determined by the following algorithm:

If the operation specifies an explicit collation CollationA (e.g., if the optional collation argument is specified in an invocation of the fn:compare() function), then:
- If CollationA is supported by the implementation, then CollationA is used.
- Otherwise, an error is raised ("Unsupported collation").
If no collation is explicitly specified for the operation and the XQuery/XPath static context specifies a collation CollationB, then:
- If CollationB is supported by the implementation, then CollationB is used.
- Otherwise, an error is raised ("Unsupported collation").
Note:

There might be several ways in which a collation might be specified in the XQuery/XPath static context. For example, XQuery might provide syntax that specifies a default collation as part of the query prolog.
Otherwise, the Unicode codepoint collation (http://www.w3.org/2003/05/query-operators/collation/codepoint) is used.

XML allows elements to specify the xml:lang attribute to indicate the language associated with the content of such an element. This specification does not use xml:lang to identify the default collation, in part because collations should be determined by the user of the data, not (normally) the data itself, and because using xml:lang does not produce desired effects when the two strings to be compared have different xml:lang values or when a string is multilingual.

Note:

Some data management environments allow collations to be associated with the definition of string items (that is, with the metadata that describes items whose type is string). While such association may be appropriate for use in environments in which data is held in a repository tightly bound to its descriptive metadata, it is not appropriate in the XML environment in which different documents being processed by a single query may be described by differing schemas.

Note:

Allcollations support the capability of deciding whether two strings are considered equal, and if not, which of the strings should be regarded as preceding the other. For functions such as fn:compare(), this is all that is required. For other functions, such as fn:contains(), the collation needs to support an additional property: it must decompose the string into a sequence of units, each unit consisting of one or more characters, such that two strings can be compared by pairwise comparison of these units. Functions suchas fn:contains(),fn:starts-with(),fn:ends-with(), fn:substring-before() and fn:substring-after() first use the collation to decompose the string provided in the first argument into such a sequence of units, then examine this sequence to determine if there is a subsequence that matches the units obtained by decomposing the string supplied in the second argument. This might occasionallylead to surprises. For example, consider a collation that treats"Jaeger" and "Jäger" as equal. It mightdo this by treating "ä" asrepresenting two collation units, inwhich case the expressionfn:contains("Jäger","eg")will return true.Alternatively, a collation might treat"ae" as a single collationunit, in which case the expression fn:contains("Jaeger", "eg") will return false. Theresults of these functions thus depends strongly on the properties of the collation that is used.

It is possible to define collations that do not have this property, for example a collation that attempts to sort "ISO 8859" before "ISO 10646", or "January" before "February". Such collations may fail, or give unexpected results, when used with functions such as fn:contains().

7.3.1 fn:compare

fn:compare($comparand1 as xs:string?, $comparand2 as xs:string?) as xs:integer?

`fn:compare`(	`$comparand1`	`as` `xs:string?`,
	`$comparand2`	`as` `xs:string?`,
	`$collationLiteral`	`as` `xs:string`) `as` `xs:integer?`

Returns -1, 0, or 1, depending on whether the value of the $comparand1 is respectively less than, equal to, or greater than the value of $comparand2, according to the rules of the collation that is used.

The collation used by the invocation of this function is determined according to the rules in 7.3 Equality and Comparison of Strings.

If $collationLiteral is not in the lexical space of xs:anyURI, an error is raised ("Invalid argument to compare function").

If the value of $comparand2 begins with a string that is equal to the value of $comparand1 (according to the collation that is used) and has additional characters following that beginning string, then the result is -1. If the value of $comparand1 begins with a string that is equal to the value of $comparand2 (according to the collation that is used) and has additional characters following that beginning string, then the result is 1.

If either argument is the empty sequence, the result is the empty sequence.

This function backs up the "eq", "ne", "gt", "lt", "le" and "ge" operators on string values.

7.3.1.1 Examples

fn:compare('abc', 'abc') returns 0.
fn:compare('Strasse', 'Straße') returns 0 if and only if the default collation includes provisions that equate "ss" and the (German) character "ß" ("sharp-s"). (Otherwise, the returned value depends on the semantics of the default collation.)
fn:compare('Strasse', 'Straße', 'deutsch') returns 0 if and only if the collation identified by the relative URI constructed from the string value "deutsch" includes provisions that equate "ss" and the (German) character "ß" ("sharp-s"). (Otherwise, the returned value depends on the semantics of that collation.)
fn:compare('Strassen', 'Straße') returns 1 if and only if the default collation includes provisions that equate "ss" and the (German) character "ß" ("sharp-s"). (Since the value of $comparand1 has an additional character, an "n", following the string that is equal to "Straße", it is greater than the value of $comparand2.)

7.4 Functions on String Values

The following functions are defined on these string types. Several of these function use a collation. See 7.3 Equality and Comparison of Strings for a discussion of collations.

Note also that when the above operators and functions are applied to datatypes derived from xs:string, they are guaranteed to return legal xs:strings,but they might not return a legal value for the particular subtype to which they were applied.

7.4.1 fn:concat

fn:concat() as xs:string

fn:concat($op1 as xs:string?) as xs:string

fn:concat($op1 as xs:string?, $op2 as xs:string?, ...) as xs:string

Accepts zero or more xs:stringsas arguments. Returns the xs:stringthat is the concatenation of the values of its arguments. The resulting xs:stringmight not be normalized according toany Unicode or W3C normalization form.If called with no arguments, returns the zero-length string. If any of the arguments is the empty sequence, it is treated as the zero-length string.

The concat() function is specified to allow an arbitrary number of xs:stringarguments that are concatenated together. This is the only function specified in this document that has that characteristic. This capability is retained for compatibility with [XPath 1.0].

7.4.1.1 Examples

fn:concat('abc', 'def') returns " abcdef ".
fn:concat('abc', '', 'def') returns " abcdef ".
- fn:concat('abc') returns " abc ".
fn:concat('abc', 'def', 'ghi', 'jkl', 'mno') returns " abcdefghijklmno ".
fn:concat(()) returns "".

7.4.2 fn:string-join

fn:string-join($operand1 as xs:string*, $operand2 as xs:string) as xs:string

Returns a (possibly empty) xs:stringcreated by concatenating the members of the $operand1 sequence using $operand2 as a separator. If the value of $operand2 is the zero-length string, then the members of $operand1 are concatenated without a separator as in fn:concat().

If the value of $operand1 is the empty sequence, the zero-length string is returned.

7.4.2.1 Examples

fn:string-join(('Now', 'is', 'the', 'time', '...'), " ") returns "Now is the time ..." .
fn:string-join(("abra", "cadabra"), "") returns "abracadabra" .
fn:string-join((), "separator") returns "" .
- Assume a document:
```
<doc>
  <chap>
    <section>
    </section>
  </chap>
</doc>
```
  with the <section> as the context node,
  
  fn:string-join(for $n in ancestor-or-self::* return name(.), '/') returns "doc/chap/section"

7.4.3 fn:starts-with

fn:starts-with($operand1 as xs:string?, $operand2 as xs:string?) as xs:boolean?

`fn:starts-with`(	`$operand1`	`as` `xs:string?`,
	`$operand2`	`as` `xs:string?`,
	`$collationLiteral`	`as` `xs:string`) `as` `xs:boolean?`

Returns an xs:booleanindicating whether or not the value of $operand1 starts with a string that is equal to the value of $operand2 according to the collation that is used.

If $collationLiteral is notin the lexical space ofxs:anyURI, an error is raised ("Invalid collationURI").

If the value of $operand1 or $operand2 is the empty sequence, the empty sequence is returned.

If the value of $operand2 is the zero-length string, then the function returns true. If the value of $operand1 is the zero-length string and the valueof $operand2 is not the zero-length string, then the function returns false.

The collation used by the invocation of this function is determined according to the rules in 7.3 Equality and Comparison of Strings.

7.4.3.1 Examples

fn:starts-with("goldenrod", "gold") returns true.
fn:starts-with("goldenrod", "") returns true.
fn:starts-with("goldenrod", "rod") returns false.

7.4.4 fn:ends-with

fn:ends-with($operand1 as xs:string?, $operand2 as xs:string?) as xs:boolean?

`fn:ends-with`(	`$operand1`	`as` `xs:string?`,
	`$operand2`	`as` `xs:string?`,
	`$collationLiteral`	`as` `xs:string`) `as` `xs:boolean?`

Returns an xs:booleanindicating whether or not the value of $operand1 ends with a string that is equal to the value of $operand2 according to the specified collation.

If $collationLiteral is notin the lexical space of xs:anyURI, an error is raised ("Invalid collationURI").

If the value of $operand1 or $operand2 is the empty sequence, the emptysequence is returned.

If the value of $operand2 is the zero-length string, then the function returns true. If the value of $operand1 is the zero-length string andthe value of $operand2 is not the zero-length string, then the function returns false.

The collation used by the invocation of this function is determined according to the rules in 7.3 Equality and Comparison of Strings.

7.4.4.1 Examples

fn:ends-with("goldenrod","rod") returns true.
fn:ends-with("", "rod") returns false.

7.4.5 fn:contains

fn:contains($operand1 as xs:string?, $operand2 as xs:string?) as xs:boolean?

`fn:contains`(	`$operand1`	`as` `xs:string?`,
	`$operand2`	`as` `xs:string?`,
	`$collationLiteral`	`as` `xs:string`) `as` `xs:boolean?`

If$collationLiteralis not in the lexical spaceof xs:anyURI, an error is raised ("Invalid collationURI").

Ifthe value of $operand1 or $operand2 is the empty sequence,the empty sequence is returned.

If the value of $operand2 is the zero-length string, then the function returns true. If the value of $operand1 is the zero-length string and the value of $operand2 is not the zero-length string, then the function returns false.

Otherwise, returns anxs:boolean indicating whether or not the value of $operand1 contains (at the beginning, at the end, or anywherewithin) a string equal to the value of $operand2 according tothe collation that is used. The collation used by the invocation of this function is determined according to the rules in 7.3 Equality and Comparison of Strings.

7.4.6 fn:substring

`fn:substring`(	`$sourceString`	`as` `xs:string?`,
`fn:substring`(	`$startingLoc`	`as` `xs:double`) `as` `xs:string?`

`fn:substring`(	`$sourceString`	`as` `xs:string?`,
	`$startingLoc`	`as` `xs:double`,
	`$length`	`as` `xs:double`) `as` `xs:string?`

If the value of $sourceString is the empty sequence, the empty sequence is returned.

Otherwise, returnsthe portion of the value of $sourceString beginning at the position indicated by the value of $startingLoc and continuing for the number of characters indicated by the value of $length. More specifically, returns the characters in $sourceString whose position $p obeys:

fn:round($startingLoc) <= $p < fn:round($startingLoc) + fn:round($length)

In the above computation, the rules for op:numeric-less-than() and op:numeric-greater-than() apply.

If $startingLoc is zero or negative, the substring includes characters from the beginning of the $sourceString.

If $length is not specified, the substring includes characters to the end of $sourceString.

If $length is greater than the number of characters in the value of $sourceString following $startingLoc, the substring includes characters to the end of $sourceString.

The first character of a string is located at position 1, not position 0.

Note:

The position and length given in the second and (optional) third argument relate to the number of XML characters in the string (or equivalently, the number of Unicode code points).Some implementations may represent a code pointabove xFFFF using two 16-bit values known as a surrogate pair. A surrogate pair counts as one character, not two.

7.4.6.1 Examples

fn:substring("motor car", 6) returns " car".

Characters starting at position 6 to the end of $sourceString are selected.
fn:substring("metadata", 4, 3) returns "ada".

Characters at positions greater than or equal to 4 and less than 7 are selected.
- fn:substring("12345", 1.5, 2.6) returns "234".
  
  Characters at positions greater than or equal to 2and less than 5 are selected.
- fn:substring("12345", 0,3) returns "12".
  
  Characters at positions greater than or equal to 0 and less than 3 are selected.
- fn:substring("12345", 0 div 0, 3) returns "".
  
  Since 0 div 0 returns NaN, and NaN compared to any other number returns false, no characters are selected.
- fn:substring("12345", 1, 0 div 0) returns "".
  
  As above.
- fn:substring("12345", -42, 1 div 0) returns "12345".
  
  Characters at positions greater than or equal to -42 and less than INF are selected.
- fn:substring("12345", -1 div 0, 1 div 0) returns "".
  
  Since -INF + INF returns NaN, no characters are selected.

7.4.7 fn:string-length

fn:string-length() as xs:integer?

fn:string-length(

$srcval as xs:string?

) as xs:integer?

Returns an xs:integerequal to the length in characters of the value of $srcval. If the value of $srcval is the empty sequence, the empty sequence is returned. If no argument is supplied, $srcval defaults to the string value (calculated using fn:string()) of the context item (.).

Note:

The value returned is the number of XML characters in the string (or equivalently, the number of Unicode code points).Some implementations may represent a code pointabove xFFFF using two 16-bit values known as a surrogate pair. A surrogate pair counts as one character, not two.

7.4.7.1 Examples

fn:string-length("first we kill the lawyers") returns 25.

7.4.8 fn:substring-before

`fn:substring-before`(	`$operand1`	`as` `xs:string?`,
`fn:substring-before`(	`$operand2`	`as` `xs:string?`) `as` `xs:string?`

`fn:substring-before`(	`$operand1`	`as` `xs:string?`,
	`$operand2`	`as` `xs:string?`,
	`$collationLiteral`	`as` `xs:string`) `as` `xs:string?`

Returns the substring of the value of $operand1 that precedes in the value of $operand1 the first occurrence of a string that is equal to the value of $operand2 according to the collation that is used.

If $collationLiteral is not in the lexical space of xs:anyURI an error is raised ("Invalid collationURI").

If the value of $operand1 or $operand2 is the empty sequence, returns the empty sequence.

If the value of $operand2 is the zero-length string, then the function returns the value of $operand1.

If the value of $operand1 does not contain a string that is equal to the value of $operand2, then the function returns the zero-length string.

The collation used by the invocation of this function is determined according to the rules in 7.3 Equality and Comparison of Strings.

7.4.8.1 Examples

fn:substring-before("abcdabcd","d") returns "abc".
fn:substring-before("abcd","") returns "abcd".

7.4.9 fn:substring-after

fn:substring-after($operand1 as xs:string?, $operand2 as xs:string?) as xs:string?

`fn:substring-after`(	`$operand1`	`as` `xs:string?`,
	`$operand2`	`as` `xs:string?`,
	`$collationLiteral`	`as` `xs:string`) `as` `xs:string?`

Returns the substring of the value of $operand1 that follows in the value of $operand1 the first occurrence of a string that is equal to the value of $operand2 according to the collation that is used.

If $collationLiteral is not in the lexical space of xs:anyURI an error is raised ("Invalid collationURI").

If the value of $operand1 or $operand2 is the empty sequence, returns the empty sequence.

If the value of $operand2 is the zero-length string, then the function returns the value of $operand1.

If the value of $operand1 does not contain a string that is equal to the value of $operand2, then the function returns the zero-length string.

The collation used by the invocation of this function is determined according to the rules in 7.3 Equality and Comparison of Strings.

7.4.9.1 Examples

fn:substring-after("abcdabcd","d") returns "abcd".
- fn:substring-after("abcd","") returns "".

7.4.10 fn:normalize-space

fn:normalize-space() as xs:string?

fn:normalize-space(

$srcval as xs:string?

) as xs:string?

Returns the value of $srcvalwith whitespace normalized by stripping leading and trailing whitespace and replacing sequences of more than one whitespace character by a single space, #x20.If the value of $srcval is the empty sequence, returns the empty sequence. If no argument is supplied, $srcval defaults to the string value (calculated using fn:string()) of the context item (.).

7.4.10.1 Examples

fn:normalize-space(" hello world ") returns "hello world".

7.4.11 fn:normalize-unicode

fn:normalize-unicode($srcval as xs:string?) as xs:string?

`fn:normalize-unicode`(	`$srcval`	`as` `xs:string?`,
`fn:normalize-unicode`(	`$normalizationForm`	`as` `xs:string`) `as` `xs:string?`

If the value of $srcval is the empty sequence, returns the empty sequence.

Otherwise, returnsthe value of $srcval normalized according to the normalization criteria for a normalization form identified by the value of $normalizationForm. The effective value of the $normalizationForm is computed by removing leading and trailing blanks, if present, and converting to upper case.

If the $normalizationForm is absent, as in the first format above, it shall be assumed to be "NFC"

If the effective value of $normalizationForm is "NFC", then the value returned by the function is the value of $srcval in Unicode Normalization Form C (NFC).
If the effective value of $normalizationForm is "NFD", then the value returned by the function is the value of $srcval in Unicode Normalization Form D (NFD).
If the effective value of $normalizationForm is "NFKC", then the value returned by the function is the value of $srcval in Unicode Normalization Form KC (NFKC).
If the effective value of $normalizationForm is "NFKD", then the value returned by the function is the value of $srcval in Unicode Normalization Form KD (NFKD).
If the effective value of $normalizationForm is "W3C", then the value returned by the function is the value of $srcval is the fully normalized form. See [Character Model for the World Wide Web 1.0].
If the effective value of $normalizationForm is the zero-length string,no normalization is performed and $srcval is returned.

Conformingimplementations ·must·support normalization form "NFC" and ·may·support normalization forms "NFD", "NFKC", "NFKD", "W3C" or other normalization forms. If the effective value of the $normalizationForm is other than one of the values supported by the implementation, then an error is raised ("Unsupported normalization form").

7.4.12 fn:upper-case

fn:upper-case($srcval as xs:string?) as xs:string?

If the value of $srcval is the empty sequence, returns the empty sequence.

Otherwise, returnsthe value of $srcval after translating every lower-case letter to its upper-case correspondent. Every lower-case letter that does not have an upper-case correspondent, and every character that is not a lower-case letter, is included in the returned value in its original form.

A "lower-case letter" is a character whose Unicode General Category class includes "Ll". The corresponding upper-case letter is determined using [Unicode Case Mappings].

7.4.12.1 Examples

fn:upper-case("abCd0") returns "ABCD0".

7.4.13 fn:lower-case

fn:lower-case($srcval as xs:string?) as xs:string?

If the value of $srcval is the empty sequence, returns the empty sequence.

Otherwise, returnsthe value of $srcval after translating every upper-case letter to its lower-case correspondent. Every upper-case letter that does not have a lower-case correspondent, and every character that is not an upper-case letter, is included in the returned valuein its original form.

An "upper-case letter" is a character whose Unicode General Category class includes "Lu". The corresponding lower-case letter is determined using [Unicode Case Mappings].

7.4.13.1 Examples

fn:lower-case("ABc!D") returns "abc!d".

7.4.14 fn:translate

`fn:translate`(	`$srcval`	`as` `xs:string?`,
	`$mapString`	`as` `xs:string?`,
	`$transString`	`as` `xs:string?`) `as` `xs:string?`

If the value of $srcval, $mapString or $transString is the empty sequence, returns the empty sequence.

Otherwise,returns the value of $srcval modified so that every character in the value of $srcval that occurs at some position N in the value of $mapString has been replaced by the character that occurs at position N in the value of $transString.

Every character in the value of $srcval that does not appear in the value of $mapString is unchanged.

Every character in the value of $srcval that appears at some position M in the value of $mapString, where the value of $transString is less than M characters in length, is omitted from the returned value.

If the value of $srcval, $mapString or $transString is the empty sequence, returns the empty sequence.

Note:

This function operates on XML characters in the string (or equivalently, Unicode code points).Some implementations may represent a code pointabove xFFFF using two 16-bit values known as a surrogate pair. A surrogate pair counts as one character, not two.

7.4.14.1 Examples

fn:translate("bar","abc","ABC") returns "BAr"
- fn:translate("--aaa--","abc-","ABC") returns "AAA".
- fn:translate("abcdabc", "abc", "AB") returns "ABdAB".

7.4.15 fn:string-pad

fn:string-pad($padString as xs:string?, $padCount as xs:integer) as xs:string?

If the value of $padString is the empty sequence, returns theempty sequence.

Otherwise, returns an xs:string consisting of $padCount copies of $padString concatenated together withoutany separators. Returns the zero-length string if $padCount is zero (0).

If the value of $padCount is less than zero (0), an error is raised ("Invalid string-pad count").

7.4.15.1 Examples

fn:string-pad("XMLQuery", 2) returns "XMLQueryXMLQuery".
fn:string-pad(" ", 4) returns a string containing four spaces.
fn:string-pad(" ", 0) returns the zero-length string.
fn:string-pad(" ", -3) results in an error being raised ("Invalid string-pad count").

7.4.16 fn:escape-uri

fn:escape-uri($uri-part as string, $escape-reserved as xs:boolean) as xs:string

Thisfunction applies the URI escaping rules defined in section 2of [RFC 2396]as amended by [RFC 2732] to the string suppliedas $uri-part, which typically represents all or part ofa URI. The effect of the functionis to replace any special character in the string by an escape sequence of the form%xx%yy..., where xxyy... is thehexadecimal representation of the octets used to represent the character in UTF-8.

The set of characters that are escaped depends on the setting of the boolean argument $escape-reserved.

If$escape-reserved is true, all characters are escaped other than lower case letters a-z, upper case lettersA-Z, digits 0-9 and the characters referred to in[RFC 2396] as "marks":specifically, "-" | "_" | "." | "!" | "~" | "*" | "'" | "(" | ")". The "%" character itself is escaped onlyif it is not followed by two hexadecimal digits (thatis, 0-9, a-f and A-F).

If $escape-reservedis false,the behavior differs in that characters referred to in [RFC 2396] and [RFC 2732] as reserved characters,together with the '#' character, are not escaped. These characters are ";" | "/" | "?" | ":" | "@" | "&" | "=" | "+" | "$" | "," | "#","[", "]".

[RFC 2396]does not definewhether escapedURIs should use lower case or upper case for hexadecimal digits. To ensure that escaped URIs can be compared using string comparison functions, this function must always generate hexadecimal values usingthe upper-case letters A-F.

Generally, $escape-reserved should be set to true when escaping astring that is to form a single part of a URI, and to false when escaping an entire URI or URIreference.

7.4.16.1 Examples

fn:escape-uri("gopher://spinaltap.micro.umn.edu/00/Weather/CA/Los%20Angeles#ocean", true())returns "gopher%3A%2F%2Fspinaltap.micro.umn.edu%2F00%2FWeather%2FCA%2FLos%20Angeles%23ocean"
fn:escape-uri("gopher://spinaltap.micro.umn.edu/00/Weather/CA/Los%20Angeles#ocean", false())returns "gopher://spinaltap.micro.umn.edu/00/Weather/CA/Los%20Angeles#ocean"

7.5 StringFunctions that Use Pattern Matching

The three functions described in this section make useof a regular expression syntax for pattern matching. This is described below.

Function	Meaning
`fn:matches`	ReturnsAn an `xs:boolean` value that indicates whether the value of the first argumenterror is matched by the regular expression thatif is the value of the second argument.
`fn:replace`	Returns the value of the$flags first argument with every substringto matched by the regular expression that is the value. of the second argument replaced by the replacement string that is the value of the third argument.
`fn:tokenize`	Returns a sequence of zero or more `xs:string`s whose values are substrings of the value of the first argument separated by substrings that match the regular expression that is the value of the second argument.

7.5.1 Regular Expression Syntax

The regular expression syntax used by these functions is defined in terms of the regular expression syntax specified in XML Schema (see [XML Schema Part 2: Datatypes]), which in turn is based on the established conventions of languages such as Perl. However, because XML Schema uses regular expressions only for validity checking, it omitssome facilities that are widely-used with languages such as Perl. Thissection, therefore, describes extensions to the XML Schema regular expressions syntax that reinstate these capabilities.

The regular expression syntax and semantics for these functions are identical to those defined in [XML Schema Part 2: Datatypes] with the following additions:

Two modes are defined, string mode and multiline mode.
Two meta-characters, ^ and $ are added. In string mode, the metacharacter ^ matches the start of the entire string, while $ matches the end of the entire string. In multiline mode, ^ matches the start of any line (that is, the start of the entire string, and the position immediately after a newline character), while $ matches the end of any line (that is, the end of the entire string, and the position immediately before a newline character). Newline here means the character #x0A only.

This means that the production in [XML Schema Part 2: Datatypes]:

[10] Char ::= [^.\?*+()|#x5B#x5D]

is modified to read:

[10] Char ::= [^.\?*+()|^$#x5B#x5D]

The characters #x5B and #x5D correspond to "[" and "]" respectively.
In string mode, the metacharacter . matches any character whatsoever. In multiline mode, the metacharacter . matches any character except a newline (#x0A) character.
Reluctant quantifiers are supported. Specifically:
- X?? matches X, once or not at all
- X*? matches X, zero or more times
- X+? matches X, one or more times
- X{n}? matches X, exactly n times
- X(n,}? matches X, at least n times
- X{n,m}? matches X, at least n times, but not more than m times
The effect of these quantifiers is that the regular expression matches the shortest possible substring consistent with the match as a whole succeeding. In the absence of these quantifiers, the regular expression matches the longest possible substring.

To achieve this, the production in [XML Schema Part 2: Datatypes]:

[4] quantifier ::= [?*+] | ( '{' quantity '}' )

is changed to:

[4] quantifier ::= ( [?*+] | ( '{' quantity '}' ) ) '?'?
Sub-expressions (groups) within the regular expression are recognized. The regular expression syntax defined by [XML Schema Part 2: Datatypes]allows a regular expression to contain parenthesized sub-expressions, but attaches no special significance to them. The fn:replace()function described below allows access to the parts of the input string that matched a sub-expression (called captured substrings). The sub-expressions are numbered according to the position of the opening parenthesis in left-to-right order within the top-level regular expression: the first opening parenthesis identifies captured substring1, the second identifies captured substring2, and so on. If a sub-expression matches more than one substring (because it is within a construct that allows repetition), then only the last substring that it matched will be captured.

Note:

Reluctant quantifiers have no effect on the results of the boolean fn:matches function, since this function is only interested in discovering whether a match exists, and not where it exists.

7.5.1.1 Flags

All these functions provide an optional parameter, $flags, to set options for the interpretation of the regular expression. The parameter is a string, in which individual letters are used to set options. The presence of a letter within the string indicates that the option is on; its absence indicates that the option is off. Letters may appear in any order and may be repeated. If there are letters present that are not defined here, then an error is raised ("Invalid regular expression flags").

The following options are defined:

m: If present, the match operates in multiline mode. Otherwise, the match operates in string mode.
i: If present, the match operates in case-insensitive mode. Otherwise, the match operates in case-sensitive mode. In case-sensitive mode, a character in the input string matches a character specified by the pattern only if the Unicode code-points match. In case-insensitive mode, a character in the input string matches a character specified by the pattern if there is a canonical caseless match between the two characters as defined in section 2.5of [Unicode Case Mappings].

7.5.2 fn:matches

fn:matches($input as xs:string?, $pattern as xs:string) as xs:boolean?

`fn:matches`(	`$input`	`as` `xs:string?`,
	`$pattern`	`as` `xs:string`,
	`$flags`	`as` `xs:string`) `as` `xs:boolean?`

The effect of calling the first version of this function (omitting the argument $flags) is the same as the effect of calling the second version with the $flags argument set to a zero-length string.

If $input is the empty sequence, the result is the empty sequence.

The function returns true if $input matches the regular expression supplied as $pattern; otherwise, it returns false.

Unless the metacharacters ^ and $ are used as anchors, the string is considered to match the pattern if any substring matches the pattern. But if anchors are used, the anchors must match the start/end of the string (in string mode), or the start/end of a line (in multiline mode).

Note:

This is different from the behavior of patterns in [XML Schema Part 2: Datatypes], where regular expressions are implicitly anchored.

An error is raised ("Invalid regular expression") if the value of $pattern is invalid according to the rules described in section 7.5.1 Regular Expression Syntax.

An error is raised ("Invalid regular expression flags") if the value of $flags is invalid according to the rules described in section 7.5.1 Regular Expression Syntax.

7.5.2.1 Examples

fn:matches("abracadabra", "bra") returns true
fn:matches("abracadabra", "^a.*a$") returns true
fn:matches("abracadabra", "^bra") returns false

Given the source document:

<poem author="Wilhelm Busch"> 
Kaum hat dies der Hahn gesehen,
Fängt er auch schon an zu krähen:
«Kikeriki! Kikikerikih!!»
Tak, tak, tak! - da kommen sie.
</poem>

the following function calls produce the following results, with the poem element as the context node:

fn:matches(., "Kaum.*krähen") returns true
fn:matches(., "Kaum.*krähen", "m") returns false
fn:matches(., "^Kaum.*gesehen,$", "m") returns true
fn:matches(., "^Kaum.*gesehen,$") returns false
fn:matches(., "kiki", "i") returns true

Note:

Regular expression matching is defined on the basis of Unicode code-points; it takes no account of collations.

7.5.3 fn:replace

`fn:replace`(	`$input`	`as` `xs:string?`,
	`$pattern`	`as` `xs:string`,
	`$replacement`	`as` `xs:string`) `as` `xs:string?`

`fn:replace`(	`$input`	`as` `xs:string?`,
	`$pattern`	`as` `xs:string`,
	`$replacement`	`as` `xs:string`,
	`$flags`	`as` `xs:string`) `as` `xs:string?`

The $flags argument is interpreted in the same manner as for the fn:matches() function.

If $input is the empty sequence, the result is the empty sequence.

The function returns the xs:stringthat is obtained by replacing all non-overlapping substrings of $input that match the given $pattern with an occurrence of the $replacement string.

If two overlappingsubstrings of $inputboth match the $pattern,then only the firstone (that is, the one whose first character comes first in the $input string) is replaced.

Within the $replacement string, the variables $1 to $9 may be used to refer to the substring captured by each of the first nine parenthesized sub-expressions in the regular expression. A literal $ symbol must be written as \$. For each match of the pattern, these variables are assigned the value of the content of the relevant captured sub-expression, and the modified replacement string is then substituted for the characters in $input that matched the pattern.

If a variable $n is present in the replacement string, but there is no nth captured substring (which may happen because there were fewer than n parenthesized sub-expressions, or because the nth parenthesized sub-expression was not matched) then the variable is replaced by a zero-length string.

If two alternatives within the pattern both match at the same position in the $input, then the match that is chosen is the one matched by the first alternative. For example:

fn:replace("abcd", "(ab)|(a)", "[1=$1][2=$2]") returns "[1=ab][2=]cd"

An error is raised ("Invalid regular expression") if the value of $pattern is invalid according to the rules described in section 7.5.1 Regular Expression Syntax.

An error is raised ("Invalid regular expression flags") if the valueof $flags is invalid according to the rules described in section 7.5.1 Regular Expression Syntax.

An error is raised ("Regular expressionmatches zero-length string") if the pattern matches a zero-length string. It is not an error, however, if a captured substring is zero-length.

An error is raised ("Invalid replacement string") if the value of $replacement contains a "$" character that is not immediately followed by a digit 1-9 and not immediately preceded by a "/".

An error is raised ("Invalid replacement string") if the value of $replacement contains a "\" character that is not part of a "\\" pair, unless it is immediately followed by a "$" character.

7.5.3.1 Examples

replace("abracadabra", "bra", "*") returns "a*cada*"
replace("abracadabra", "a.*a", "*") returns "*"
replace("abracadabra", "a.*?a", "*") returns "*c*bra"
replace("abracadabra", "a", "") returns "brcdbr"
replace("abracadabra", "a(.)", "a$1$1") returns "abbraccaddabbra"
replace("abracadabra", ".*?", "$1") raises an error, because the pattern matches the zero-length string

7.5.4 fn:tokenize

fn:tokenize($input as xs:string?, $pattern as xs:string) as xs:string*

`fn:tokenize`(	`$input`	`as` `xs:string?`,
	`$pattern`	`as` `xs:string`,
	`$flags`	`as` `xs:string`) `as` `xs:string*`

This function breaks the $input string into a sequence of strings, treating any substring that matches $pattern as a separator. The separators themselves are not returned.

The $flags argument is interpreted in the same way as for the fn:matches() function.

If $inputis the empty sequence, the result is the empty sequence.

If the supplied$pattern matchesa zero-length string,the fn:tokenize()function breaks the string into its component characters. The nth characterin the $inputstring becomes the nth string in the resultsequence; eachstring in theresultsequence hasa string length of one.

Ifa separator occurs at the start of the $inputstring, the result sequence will start with a zero-lengthstring. Zero-length strings will also occur in the resultsequence ifa separator occurs at the endof the $inputstring, or if two adjacent substrings match the supplied$pattern.

If twoalternatives within the supplied $patternboth match at the sameposition in the $inputstring, then the match that is chosenis thefirst. For example:

fn:tokenize("abracadabra", "(ab)|(a)") returns ("", "r", "c", "d", "r", "")

Anerroris raised("Invalid regular expression") if the valueof $patternis invalid according to the rules described in section 7.5.1 Regular Expression Syntax.

An error is raised ("Invalid regular expression flags") if the value of $flagsis invalid according to the rules described in section 7.5.1 Regular Expression Syntax.

7.5.4.1 Examples

fn:tokenize("Thecat sat on the mat", "\s+")returns ("The","cat", "sat", "on", "the", "mat")
fn:tokenize("1,15, 24, 50", ",\s*")returns ("1","15", "24", "50")
fn:tokenize("1,15,,24,50,",",")returns ("1","15", "", "24", "50", "")
fn:tokenize("abba",".?") returns ("a", "b", "b", "a")
fn:tokenize("Some unparsed <br> HTML <BR> text", "\s*<br>\s*", "i") returns ("Some unparsed", "HTML", "text")

8 Functions and Operators on Booleans

This section discusses operators on the [XML Schema Part 2: Datatypes] boolean datatype.

8.1 Boolean Constructor Functions

The following constructor functions are defined on the boolean type.

fn:true

fn:false

8.1.1 fn:true

fn:true() as xs:boolean

Returns the xs:booleanvalue true.

8.1.1.1 Examples

fn:true() returns true.

8.1.2 fn:false

fn:false() as xs:boolean

Returns the xs:booleanvalue false.

8.1.2.1 Examples

fn:false() returns false.

8.2 Operators on Boolean Values

The following functions are defined on boolean values to back up operators defined in [XQuery 1.0: An XML Query Language] and [XPath 2.0]:

op:boolean-equal

8.2.1 op:boolean-equal

op:boolean-equal($value1 as xs:boolean, $value2 as xs:boolean) as xs:boolean

The arguments and return type are all xs:boolean. The result is true if both arguments are true or if both arguments are false. The result is false if one of the arguments is true and the other argument is false.

This function backs up the "eq" operator on xs:booleanvalues.

8.2.2 op:boolean-less-than

`op:boolean-less-than`(	`$srcval1`	`as` `xs:boolean`,
`op:boolean-less-than`(	`$srcval2`	`as` `xs:boolean`) `as` `xs:boolean`

Returns true if $srcval1 is false and $srcval2 is true. Otherwise, returns false.

This function backs up the "lt" and "ge" operators on xs:booleanvalues.

8.2.3 op:boolean-greater-than

`op:boolean-greater-than`(	`$srcval1`	`as` `xs:boolean`,
`op:boolean-greater-than`(	`$srcval2`	`as` `xs:boolean`) `as` `xs:boolean`

Returns true if $srcval1 is true and $srcval2 is false. Otherwise, returns false.

This function backs up the "gt" and "le" operatorson xs:booleanvalues.

8.3 Functions on Boolean Values

The following functions are defined on boolean values:

8.3.1 fn:not

fn:not($srcval as item*) as xs:boolean

$srcval is first reduced to an effective boolean value by applying the fn:boolean() function.

Returns true if the effective boolean value is false, and false if the effective boolean value is true.

8.3.1.1 Examples

fn:not(fn:true()) returns false.

9 Functions and Operators on Durations, Dates and Times

This section discusses operations on the [XML Schema Part 2: Datatypes] date and time types. In addition, it discusses operations on two subtypes of xs:durationthat are defined in this document. See 9.2 Two Totally Ordered Subtypes of Duration.

The functions described in this section follow the principle of locale-independent storage for these datatypes that originated with [XML Schema Part 2: Datatypes]. Thus, a single calendar (Gregorian) and a single timezone (UTC) is chosen to represent date and time values. Applications and other processing systems are free to present this information in locale-specific representations.

9.1 Duration, Date and Time Types

The operators described in this section are defined on the following duration, date and time types:

xs:dateTime
xs:date
xs:time
xs:gYearMonth
xs:gYear
xs:gMonthDay
xs:gMonth
xs:gDay

In addition, they are defined on the 9.2 Two Totally Ordered Subtypes of Duration:

xdt:yearMonthDuration
xdt:dayTimeDuration

9.1.1 CONFORMANCE NOTE

For a number of the above datatypes [XML Schema Part 2: Datatypes] extends the basic [ISO 8601] lexical representations, such as YYYY-MM-DDThh:mm:ss.s for dateTime, by allowing more than four digits to represent the year field - no maximum is specified - and an unlimited number of digits for fractional seconds.

For this specification, all minimally conforming processors must support year values with a minimum of 4 digits (i.e., YYYY) and a minimum fractional second precision of 1 millisecond or three digits (i.e., s.sss). However, conforming processors may set larger ·implementation defined·limits on the maximum number of digits they support in these two situations, in which case thelimits ·must·be clearly documented.

A processor that limits the number of digits in date and time datatype representations may encounter overflow and underflow conditions when it tries to execute the functions in 9.7 Adding and Subtracting Durations From dateTime, date and time. In these situations, the processor ·must· return zero in case of underflow and ·must· raise an error ("overflow in date/time arithmetic") in case of overflow.

The value spaces of the two totally ordered subtypes of xs:duration described in 9.2 Two Totally Ordered Subtypes of Duration are xs:integer months for xdt:yearMonthDuration and xs:decimal seconds for xdt:dayTimeDuration. If a processor limits the number of digits allowed in the representation of xs:integer and xs:decimal then overflow and underflow situations can arise when it tries to execute the functions in 9.5 Arithmetic Functions on xdt:yearMonthDuration and xdt:dayTimeDuration. In these situations the processor ·must· return zero in case of underflow and ·must· raise an error ("overflow in duration arithmetic") in case of overflow.

9.2 Two Totally Ordered Subtypes of Duration

Twototally ordered subtypes of xs:durationare defined in this specification using the mechanisms described in [XML Schema Part 2: Datatypes] for defining user-defined types. They are available in the namespace http://www.w3.org/2003/05/xquery-datatypes.

Note:

The W3C XML Query Working Group has requested the W3C XML Schema Working Group that these two subtypes of xs:durationbe included in the built-in datatypes described in [XML Schema Part 2: Datatypes]. If the W3C XML Schema Working Group agrees to this request, these two datatypes will be removed from the above name space and moved into the XML Schema namespace http://www.w3.org/2001/XMLSchema.

9.2.1 xdt:yearMonthDuration

[Definition] xdt:yearMonthDurationis derived from xs:durationby restricting its lexical representation to contain only the year and month components. The value space of xdt:yearMonthDurationis the set of xs:integermonth values. The year and month components of xdt:yearMonthDurationcorrespond to the Gregorian year and month components defined in section 5.5.3.2 of [ISO 8601], respectively.

xdt:yearMonthDurationis derived from xs:durationas follows. In this [XML Schema Part 1: Structures] fragment, the value of attributeFormDefault is unqualified.

<xs:simpleType name='xdt:yearMonthDuration'>
    <xs:restriction base='xs:duration'>
        <xs:pattern value="[\-]?P[0-9]+(Y([0-9]+M)?|M)"/>
    </xs:restriction>
</xs:simpleType>

9.2.1.1 Lexical representation

The lexical representation for xdt:yearMonthDurationis the [ISO 8601] reduced format PnYnM, where nY represents the number of years and nM the number of months. The values of the years and months components are not restricted but allow an arbitrary unsigned xs:integer.

An optional preceding minus sign ('-') is allowed to indicate a negative duration. If the sign is omitted a positive duration is indicated. To indicate a xdt:yearMonthDurationof 1 year, 2 months, one would write: P1Y2M. One could also indicate a xdt:yearMonthDurationof minus 13 months as: -P13M.

Reduced precision and truncated representations of this format are allowed provided they conform to the following:

If the number of years or months in any expression equals zero (0), the number and its corresponding designator ·may·be omitted. However, at least one number and its designator ·must·be present. For example, P1347Y and P1347M are allowed; P-1347M is not allowed, although -P1347M is allowed. P1Y2MT is not allowed. Also, P24YM is not allowed, nor is PY43M since Y must have at least one prededing digit and M must have one preceding digit.

9.2.1.2 Calculating the value from the lexical representation

The value of a xdt:yearMonthDurationlexical form is obtained by multiplying the value of the year component by 12 and adding the value of the month component. The value is positive or negative depending on the preceding sign.

9.2.1.3 Canonical representation

The canonical representation of xdt:yearMonthDurationrestricts the value of the months component to xs:integervalues between 0 and 11, both inclusive. To convert from a non-canonical representation to the canonical representation, the lexical representation is first converted to a value in xs:integermonths as defined above. This value is then divided by 12 to obtain the value of the years component of the canonical representation. The remaining number of months is the value of the months component of the canonical representation. If a component has the value zero (0), then the number and the designator for that component ·must·be omitted. However, ifthe value is zero (0) months, the canonical form is "P0M".

9.2.1.4 Order relation on yearMonthDuration

Let the function that calculates the value of an xdt:yearMonthDurationin the manner described above be called V(d). Then for two xdt:yearMonthDurationvalues x and y, x > y if and only ifV(x) > V(y). The order relation on yearMonthDuration is a total order.

9.2.2 xdt:dayTimeDuration

[Definition] xdt:dayTimeDurationis derived from xs:durationby restricting its lexical representation to contain only the day, hour, minute and second components. The value space of xdt:dayTimeDurationis the set of fractional second values. The components of xdt:dayTimeDurationcorrespond to the day, hour, minute and second components defined in Section 5.5.3.2 of [ISO 8601], respectively. xdt:dayTimeDurationis derived from xs:durationas follows. In this [XML Schema Part 1: Structures] fragment the value of attributeFormDefault is unqualified.

<xs:simpleType name='xdt:dayTimeDuration'>
    <xs:restriction base='xs:duration'>
         <xs:pattern value="[\-]?P([0-9]+D(T([0-9]+(H([0-9]+(M([0-9]+(\.[0-9]*)?S
            |\.[0-9]+S)?|(\.[0-9]*)?S)|(\.[0-9]*)?S)?|M([0-9]+
            (\.[0-9]*)?S|\.[0-9]+S)?|(\.[0-9]*)?S)|\.[0-9]+S))?
            |T([0-9]+(H([0-9]+(M([0-9]+(\.[0-9]*)?S|\.[0-9]+S)?
            |(\.[0-9]*)?S)|(\.[0-9]*)?S)?|M([0-9]+(\.[0-9]*)?S|\.[0-9]+S)?
            |(\.[0-9]*)?S)|\.[0-9]+S))"/>
    </xs:restriction>
</xs:simpleType>

9.2.2.1 Lexical representation

The lexical representation for xdt:dayTimeDurationis the [ISO 8601] truncated format PnDTnHnMnS, where nD represents the number of days, T is the date/time separator, nH the number of hours, nM the number of minutes and nS the number of seconds.

The values of the days, hours and minutes components are not restricted, but allow an arbitrary unsigned xs:integer.Similarly, the value of the seconds component allows an arbitrary unsigned xs:decimal.An optional minus sign ('-') is allowed to precede the 'P', indicating a negative duration. If the sign is omitted, the duration is positive. See also [ISO 8601] Date and Time Formats.

For example, to indicate a duration of 3 days, 10 hours and 30 minutes, one would write: P3DT10H30M. One could also indicate a duration of minus 120 days as: -P120D. Reduced precision and truncated representations of this format are allowed, provided they conform to the following:

If the number of days, hours, minutes, or seconds in any expression equals zero (0), the number and its corresponding designator ·may·be omitted. However, at least one number and its designator ·must·be present.
The seconds part ·may·have a decimal fraction.
The designator 'T' ·must·be absent if and only if all of the time items are absent. The designator 'P' ·must·always be present.

For example, P13D, PT47H, P3DT2H, -P35.89S and P4D251M are all allowed. P-134D is not allowed (invalid location of minus sign), although -P134D is allowed.

9.2.2.2 Calculating the value of a dayTimeDuration from the lexical representation

The value of a xdt:dayTimeDurationlexical form in fractional seconds is obtained by converting the day, hour minutes and seconds value to fractional seconds using the conversion rules: 24 hours = 1 day, 60 minutes = 1 hour and 60 seconds = 1 minute.

9.2.2.3 Canonical representation

The canonical representation of xdt:dayTimeDurationrestricts the value of the hours component to xs:integervalues between 0 and 23, both inclusive; the value of the minutes component to xs:integervalues between 0 and 59; both inclusive; and the value of the seconds component to xs:decimalvalued from 0.0 to 60.999... (see [XML Schema Part 2: Datatypes], Appendix D). The value can be greater than 60 seconds to accomodate occasional leap seconds used to keep human time synchronized with the rotation of the planet.

To convert from a non-canonical representation to the canonical representation, the value of the lexical form in fractional seconds is first calculated in the manner described above. The value of the days component in the canonical form is then calculated by dividing the value by 86,400 (24*60*60).The remainder is in fractional seconds. The value of the hours component in the canonical form is calculated by dividing this remainder by 3,600 (60*60). The remainder is again in fractional seconds. The value of the minutes component in the canonical form is calculated by dividing this remainder by 60. The remainder in fractional seconds is the value of the seconds component in the canonical form. If a component has the value zero (0) then the number and the designator for that component must be omitted. However, ifall the components of the lexical form are zero (0), the canonical form is PT0S.

9.2.2.4 Order relation on dayTimeDuration

Let the function that calculates the value of a xdt:dayTimeDurationin the manner described above be called V(d). Then for two xdt:dayTimeDurationvalues x and y, x > y if and only if V(x) > V(y). The order relation on xdt:dayTimeDurationis a total order.

9.3 Comparisons of Duration, Date and Time Values

Operator	Meaning
`op:yearMonthDuration-equal`
`op:yearMonthDuration-less-than`
`op:yearMonthDuration-greater-than`
`op:dayTimeDuration-equal`
`op:dayTimeDuration-less-than`
`op:dayTimeDuration-greater-than`
`op:dateTime-equal`
`op:dateTime-less-than`
`op:dateTime-greater-than`
`op:date-equal`
`op:date-less-than`
`op:date-greater-than`
`op:time-equal`
`op:time-less-than`
`op:time-greater-than`
`op:gYearMonth-equal`
`op:gYear-equal`
`op:gMonthDay-equal`
`op:gMonth-equal`
`op:gDay-equal`

The following comparison operators are defined on the [XML Schema Part 2: Datatypes] date, time and duration datatypes. Each operator takes two operands of the same type and returns a boolean result. As discussed in [XML Schema Part 2: Datatypes], the order relation on xs:durationand the date and time datatypes is not a total order but, rather, a partial order. For this reason, nofunctions are defined on xs:duration.A full complement of comparison and arithmetic functions are defined on the two subtypes of duration described in 9.2 Two Totally Ordered Subtypes of Duration.

If either operand to a comparison function on date or time values does not have an explicit timezone then, for the purpose of the operation, an implicit timezone, provided by the evaluation context, is assumed to be present as part of the value. This creates a total order for all date and time values. The order relations on date and time datatypes is defined in [XML Schema Part 2: Datatypes].

Note that for xs:dateTime,xs:date and xs:time,as discussed in 1.4 xs:dateTime, xs:date and xs:time valuesthe valueis defined as a tuple. Comparison operators on thesethree datatypes operate on the first, or normalized value,part of thetuple and disregard the second, or timezone, part of the tuple. Ifthetimezonepart is (), the implicit timezone is used to adjust the normalized value as necessary.

9.3.1 op:yearMonthDuration-equal

`op:yearMonthDuration-equal`(	`$operand1`	`as` `xdt:yearMonthDuration`,
`op:yearMonthDuration-equal`(	`$operand2`	`as` `xdt:yearMonthDuration`) `as` `xs:boolean`

Returns true if and only if $operand1 is equal to $operand2. Returns false otherwise.

This function backs up the "eq" and "ne" operators on xdt:yearMonthDurationvalues.

9.3.2 op:yearMonthDuration-less-than

`op:yearMonthDuration-less-than`(	`$operand1`	`as` `xdt:yearMonthDuration`,
`op:yearMonthDuration-less-than`(	`$operand2`	`as` `xdt:yearMonthDuration`) `as` `xs:boolean`

Returns true if and only if $operand1 is less than $operand2. Returns false otherwise.

This function backs up the "lt" and "ge" operators on xdt:yearMonthDurationvalues.

9.3.3 op:yearMonthDuration-greater-than

`op:yearMonthDuration-greater-than`(	`$operand1`	`as` `xdt:yearMonthDuration`,
`op:yearMonthDuration-greater-than`(	`$operand2`	`as` `xdt:yearMonthDuration`) `as` `xs:boolean`

Returns true if and only if $operand1 is greater than $operand2. Returns false otherwise.

This function backs up the "gt" and "le" operators on xdt:yearMonthDurationvalues.

9.3.4 op:dayTimeDuration-equal

`op:dayTimeDuration-equal`(	`$operand1`	`as` `xdt:dayTimeDuration`,
`op:dayTimeDuration-equal`(	`$operand2`	`as` `xdt:dayTimeDuration`) `as` `xs:boolean`

Returns true if and only if the value of $operand1 is equal to the value of $operand2. Returns false otherwise.

This function backs up the "eq" and "ne" operators on xdt:dayTimeDurationvalues.

9.3.5 op:dayTimeDuration-less-than

`op:dayTimeDuration-less-than`(	`$operand1`	`as` `xdt:dayTimeDuration`,
`op:dayTimeDuration-less-than`(	`$operand2`	`as` `xdt:dayTimeDuration`) `as` `xs:boolean`

Returns true if and only if $operand1 is less than $operand2. Returns false otherwise.

This function backs up the "lt" and "ge" operators on xdt:dayTimeDurationvalues.

9.3.6 op:dayTimeDuration-greater-than

`op:dayTimeDuration-greater-than`(	`$operand1`	`as` `xdt:dayTimeDuration`,
`op:dayTimeDuration-greater-than`(	`$operand2`	`as` `xdt:dayTimeDuration`) `as` `xs:boolean`

Returns true if and only if $operand1 is greater than $operand2. Returns false otherwise.

This function backs up the "gt" and "le" operators on xdt:dayTimeDurationvalues.

9.3.7 op:dateTime-equal

`op:dateTime-equal`(	`$operand1`	`as` `xs:dateTime`,
`op:dateTime-equal`(	`$operand2`	`as` `xs:dateTime`) `as` `xs:boolean`

Returns true if and only if thenormalized value of $operand1is equal to the normalizedvalue of $operand2.Returns falseotherwise.

This function backs up the "eq" and "ne" operators on xs:dateTimevalues.

9.3.7.1 Examples

Assume that the evaluation context provides an implicit timezone value of -5:00.

op:dateTime-equal(xs:dateTime("2002-04-02T12:00:00-01:00"), xs:dateTime("2002-04-02T17:00:00+04:00")) returns true.
- op:dateTime-equal(xs:dateTime("2002-04-02T12:00:00"),xs:dateTime("2002-04-02T23:00:00+06:00")) returns true.
op:dateTime-equal(xs:dateTime("2002-04-02T12:00:00"), xs:dateTime("2002-04-02T17:00:00")) returns false.
op:dateTime-equal(xs:dateTime("2002-04-02T12:00:00"), xs:dateTime("2002-04-02T12:00:00")) returns true.

9.3.8 op:dateTime-less-than

`op:dateTime-less-than`(	`$operand1`	`as` `xs:dateTime`,
`op:dateTime-less-than`(	`$operand2`	`as` `xs:dateTime`) `as` `xs:boolean`

Returns true if and only if thenormalized value of $operand1is lessthan the normalizedvalue of $operand2.Returns falseotherwise.

This function backs up the "lt" and "ge" operators ond xs:dateTimevalues.

9.3.9 op:dateTime-greater-than

`op:dateTime-greater-than`(	`$operand1`	`as` `xs:dateTime`,
`op:dateTime-greater-than`(	`$operand2`	`as` `xs:dateTime`) `as` `xs:boolean`

Returns true if and only if thenormalized value of $operand1is greaterthan the normalizedvalue of $operand2.Returns falseotherwise.

This function backs up the "gt" and "le" operators on xs:dateTimevalues.

9.3.10 op:date-equal

op:date-equal($operand1 as xs:date, $operand2 as xs:date) as xs:boolean

Returns true if and only if thenormalized value of $operand1is equal to the normalizedvalue of $operand2.Returns falseotherwise.

This function backs up the "eq" and "ne" operators on xs:datevalues.

9.3.11 op:date-less-than

op:date-less-than($operand1 as xs:date, $operand2 as xs:date) as xs:boolean

Returns true if and only if thenormalized value of $operand1is lessthan the normalizedvalue of $operand2.Returns falseotherwise.

This function backs up the "lt" and "ge" operators on xs:datevalues.

9.3.12 op:date-greater-than

op:date-greater-than($operand1 as xs:date, $operand2 as xs:date) as xs:boolean

Returns true if and only if thenormalized value of $operand1is greaterthan the normalizedvalue of $operand2.Returns falseotherwise.

This function backs up the "gt" and "le" operators on xs:datevalues.

9.3.13 op:time-equal

op:time-equal($operand1 as xs:time, $operand2 as xs:time) as xs:boolean

Returns true if and only if thenormalized value of $operand1is equal to the normalizedvalue of $operand2.Returns falseotherwise.

This function backs up the "eq" and "ne" operators on xs:timevalues.

9.3.14 op:time-less-than

op:time-less-than($operand1 as xs:time, $operand2 as xs:time) as xs:boolean

Returns true if and only if the normalized value of $operand1 is less than the normalized value of $operand2. Returns false otherwise.

This function backs up the "lt" and "ge" operators on xs:timevalues.

9.3.14.1 Examples

Assumethat the evaluation context provides an implicit timezone value of -5:00.

op:time-less-than(xs:time("12:00:00"),xs:time("23:00:00+06:00"))returns false.
op:time-less-than(xs:time("11:00:00"),xs:time("17:00:00"))returns true.
op:time-less-than(xs:time("23:00:00"),xs:time("01:00:00-01:00"))returns truesince it compares the normalizedvalues 28:00:00Z(23:00:00adjusted with the implicit timezone -05:00)and 02:00:00Z.

9.3.15 op:time-greater-than

op:time-greater-than($operand1 as xs:time, $operand2 as xs:time) as xs:boolean

Returns true if and only if thenormalized value of $operand1is greaterthan the normalizedvalue of $operand2.Returns falseotherwise.

This function backs up the "gt" and "le" operators on xs:timevalues.

9.3.16 op:gYearMonth-equal

`op:gYearMonth-equal`(	`$operand1`	`as` `xs:gYearMonth`,
`op:gYearMonth-equal`(	`$operand2`	`as` `xs:gYearMonth`) `as` `xs:boolean`

Returns true if and only if the value of $operand1 is equal to the value of $operand2. Returns false otherwise.

This function backs up the "eq" and "ne" operators on xs:gYearMonthvalues.

9.3.17 op:gYear-equal

op:gYear-equal($operand1 as xs:gYear, $operand2 as xs:gYear) as xs:boolean

Returns true if and only if the value of $operand1 is equal to the value of $operand2. Returns false otherwise.

This function backs up the "eq" and "ne" operators on xs:gYearvalues.

9.3.18 op:gMonthDay-equal

`op:gMonthDay-equal`(	`$operand1`	`as` `xs:gMonthDay`,
`op:gMonthDay-equal`(	`$operand2`	`as` `xs:gMonthDay`) `as` `xs:boolean`

Returns true if and only if the value of $operand1 is equal to the value of $operand2. Returns false otherwise.

This function backs up the "eq" and "ne" operators on xs:gMonthDayvalues.

9.3.19 op:gMonth-equal

op:gMonth-equal($operand1 as xs:gMonth, $operand2 as xs:gMonth) as xs:boolean

Returns true if and only if the value of $operand1 is equal to the value of $operand2. Returns false otherwise.

This function backs up the "eq" and "ne" operators on xs:gMonthvalues.

9.3.20 op:gDay-equal

op:gDay-equal($operand1 as xs:gDay, $operand2 as xs:gDay) as xs:boolean

Returns true if and only if the value of $operand1 is equal to the value of $operand2. Returns false otherwise.

This function backs up the "eq" and "ne" operators on xs:gDayvalues.

9.4 Component Extraction Functions on Duration, Date and Time Values

The duration, date and time datatypes may be considered to be composite datatypes in that they contain distinct components. The extraction functions specified below extract a single component from a duration, date or time value.

Function	Meaning
`fn:get-years-from-yearMonthDuration`
`fn:get-months-from-yearMonthDuration`
`fn:get-days-from-dayTimeDuration`
`fn:get-hours-from-dayTimeDuration`
`fn:get-minutes-from-dayTimeDuration`
`fn:get-seconds-from-dayTimeDuration`
`fn:get-year-from-dateTime`
`fn:get-month-from-dateTime`
`fn:get-day-from-dateTime`
`fn:get-hours-from-dateTime`
`fn:get-minutes-from-dateTime`
`fn:get-seconds-from-dateTime`
`fn:get-timezone-from-dateTime`
`fn:get-year-from-date`
`fn:get-month-from-date`
`fn:get-day-from-date`
`fn:get-timezone-from-date`
`fn:get-hours-from-time`
`fn:get-minutes-from-time`
`fn:get-seconds-from-time`
`fn:get-timezone-from-time`

9.4.1 fn:get-years-from-yearMonthDuration

fn:get-years-from-yearMonthDuration( $srcval as xdt:yearMonthDuration?) as xs:integer?

Returns an xs:integerrepresenting the years component in the canonical lexical representation of the value of $srcval. The result may be negative. If $srcval is the empty sequence, returns the empty sequence.

9.4.1.1 Examples

fn:get-years-from-yearMonthDuration(xdt:yearMonthDuration("P20Y15M")) returns 21.
- fn:get-years-from-yearMonthDuration(xdt:yearMonthDuration("-P15M")) returns -1.

9.4.2 fn:get-months-from-yearMonthDuration

fn:get-months-from-yearMonthDuration( $srcval as xdt:yearMonthDuration?) as xs:integer?

Returns an xs:integerrepresenting the months component in the canonical lexical representation of the value of $srcval. The result may be negative. If $srcval is the empty sequence, returns the empty sequence.

9.4.2.1 Examples

fn:get-months-from-yearMonthDuration(xdt:yearMonthDuration("P20Y15M")) returns 3.
- fn:get-months-from-yearMonthDuration(xdt:yearMonthDuration("-P20Y18M")) returns -6.

9.4.3 fn:get-days-from-dayTimeDuration

fn:get-days-from-dayTimeDuration( $srcval as xdt:dayTimeDuration?) as xs:integer?

Returns an xs:integerrepresenting the days component in the canonical lexical representation of the value of $srcval. The result may be negative. If $srcval is the empty sequence, returns the empty sequence.

9.4.3.1 Examples

fn:get-days-from-dayTimeDuration(xdt:dayTimeDuration("P3DT10H")) returns 3.
- fn:get-days-from-dayTimeDuration(xdt:dayTimeDuration("P3DT55H")) returns 5.

9.4.4 fn:get-hours-from-dayTimeDuration

fn:get-hours-from-dayTimeDuration( $srcval as xdt:dayTimeDuration?) as xs:integer?

Returns an xs:integerrepresenting the hours component in the canonical lexical representation of the value of $srcval. The result may be negative. If $srcval is the empty sequence, returns the empty sequence.

9.4.4.1 Examples

fn:get-hours-from-dayTimeDuration(xdt:dayTimeDuration("P3DT10H")) returns 10.
- fn:get-hours-from-dayTimeDuration(xdt:dayTimeDuration("P3DT12H32M12S")) returns 12.
- fn:get-hours-from-dayTimeDuration(xdt:dayTimeDuration("PT123H")) returns 3.
- fn:get-hours-from-dayTimeDuration(xdt:dayTimeDuration("-P3DT10H")) returns -10.

9.4.5 fn:get-minutes-from-dayTimeDuration

fn:get-minutes-from-dayTimeDuration( $srcval as xdt:dayTimeDuration?) as xs:integer?

Returns an xs:integerrepresenting the minutes component in the canonical lexical representation of the value of $srcval. The result may be negative. If $srcval is the empty sequence, returns the empty sequence.

9.4.5.1 Examples

fn:get-minutes-from-dayTimeDuration(xdt:dayTimeDuration("P3DT10H")) returns 0.
- fn:get-minutes-from-dayTimeDuration(xdt:dayTimeDuration("-P5DT12H30M")) returns -30.

9.4.6 fn:get-seconds-from-dayTimeDuration

fn:get-seconds-from-dayTimeDuration( $srcval as xdt:dayTimeDuration?) as xs:decimal?

Returns anxs:decimalrepresenting the seconds component in the canonical lexical representation of the value of $srcval. The result may be negative. If $srcval is the empty sequence, returns the empty sequence.

9.4.6.1 Examples

fn:get-seconds-from-dayTimeDuration(xdt:dayTimeDuration("P3DT10H12.5S")) returns 12.5.
- fn:get-seconds-from-dayTimeDuration(xdt:dayTimeDuration("-P256S")) returns -16.0.

9.4.7 fn:get-year-from-dateTime

fn:get-year-from-dateTime($srcval as xs:dateTime?) as xs:integer?

Returns an xs:integerrepresenting the year component in the normalized value of $srcval. The result may be negative. If $srcval is the empty sequence, returns the empty sequence.

9.4.7.1 Examples

Assume that the evaluation context provides an implicit timezone value of -05:00.

fn:get-year-from-dateTime(xs:dateTime("1999-05-31T13:20:00-05:00")) returns 1999.
- fn:get-year-from-dateTime(xs:dateTime("1999-05-31T21:30:00-05:00")) returns 1999.
- fn:get-year-from-dateTime(xs:dateTime("1999-12-31T19:20:00-05:00")) returns 2000.

9.4.8 fn:get-month-from-dateTime

fn:get-month-from-dateTime($srcval as xs:dateTime?) as xs:integer?

Returns an xs:integerbetween 1 and 12, both inclusive, representing the month component in the normalized value of $srcval. If $srcval is the empty sequence, returns the empty sequence.

9.4.8.1 Examples

fn:get-month-from-dateTime(xs:dateTime("1999-05-31T13:20:00-05:00")) returns 5.
- fn:get-month-from-dateTime(xs:dateTime("1999-12-31T19:20:00-05:00")) returns 1.

9.4.9 fn:get-day-from-dateTime

fn:get-day-from-dateTime($srcval as xs:dateTime?) as xs:integer?

Returns an xs:integerbetween 1 and 31, both inclusive, representing the day component in the normalized value of $srcval. If $srcval is the empty sequence, returns the empty sequence.

9.4.9.1 Examples

fn:get-day-from-dateTime(xs:dateTime("1999-05-31T13:20:00-05:00")) returns 31.
- fn:get-day-from-dateTime(xs:dateTime("1999-12-31T20:00:00-05:00")) returns 1.

9.4.10 fn:get-hours-from-dateTime

fn:get-hours-from-dateTime($srcval as xs:dateTime?) as xs:integer?

Returns an xs:integer between 0 and 23,both inclusive, representing the hours componentin the normalized value of $srcval. If $srcval is the empty sequence, returns the empty sequence.

9.4.10.1 Examples

Assume that the evaluation context provides an implicit timezone value of -05:00.

fn:get-hours-from-dateTime(xs:dateTime("1999-05-31T08:20:00-05:00")) returns 13.
- fn:get-hours-from-dateTime(xs:dateTime("1999-12-31T21:20:00-05:00")) returns 2.
- fn:get-hours-from-dateTime(xs:dateTime("1999-12-31T12:00:00")) returns 17.

9.4.11 fn:get-minutes-from-dateTime

fn:get-minutes-from-dateTime($srcval as xs:dateTime?) as xs:integer?

Returns an xs:integervalue between 0 and 59, both inclusive, representing the minute component in the normalized value of $srcval. If $srcval is the empty sequence, returns the empty sequence.

9.4.11.1 Examples

fn:get-minutes-from-dateTime(xs:dateTime("1999-05-31T13:20:00-05:00")) returns 20 .
- fn:get-minutes-from-dateTime(xs:dateTime("1999-05-31T13:30:00+05:30")) returns 0 .

9.4.12 fn:get-seconds-from-dateTime

fn:get-seconds-from-dateTime($srcval as xs:dateTime?) as xs:decimal?

Returns anxs:decimalvalue between0 and 60.999..., bothinclusive representing the seconds and fractional seconds in the normalized value of $srcval.Note that the value can be greater than 60 seconds to accomodate occasional leap seconds used to keep human time synchronized with the rotation of the planet. If $srcval is the empty sequence, returns the empty sequence.

9.4.12.1 Examples

fn:get-seconds-from-dateTime(xs:dateTime("1999-05-31T13:20:00-05:00")) returns 0 .

9.4.13 fn:get-timezone-from-dateTime

fn:get-timezone-from-dateTime($srcval as xs:dateTime?) as xdt:dayTimeDuration?

Returns the timezone component of $srcval. The result is an xdt:dayTimeDurationthat indicates deviation from UTC; its value may range from +14:00 to -14:00 hours, both inclusive. If $srcval is the empty sequence, returns the empty sequence.

9.4.13.1 Examples

fn:get-timezone-from-dateTime(xs:dateTime("1999-05-31T13:20:00-05:00")) returns the xdt:dayTimeDuration whose value is -PT5H.
fn:get-timezone-from-dateTime(xs:dateTime("2000-06-12T13:20:00Z")) returns the xdt:dayTimeDuration whose value is -PT0H.

9.4.14 fn:get-year-from-date

fn:get-year-from-date($srcval as xs:date?) as xs:integer?

Returns an xs:integerrepresenting the year in the normalized value of $srcval. The value may be negative. If $srcval is the empty sequence, returns the empty sequence.

9.4.14.1 Examples

Assume that the evaluation context provides an implicit timezone value of -05:00.

fn:get-year-from-date(xs:date("1999-05-31")) returns 1999.
- fn:get-year-from-date(xs:date("2000-01-01+05:00")) returns 1999.

9.4.15 fn:get-month-from-date

fn:get-month-from-date($srcval as xs:date?) as xs:integer?

Returns an xs:integerbetween 1 and 12, both inclusive, representing the month component in the normalized value of $srcval. If $srcval is the empty sequence, returns the empty sequence.

9.4.15.1 Examples

fn:get-month-from-date(xs:date("1999-05-31-05:00")) returns 5 .
- fn:get-month-from-date(xs:date("2000-01-01+05:00")) returns 12 .

9.4.16 fn:get-day-from-date

fn:get-day-from-date($srcval as xs:date?) as xs:integer?

Returns an xs:integerbetween 1 and 31, both inclusive, representing the day component in the normalized value of $srcval. If $srcval is the empty sequence, returns the empty sequence.

9.4.16.1 Examples

fn:get-day-from-date(xs:date("1999-05-31-05:00")) returns 31.
- fn:get-day-from-date(xs:date("2000-01-01+05:00")) returns 31.

9.4.17 fn:get-timezone-from-date

fn:get-timezone-from-date($srcval as xs:date?) as xdt:dayTimeDuration?

Returns the timezone component inthe normalized value of $srcval. The result is an xdt:dayTimeDurationthat indicates deviation from UTC; its value may range from +14:00 to -14:00 hours, both inclusive. If $srcval is the empty sequence, returns the empty sequence.

9.4.17.1 Examples

fn:get-timezone-from-date(xs:date("1999-05-31-05:00")) returns the xdt:dayTimeDuration whose value is -PT5H.
fn:get-timezone-from-date(xs:date("2000-06-12Z")) returns the xdt:dayTimeDurationwith value PT0H.

9.4.18 fn:get-hours-from-time

fn:get-hours-from-time($srcval as xs:time?) as xs:integer?

Returns an xs:integerbetween 0 and 23, both inclusive, representingthe value of thehours componentin the normalized valueof $srcval. If $srcval is the empty sequence, returns the empty sequence.

9.4.18.1 Examples

Assume that the evaluation context provides an implicit timezone value of -05:00.

fn:get-hours-from-time(xs:time("11:23:00")) returns 16.
- fn:get-hours-from-time(xs:time("21:23:00")) returns 2.
- fn:get-hours-from-time(xs:time("01:23:00+05:00")) returns 20.

9.4.19 fn:get-minutes-from-time

fn:get-minutes-from-time($srcval as xs:time?) as xs:integer?

Returns an xs:integervalue between 0 to 59, both inclusive, representingthe value of theminutes component in the normalized value of $srcval.If $srcval is the empty sequence, returns the empty sequence.

9.4.19.1 Examples

fn:get-minutes-from-time(xs:time("13:00:00Z")) returns 0 .

9.4.20 fn:get-seconds-from-time

fn:get-seconds-from-time($srcval as xs:time?) as xs:decimal?

Returns an xs:decimalvalue between 0 and 60.999..., both inclusive, representing the seconds and fractional seconds in the normalized value of $srcval. Note that the value can be greater than 60 seconds to accomodate occassional leap seconds used to keep human time synchronized with the rotation of the planet. If $srcval is the empty sequence, returns the empty sequence.

9.4.20.1 Examples

fn:get-seconds-from-time(xs:time("13:20:10.5")) returns 10.5 .

9.4.21 fn:get-timezone-from-time

fn:get-timezone-from-time($srcval as xs:time?) as xdt:dayTimeDuration?

Returns an xdt:dayTimeDurationrepresenting the timezone component of $srcval. The result is a xdt:dayTimeDurationthat indicates deviation from UTC; its value may range from +14:00 to -14:00 hours, both inclusive. If $srcval is the empty sequence, returns the empty sequence.

9.4.21.1 Examples

fn:get-timezone-from-time(xs:time("13:20:00-05:00")) returns xdt:dayTimeDuration whose value is -PT5H.
fn:get-timezone-from-time(xs:time("13:20:00")) returns the xdt:dayTimeDurationwhose value is-PT5H.

9.5 Arithmetic Functions on xdt:yearMonthDuration and xdt:dayTimeDuration

Function	Meaning
`op:add-yearMonthDurations`
`op:subtract-yearMonthDurations`
`op:multiply-yearMonthDuration`
`op:divide-yearMonthDuration`
`op:add-dayTimeDurations`
`op:subtract-dayTimeDurations`
`op:multiply-dayTimeDuration`
`op:divide-dayTimeDuration`

9.5.1 op:add-yearMonthDurations

`op:add-yearMonthDurations`(	`$srcval1`	`as` `xdt:yearMonthDuration`,
`op:add-yearMonthDurations`(	`$srcval2`	`as` `xdt:yearMonthDuration`) `as` `xdt:yearMonthDuration`

Returns the result of adding the value of $srcval1 to the value of $srcval2. Backs up the "+" operator on xdt:yearMonthDurationvalues.

9.5.1.1 Examples

op:add-yearMonthDurations(xdt:yearMonthDuration("P2Y11M"), xdt:yearMonthDuration("P3Y3M")) returns a xdt:yearMonthDurationvalue corresponding to 6 years and 2 months.

9.5.2 op:subtract-yearMonthDurations

`op:subtract-yearMonthDurations`(	`$srcval1`	`as` `xdt:yearMonthDuration`,
`op:subtract-yearMonthDurations`(	`$srcval2`	`as` `xdt:yearMonthDuration`) `as` `xdt:yearMonthDuration`

Returns the result of subtracting the value of $srcval2 from the value of $srcval2. Backs up the "-" operator on xdt:yearMonthDurationvalues.

9.5.2.1 Examples

op:subtract-yearMonthDurations(xdt:yearMonthDuration("P2Y11M"), xdt:yearMonthDuration("P3Y3M")) returns a xdt:yearMonthDurationvalue corresponding to negative 4 months.

9.5.3 op:multiply-yearMonthDuration

`op:multiply-yearMonthDuration`(	`$srcval1`	`as` `xdt:yearMonthDuration`,
`op:multiply-yearMonthDuration`(	`$srcval2`	`as` `xs:decimal`) `as` `xdt:yearMonthDuration`

Returns the result of multiplying the value of $srcval1 by $srcval2. The result is rounded to the nearest month. For a value v, 0 <= v < 0.5 rounds to 0; 0.5 <= v < 1.0 rounds to 1.

Backs up the "*" operator on xdt:yearMonthDurationvalues.

9.5.3.1 Examples

op:multiply-yearMonthDuration(xdt:yearMonthDuration("P2Y11M"), 2.3) returns a xdt:yearMonthDurationvalue corresponding to 6 years and 9 months.

9.5.4 op:divide-yearMonthDuration

`op:divide-yearMonthDuration`(	`$srcval1`	`as` `xdt:yearMonthDuration`,
`op:divide-yearMonthDuration`(	`$srcval2`	`as` `xs:decimal`) `as` `xdt:yearMonthDuration`

Returns the result of dividing the value of $srcval1 by $srcval2. The result is rounded to the nearest month. For a value v, 0 <= v < 0.5 rounds to 0; 0.5 <= v < 1.0 rounds to 1.

Backs up the "div" operator on xdt:yearMonthDurationvalues.

9.5.4.1 Examples

op:divide-yearMonthDuration(xdt:yearMonthDuration("P2Y11M"), 1.5) returns a xdt:yearMonthDurationvalue corresponding to 1 year and 11 months.

9.5.5 op:add-dayTimeDurations

`op:add-dayTimeDurations`(	`$srcval1`	`as` `xdt:dayTimeDuration`,
`op:add-dayTimeDurations`(	`$srcval2`	`as` `xdt:dayTimeDuration`) `as` `xdt:dayTimeDuration`

Returns the result of adding the value of $srcval1 to the value of $srcval2. Backs up the "+" operator on xdt:dayTimeDurationvalues.

9.5.5.1 Examples

op:add-dayTimeDurations(xdt:dayTimeDuration("P2DT12H5M"), xdt:dayTimeDuration("P5DT12H")) returns a xdt:dayTimeDurationvalue corresponding to 8 days and 5 minutes.

9.5.6 op:subtract-dayTimeDurations

`op:subtract-dayTimeDurations`(	`$srcval1`	`as` `xdt:dayTimeDuration`,
`op:subtract-dayTimeDurations`(	`$srcval2`	`as` `xdt:dayTimeDuration`) `as` `xdt:dayTimeDuration`

Returns the result of subtracting the value of $srcval2 from the value of $srcval2. Backs up the "-" operator on xdt:dayTimeDurationvalues.

9.5.6.1 Examples

op:subtract-dayTimeDurations(xdt:dayTimeDuration("P2DT12H"), xdt:dayTimeDuration("P1DT10H30M")) returns a xdt:dayTimeDurationvalue corresponding to 1 day, .5 hourand 30 minutes.

9.5.7 op:multiply-dayTimeDuration

`op:multiply-dayTimeDuration`(	`$srcval1`	`as` `xdt:dayTimeDuration`,
`op:multiply-dayTimeDuration`(	`$srcval2`	`as` `xs:decimal`) `as` `xdt:dayTimeDuration`

Returns the result of multiplying the value of $srcval1 by $srcval2. Backs up the "*" operator on xdt:dayTimeDurationvalues.

9.5.7.1 Examples

op:multiply-dayTimeDuration(xdt:dayTimeDuration("PT2H10M"), 2.1) returns a xdt:dayTimeDurationvalue corresponding to 4 hours and 33 minutes.

9.5.8 op:divide-dayTimeDuration

`op:divide-dayTimeDuration`(	`$srcval1`	`as` `xdt:dayTimeDuration`,
`op:divide-dayTimeDuration`(	`$srcval2`	`as` `xs:decimal`) `as` `xdt:dayTimeDuration`

Returns the result of dividing the value of $srcval1 by $srcval2. Backs up the "div" operator on xdt:dayTimeDurationvalues.

9.5.8.1 Examples

op:divide-dayTimeDuration(xdt:yearMonthDuration("P1DT2H30M10.5S"), 1.5) returns a xdt:dayTimeDurationvalue corresponding to 17 hours, 40 minutes and 7 seconds.

9.6 Timezone Adjustment on dateTime, date and time Values

Function	Meaning
`fn:adjust-dateTime-to-timezone`	Adjusts an `xs:dateTime` dateTime value to a specific timezone, or totimezone. no timezone at all.
`fn:adjust-date-to-timezone`	Adjusts ana dateTime without a `xs:date` timezone. Values value to a specific timezone, or to no timezone at all.
`fn:adjust-time-to-timezone`	Adjusts an `xs:time` date value towith a specifictimezone. fn:add-timezone-to-time Returns timezone, or to no timezone at all.

For purposes of timezone adjustment, an xs:dateis treated as an xs:dateTimewith time 00:00:00.

9.6.1 fn:adjust-dateTime-to-timezone

fn:adjust-dateTime-to-timezone($srcval as xs:dateTime?) as xs:dateTime?

`fn:adjust-dateTime-to-timezone`(	`$srcval`	`as` `xs:dateTime?`,
`fn:adjust-dateTime-to-timezone`(	`$timezone`	`as` `xdt:dayTimeDuration?`) `as` `xs:dateTime?`

Adjusts an xs:dateTimevalue to a specific timezone, or to no timezone at all. If $timezoneis the empty sequence, returns an xs:dateTime withouta timezone. Otherwise, returns an xs:dateTime witha timezone.

If $timezone is not specified, then $timezone is the value of the implicit timezone in the evaluationcontext.

If$srcval is the empty sequence, then the result is the empty sequence.

Adynamic error is raised (invalid timezone value) if $timezoneis less than -PT14H00M or greaterthan PT14H00M.

If $srcval does nothavea timezonecomponentand $timezone is the empty sequence, then the result is $srcval.

If $srcval does not havea timezone component and $timezoneis not the empty sequence, then the result is $srcvalwith $timezone as the timezone component.

If$srcvalhas a timezone component and $timezone isthe empty sequence, then the result is $srcvalwithout its timezone component.

If $srcvalhas a timezone component and$timezoneis not the empty sequence, thenthe result is an xs:dateTime value with a timezone component of $timezonethat is equal to $srcval.

9.6.1.1 Examples

Assume the evaluation context provides an implicit timezone of -5:00 (-PT5H0M).

let $tz := xdt:dayTimeDuration("-PT10H")

fn:adjust-dateTime-to-timezone(xs:dateTime("2002-03-07T10:00:00")) returns 2002-03-07T10:00:00-05:00
fn:adjust-dateTime-to-timezone(xs:dateTime("2002-03-07T10:00:00-07:00")) returns 2002-03-07T12:00:00-05:00
- fn:adjust-dateTime-to-timezone(xs:dateTime("2002-03-07T10:00:00"), $tz) returns 2002-03-07T10:00:00-10:00
fn:adjust-dateTime-to-timezone(xs:dateTime("2002-03-07T10:00:00-07:00"), $tz) returns 2002-03-07T07:00:00-10:00
- fn:adjust-dateTime-to-timezone(xs:dateTime("2002-03-07T10:00:00-07:00"), xdt:dayTimeDuration("PT10H")) returns 2002-03-08T03:00:00+10:00
fn:adjust-dateTime-to-timezone(xs:dateTime("2002-03-07T00:00:00+01:00"), xdt:dayTimeDuration("PT-8H")) returns 2002-03-06T15:00:00-08:00
- fn:adjust-dateTime-to-timezone(xs:dateTime("2002-03-07T10:00:00"), ()) returns 2002-03-07T10:00:00
- fn:adjust-dateTime-to-timezone(xs:dateTime("2002-03-07T10:00:00-07:00"), ()) returns 2002-03-07T10:00:00

9.6.2 fn:adjust-date-to-timezone

fn:adjust-date-to-timezone(

$srcval as xs:date?

) as xs:date?

`fn:adjust-date-to-timezone`(	`$srcval`	`as` `xs:date?`,
`fn:adjust-date-to-timezone`(	`$timezone`	`as` `xdt:dayTimeDuration?`) `as` `xs:date?`

Adjusts an xs:datevalue to a specifictimezone, or to no timezone at all. If $timezoneis the empty sequence, returns an xs:datewithout a timezone. Otherwise, returnsan xs:date with atimezone.

If $timezone is not specified, then $timezone is the value of the implicit timezone in the evaluation context.

If$srcvalis theempty sequence, then the result is the emptysequence.

A dynamic error is raised (invalid timezone value) if $timezone is less than -PT14H00M or greater than PT14H00M.

If $srcval doesnot have a timezone component and $timezone is the empty sequence,then the result is $srcval.

If$srcvaldoes not have a timezone component and $timezone is not the empty sequence, thenthe result is $srcval with $timezoneas the timezone component.

If $srcvalhas a timezone component and $timezoneis the empty sequence, then theresult is $srcval withoutits timezone component.

If $timezoneis not the empty sequence, then the result is $srcval with $timezone as its timezone component.

9.6.2.1 Examples

Assume the evaluation context provides an implicit timezone of -5:00 (-PT5H0M).

let $tz := xdt:dayTimeDuration("-PT10H")

fn:adjust-date-to-timezone(xs:date("2002-03-07")) returns 2002-03-07-05:00
fn:adjust-date-to-timezone(xs:date("2002-03-07-07:00")) returns 2002-03-07-05:00
fn:adjust-date-to-timezone(xs:date("2002-03-07"), $tz) returns 2002-03-07-10:00
fn:adjust-date-to-timezone(xs:date("2002-03-07-07:00"), $tz) returns 2002-03-07-10:00
- fn:adjust-date-to-timezone(xs:date("2002-03-07"),()) returns2002-03-07
- fn:adjust-date-to-timezone(xs:date("2002-03-07-07:00"),()) returns2002-03-07

9.6.3 fn:adjust-time-to-timezone

fn:adjust-time-to-timezone(

$srcval as xs:time?

) as xs:dateTime?

`fn:adjust-time-to-timezone`(	`$srcval`	`as` `xs:time?`,
`fn:adjust-time-to-timezone`(	`$timezone`	`as` `xdt:dayTimeDuration?`) `as` `xs:time?`

Adjustsan xs:timevalue toa specific timezone, or to no timezone at all. If $timezoneis the empty sequence, returns an xs:timewithout a timezone. Otherwise, returns anxs:timewith a timezone.

If $timezone is not specified, then $timezone is the value of the implicit timezone in the evaluation context.

If$srcvalis theempty sequence,then the result is the empty sequence.

Adynamic error is raised (invalidtimezone value) if $timezoneis less than -PT14H00M or greater thanPT14H00M.

If $srcval does not have a timezone component and$timezone isthe empty sequence, then the result is$srcval.

If $srcvaldoes not have a timezone component and $timezone is not the emptysequence, then the result is $srcval with $timezoneas the timezone component.

If $srcval has a timezonecomponent and $timezoneis the empty sequence, then the result is $srcval withoutits timezone component.

If $srcval has a timezone component and $timezone is not the empty sequence, then:

Let$srcdt be an xs:dateTimevalue, with an arbitrary date forthe date component and time andtimezone components that arethe same as the time and timezone components of $srcval.
Let$rbe the result of evaluating

fn:adjust-dateTime-to-timezone($srcdt, $timezone)
Theresult of this function willbe a time value that has time and timezone components that are the same as the time and timezone components of $r.

9.6.3.1 Examples

Assume the evaluation context provides an implicit timezone of -5:00 (-PT5H0M).

let $tz := xdt:dayTimeDuration("-PT10H")

fn:adjust-time-to-timezone(xs:time("10:00:00")) returns 10:00:00-05:00
fn:adjust-time-to-timezone(xs:time("10:00:00-07:00")) returns 12:00:00-05:00
- fn:adjust-time-to-timezone(xs:time("10:00:00"), $tz) returns 10:00:00-10:00
fn:adjust-time-to-timezone(xs:time("10:00:00-07:00"), $tz) returns 07:00:00-10:00
- fn:adjust-time-to-timezone(xs:time("10:00:00"), ()) returns 10:00:00
fn:adjust-time-to-timezone(xs:time("10:00:00-07:00"), ()) returns 10:00:00
- fn:adjust-time-to-timezone(xs:time("10:00:00-07:00"), xdt:dayTimeDuration("PT10H")) returns 03:00:00+10:00

9.7 Adding and Subtracting Durations From dateTime, date and time

These functions support adding or subtracting a duration value to or from an xs:dateTime,an xs:dateor an xs:timevalue. Appendix E of [XML Schema Part 2: Datatypes] describes an algorithm for performing such operations.

If any of the arguments to the functions below is an xs:dateTime,xs:dateor xs:timethat does not contain an explicit timezonethen, for the purpose of the operation, an implicit timezone, provided bythe evaluation context,is assumed to bepresent as part of the value.

Function	Meaning
`fn:subtract-dateTimes-yielding-yearMonthDuration`
`fn:subtract-dateTimes-yielding-dayTimeDuration`
`op:subtract-dates`
`op:subtract-times`
`op:add-yearMonthDuration-to-dateTime`
`op:add-dayTimeDuration-to-dateTime`
`op:subtract-yearMonthDuration-from-dateTime`
`op:subtract-dayTimeDuration-from-dateTime`
`op:add-yearMonthDuration-to-date`
`op:add-dayTimeDuration-to-date`
`op:subtract-yearMonthDuration-from-date`
`op:subtract-dayTimeDuration-from-date`
`op:add-dayTimeDuration-to-time`
`op:subtract-dayTimeDuration-from-time`

9.7.1 fn:subtract-dateTimes-yielding-yearMonthDuration

`fn:subtract-dateTimes-yielding-yearMonthDuration`(	`$srcval1`	`as` `xs:dateTime`,
`fn:subtract-dateTimes-yielding-yearMonthDuration`(	`$srcval2`	`as` `xs:dateTime`) `as` `xdt:yearMonthDuration`

Returns the xdt:yearMonthDurationthat corresponds to the difference between the normalized value of $srcval1 and the normalized value of $srcval2. If either argument is the empty sequence, returns the empty sequence. If the normalized value of $srcval1 precedes in time the normalized value of $srcval2, the returned value is a negative duration.

In general, the difference between two xs:dateTimevalues will be a duration that contains years and months as well as days, hours, etc. In fact, it can be looked at as an xdt:yearMonthDurationplus an xdt:dayTimeDuration.This function returns the result rounded to contain only years and months. The calculation is as follows: first the duration is calculated as the value of an xdt:dayTimeDurationin seconds. Then, starting from $srcval2, the maximum number of months in the duration are calculated. Ifthere is aremaining number of days, theyare discarded.

9.7.1.1 Examples

fn:subtract-dateTimes-yielding-yearMonthDuration(xs:dateTime("2000-10-30T11:12:00"), xs:dateTime("1999-11-28T09:00:00")) returns a xdt:yearMonthDurationvalue corresponding to 11 months.

9.7.2 fn:subtract-dateTimes-yielding-dayTimeDuration

`fn:subtract-dateTimes-yielding-dayTimeDuration`(	`$srcval1`	`as` `xs:dateTime`,
`fn:subtract-dateTimes-yielding-dayTimeDuration`(	`$srcval2`	`as` `xs:dateTime`) `as` `xdt:dayTimeDuration`

Returns the xdt:dayTimeDurationthat corresponds to the difference between the normalized value of $srcval1 and the normalized value of $srcval2. If either argument is the empty sequence, returns the empty sequence. If the normalized value of $srcval1 precedes in time the normalized value of $srcval2, then the returned value is a negative duration.

9.7.2.1 Examples

Assumethat the evaluationcontext provides an implicit timezone value of -5:00.

fn:subtract-dateTimes-yielding-dayTimeDuration(xs:dateTime("2000-10-30T06:12:00"), xs:dateTime("1999-11-28T09:00:00Z")) returns an xdt:dayTimeDurationvalue corresponding to 337 days, 2 hours and 12 minutes.

9.7.3 op:subtract-dates

`op:subtract-dates`(	`$srcval1`	`as` `xs:date`,
`op:subtract-dates`(	`$srcval2`	`as` `xs:date`) `as` `xdt:dayTimeDuration`

Returns the xdt:dayTimeDurationthat corresponds to the difference between the normalized value of $srcval1 and the normalizedvalue of $srcval2.If either argument is the empty sequence, returns the empty sequence. If the normalized value of $srcval1precedes in timethe normalized valueof $srcval2,then the returned value is a negative duration.

Backs up the subtract, "-", operator on xs:datevalues.

9.7.3.1 Examples

op:subtract-dates(xs:date("2000-10-30"), xs:date("1999-11-28")) returns an xdt:dayTimeDurationvalue corresponding to 337 days.

9.7.4 op:subtract-times

`op:subtract-times`(	`$srcval1`	`as` `xs:time`,
`op:subtract-times`(	`$srcval2`	`as` `xs:time`) `as` `xdt:dayTimeDuration`

Backs up the subtract, "-", operator on xs:timevalues.

9.7.4.1 Examples

Assume that the evaluation context provides an implicit timezone value of -5:00.

op:subtract-times(xs:time("11:12:00Z"), xs:time("04:00:00")) returns an xdt:dayTimeDurationvalue corresponding to 2 hours and 12 minutes.

9.7.5 op:add-yearMonthDuration-to-dateTime

`op:add-yearMonthDuration-to-dateTime`(	`$srcval1`	`as` `xs:dateTime`,
`op:add-yearMonthDuration-to-dateTime`(	`$srcval2`	`as` `xdt:yearMonthDuration`) `as` `xs:dateTime`

Returns the xs:dateTimecomputed by adding $srcval2 to the normalized value of $srcval1 using the algorithm described in Appendix E of [XML Schema Part 2: Datatypes]. If $srcval2 is negative, then the result xs:dateTimeprecedes $srcval1.

The result has the same timezone as srcval1. If srcval1 has no timezone, the result has no timezone.

This functions backs up the "+" operator on xs:dateTimeand xdt:yearMonthDuration values.

9.7.5.1 Examples

op:add-yearMonthDuration-to-dateTime(xs:dateTime("2000-10-30T11:12:00"), xdt:yearMonthDuration("P1Y2M")) returns an xs:dateTimevalue corresponding to the lexical representation "2001-12-30T11:12:00".

9.7.6 op:add-dayTimeDuration-to-dateTime

`op:add-dayTimeDuration-to-dateTime`(	`$srcval1`	`as` `xs:dateTime`,
`op:add-dayTimeDuration-to-dateTime`(	`$srcval2`	`as` `xdt:dayTimeDuration`) `as` `xs:dateTime`

Returns the xs:dateTimecomputed by adding $srcval2 to the normalized valueof $srcval1 using the algorithm described in Appendix E of [XML Schema Part 2: Datatypes]. If $srcval2 is negative, then the result xs:dateTimeprecedes $srcval1.

The result has the same timezone as srcval1. If srcval1 has no timezone, the result has no timezone.

This functions backs up the "+" operator on xs:dateTimeand xdt:dayTimeDuration values.

9.7.6.1 Examples

op:add-dayTimeDuration-to-dateTime(xs:dateTime("2000-10-30T11:12:00"), xdt:dayTimeDuration("P3DT1H15M")) returns an xs:dateTimevalue corresponding to the lexical representation "2000-11-02T12:27:00".

9.7.7 op:subtract-yearMonthDuration-from-dateTime

`op:subtract-yearMonthDuration-from-dateTime`(	`$srcval1`	`as` `xs:dateTime`,
`op:subtract-yearMonthDuration-from-dateTime`(	`$srcval2`	`as` `xdt:yearMonthDuration`) `as` `xs:dateTime`

Returns the xs:dateTimecomputed by negating $srcval2 and adding the result to the normalized value of$srcval1 using the algorithm described in Appendix E of [XML Schema Part 2: Datatypes]. If $srcval2 is negative, then the xs:dateTimereturned follows $srcval1.

The result has the same timezone as srcval1. If srcval1 has no timezone, the result has no timezone.

This functions backs up the "-" operator on xs:dateTimeand xdt:yearMonthDuration values.

9.7.7.1 Examples

op:subtract-yearMonthDuration-from-dateTime(xs:dateTime("2000-10-30T11:12:00"), xdt:yearMonthDuration("P1Y2M")) returns an xs:dateTimevalue corresponding to the lexical representation "1999-08-30T11:12:00".

9.7.8 op:subtract-dayTimeDuration-from-dateTime

`op:subtract-dayTimeDuration-from-dateTime`(	`$srcval1`	`as` `xs:dateTime`,
`op:subtract-dayTimeDuration-from-dateTime`(	`$srcval2`	`as` `xs:dayTimeDuration`) `as` `xs:dateTime`

The result has the same timezone as srcval1. If srcval1 has no timezone, the result has no timezone.

This functions backs up the "-" operator on xs:dateTimeand xdt:dayTimeDurationvalues.

9.7.8.1 Examples

op:subtract-dayTimeDuration-from-dateTime(xs:dateTime("2000-10-30T11:12:00"), xdt:dayTimeDuration("P3DT1H15M")) returns an xs:dateTimevalue corresponding to the lexical representation "2000-10-27T09:57:00".

9.7.9 op:add-yearMonthDuration-to-date

`op:add-yearMonthDuration-to-date`(	`$srcval1`	`as` `xs:date`,
`op:add-yearMonthDuration-to-date`(	`$srcval2`	`as` `xdt:yearMonthDuration`) `as` `xs:date`

Returns the xs:datecomputed by adding $srcval2 to the normalized value of$srcval1 using the algorithm described in Appendix E of [XML Schema Part 2: Datatypes]. If $srcval2 is negative, then the xs:datereturned precedes $srcval1.

The result has the same timezone as srcval1. If srcval1 has no timezone, the result has no timezone.

This functions backs up the "+" operator on xs:dateand xdt:yearMonthDuration values.

9.7.9.1 Examples

op:add-yearMonthDuration-to-date(xs:date("2000-10-30"), xdt:yearMonthDuration("P1Y2M")) returns the xs:datewhose normalized value is December 30, 2001.

9.7.10 op:add-dayTimeDuration-to-date

`op:add-dayTimeDuration-to-date`(	`$srcval1`	`as` `xs:date`,
`op:add-dayTimeDuration-to-date`(	`$srcval2`	`as` `xdt:dayTimeDuration`) `as` `xs:date`

The result has the same timezone as srcval1. If srcval1 has no timezone, the result has no timezone.

This functions backs up the "+" operator on xs:dateand xdt:dayTimeDuration values.

9.7.10.1 Examples

op:add-dayTimeDuration-to-date(xs:date("2000-10-30"), xdt:dayTimeDuration("P2DT2H30M0S")) returns the xs:datewhose normalized value is November 1, 2000".

9.7.11 op:subtract-yearMonthDuration-from-date

`op:subtract-yearMonthDuration-from-date`(	`$srcval1`	`as` `xs:date`,
`op:subtract-yearMonthDuration-from-date`(	`$srcval2`	`as` `xdt:yearMonthDuration`) `as` `xs:date`

Returns the xs:datecomputed by negating $srcval2 and adding the result to the normalized value of$srcval1 using the algorithm described in Appendix E of [XML Schema Part 2: Datatypes]. If $srcval2 is negative, then the xs:datereturned precedes $srcval1.

The result has the same timezone as srcval1. If srcval1 has no timezone, the result has no timezone.

This functions backs up the "-" operator on xs:dateand xdt:yearMonthDuration values.

9.7.11.1 Examples

op:subtract-yearMonthDuration-from-date(xs:date("2000-10-30"), xdt:yearMonthDuration("P1Y2M")) returns the xs:datewhose normalized value is August 30, 1999.

9.7.12 op:subtract-dayTimeDuration-from-date

`op:subtract-dayTimeDuration-from-date`(	`$srcval1`	`as` `xs:date`,
`op:subtract-dayTimeDuration-from-date`(	`$srcval2`	`as` `xdt:dayTimeDuration`) `as` `xs:date`

Returns the xs:datecomputed by negating $srcval2 and adding the result to the normalized value of $srcval1 using the algorithm described in Appendix E of [XML Schema Part 2: Datatypes]. If $srcval2 is negative, then the xs:datereturned precedes $srcval1.

The result has the same timezone as srcval1. If srcval1 has no timezone, the result has no timezone.

This functions backs up the "-" operator on xs:dateand xdt:dayTimeDuration values.

9.7.12.1 Examples

op:subtract-dayTimeDuration-from-date(xs:date("2000-10-30"), xdt:dayTimeDuration("P3DT1H15M")) returns a xs:datewhose normalized value is October 26, 2000.

9.7.13 op:add-dayTimeDuration-to-time

`op:add-dayTimeDuration-to-time`(	`$srcval1`	`as` `xs:time`,
`op:add-dayTimeDuration-to-time`(	`$srcval2`	`as` `xdt:dayTimeDuration`) `as` `xs:time`

First, the days component in the canonical lexical representation of $srcval2 is set to zero (0) and the value of the resulting xdt:dayTimeDurationis calculated. Alternatively, the value modulus 86,400 is used. This value is added to the normalized value of $srcval1 and the result returned. Note that the xs:time returned may occur in a following or preceding day and may be less than $srcval1.

The result has the same timezone as srcval1. If srcval1 has no timezone, the result has no timezone.

This functions backs up the "+" operator on xs:timeand xdt:dayTimeDuration values.

9.7.13.1 Examples

op:add-dayTimeDuration-to-time(xs:time("11:12:00"), xdt:dayTimeDuration("P3DT1H15M")) returns a normalized xs:time value corresponding to the lexical representation "12:27:00".
- op:add-dayTimeDuration-to-time(xs:time("23:12:00"), xdt:dayTimeDuration("P1DT3H15M")) returns a normalized xs:time value corresponding to the lexical representation "02:27:00".

9.7.14 op:subtract-dayTimeDuration-from-time

`op:subtract-dayTimeDuration-from-time`(	`$srcval1`	`as` `xs:time`,
`op:subtract-dayTimeDuration-from-time`(	`$srcval2`	`as` `xs:dayTimeDuration`) `as` `xs:time`

First, the days component in the canonical lexical representation of $srcval2 is set to zero (0) and the value of the resulting xdt:dayTimeDurationis calculated. Alternatively, the value modulus 86,400 is used. This value is subtracted from the normalized value of $srcval1 and the result returned. Note that the xs:time returned may occur in a preceding or following day and may be greater than $srcval1.

The result has the same timezone as srcval1. If srcval1 has no timezone, the result has no timezone.

This functions backs up the "-" operator on xs:timeand xdt:dayTimeDuration values.

9.7.14.1 Examples

op:subtract-dayTimeDuration-from-time(xs:time("11:12:00"), xdt:dayTimeDuration("P3DT1H15M")) returns a normalized xs:time value correspondingto the lexical representation "09:57:00".
- op:subtract-dayTimeDuration-from-time(xs:time("08:20:00"), xdt:dayTimeDuration("P23DT10H10M")) returns a normalized xs:time value corresponding to the lexical representation "22:10:00".

10 Functions Related to QNames

10.1 Constructor Functions for QNames

Since the validity of a QName is situation dependent, there is no constructor function for QName defined in 5 Constructor Functions. Neither is casting defined for QName from any other type in 17 Casting Functions. This section defines constructor functions for QName as defined in [XML Schema Part 2: Datatypes]. Leading and trailing whitespace, if present, is stripped from string arguments before the result is constructed.

`fn:resolve-QName`	Returns an `xs:QName` QName with the lexical form given in the first argument. The prefix is resolved using the in-scope namespaces for a given element.
`fn:expanded-QName`	Returnsin an `xs:QName` with the namespace URI given in the first argument and the local name in the second argument.

10.1.1 fn:resolve-QName

fn:resolve-QName($qname as xs:string, $element as element) as xs:QName

Returns an xs:QNamevalue (that is, an expanded QName)by taking an xs:stringthat has thelexical form of an xs:QName(a string in the form "prefix:local-name" or "local-name") andresolving it using the in-scope namespaces for a given element.

Morespecifically, the function searches the namespace nodes of $element for a node whosename matches the prefix of $qname,or the zero-lengthstring if it has noprefix, and constructs an expanded QName whose local name is taken from the supplied $qname, and whosenamespace URI is taken fromthe string value ofthe namespace node.

If the $qname has a prefix and if there is nonamespace nodefor $elementthat matches this prefix, then anerror is raised ("nonamespace found for prefix").

If the $qname has no prefix, and thereis no unnamed namespace node for $element, then the resulting expanded QName has no namespace part.

10.1.1.1 Usage Note

Sometimes therequirement is to constructan xs:QNamewithoutusing the default namespace.This can be achieved by writing:

   if (contains($qname, ":") then fn:resolve-QName($qname, $element)
        else fn:expanded-QName((), $qname)

If the requirementis to construct anxs:QNameusing the namespacesin the static context,then the xs:QNameconstructor should be used.

10.1.1.2 Examples

Assumethat the element boundto$element has a singlenamespace node bound to the prefixeg.

fn:resolve-QName("hello",$element)returns a QNamewith localname "hello" that is in no namespace.
fn:resolve-QName("eg:myFunc",$element) returns an xs:QNamewhosenamespace URI is specifiedby the namespace nodecorresponding to the prefix "eg" and whose local name is "myFunc".

10.1.2 fn:expanded-QName

fn:expanded-QName($paramURI as xs:string, $paramLocal as xs:string) as xs:QName

Returnsan xs:QNamewith the namespace URI given in $paramURIand the local name in $paramLocal.If $paramURIis the empty string, it represents "no namespace".

10.1.2.1 Examples

fn:expanded-QName("http://www.example.com/example", "person") returns anxs:QName with namespace URI ="http://www.example.com/example" and local name = "person".

10.2 Functions Related to QNames

This section discusses functions on QNames as defined in [XML Schema Part 2: Datatypes].

`op:QName-equal`	Returns `true` if the local names and namespace URIs of the two arguments are equal.
`fn:get-local-name-from-QName`
`fn:get-namespace-from-QName`
`fn:get-namespace-uri-for-prefix`	Returns the namespace URI of one of the in-scope namespaces for the given element, identified by its namespace prefix.
`fn:get-in-scope-namespaces`	Returns the prefixes of the in-scope namespaces for the given element.

10.2.1 op:QName-equal

op:QName-equal($srcval1 as xs:QName, $srcval2 as xs:QName) as xs:boolean

Returns true if the namespace URIs of $srcval1 and $srcval2 are equal and the local-name parts of $srcval1 and $srcval2 are identical on a codepoint-by-codepoint basis. Otherwise, returns false. Two namespace URIs are considered equal if they are either both absent or both present and identical on a codepoint-by-codepoint basis. See also 11.2 op:anyURI-equal.

Backs up the "eq" and "ne" operators on values of type xs:QName.

10.2.2 fn:get-local-name-from-QName

fn:get-local-name-from-QName($srcval as xs:QName?) as xs:string?

Returns an xs:stringrepresenting the local part of $srcval. If $srcval is the empty sequence, returns the empty sequence.

10.2.2.1 Examples

fn:get-local-name-from-QName(fn:expanded-QName("http://www.example.com/example", "person")) returns "person".

10.2.3 fn:get-namespace-from-QName

fn:get-namespace-from-QName($srcval as xs:QName?) as xs:string?

Returns the namespace URI for $srcval as an xs:string. If $srcval is the empty sequence, the empty sequence is returned. If $srcval is in no namespace, the empty sequence is returned.

10.2.3.1 Examples

fn:get-namespace-from-QName(fn:expanded-QName("http://www.example.com/example", "person")) returns the namespace URI corresponding to "http://www.example.com/example".

10.2.4 fn:get-namespace-uri-for-prefix

`fn:get-namespace-uri-for-prefix`(	`$element`	`as` `element`,
`fn:get-namespace-uri-for-prefix`(	`$prefix`	`as` `xs:string`) `as` `xs:string?`

Returns the namespace URI of one of the in-scope namespaces for $element,identified by its namespace prefix.

If $element has an in-scope namespace whose namespace prefix is equal to $prefix,it returns the namespace URI of that namespace. If $prefix is the zero-length string, it returns the namespace URI of the default (unnamed) namespace. Otherwise, it returns the empty sequence.

Prefixes are equal only if their Unicode code-points match exactly.

10.2.5 fn:get-in-scope-namespaces

fn:get-in-scope-namespaces($element as element) as xs:string*

Returns the prefixes of the in-scope namespaces for $element. For namespaces that have a prefix, it returns the prefixas an xs:NCName.For the default namespace, which has noprefix, it returns the zero-length string.

11 Functions and Operators for anyURI

This section specifiesfunctions that take anyURI as arguments.

`fn:resolve-uri`	Returns an absolute `xs:anyURI` given a base URI and a relative URI.
`op:anyURI-equal`	Returns `true` if the two arguments are equal.

11.1 fn:resolve-uri

fn:resolve-uri($relative as xs:string) as xs:string

fn:resolve-uri($relative as xs:string, $base as anyURI) as xs:string

The second form of this function expects $base to be an absolute URI and $relative to be a relative URI. It resolves the relative URI $relative against the base-uri $base and returns the resulting absolute URI. If $relative is an absolute URI, it is returned unchanged. If $base is not an absolute URI, a error is raised ("Relative URI base argument to resolve-uri").

If $relative or $base is not in the lexical space of xs:anyURI an error is raised ("Invalid argument to resolve-uri").

The first form of this function resolves the relative URI $relative against the value of the base-uri property from the static context. If $relative is an absolute URI, it is returned unchanged. If the base-uri property is not initialized in the static context an error is raised ("Base uri undefinedin the static context").

If the $relativeURI is the zero-length string, returns the value of the base-uri property from the static context in the first form and $base in the second form.

Note:

Resolving a URI does not dereference it. This is merely a syntactic operation on two character strings.

11.2 op:anyURI-equal

op:anyURI-equal($srcval1 as xs:anyURI, $srcval2 as xs:anyURI) as xs:boolean

Returns true if $srcval1 and $srcval2 compare equal on a codepoint-by-codepoint basis. Otherwise, returns false. This function backs up the "eq" and "ne" operators on anyURI.

For more details on comparing URIs see [How to Compare URIs].

11.2.1 Examples

op:anyURI-equal(anyURI("gopher://spinaltap.micro.umn.edu/00/Weather/California/Los%20Angeles"), anyURI("gopher://spinaltap.micro.umn.edu")) returns false

12 Functions and Operators on base64Binary and hexBinary

12.1 Comparisons of base64Binary and hexBinary Values

We define the following comparison operators on xs:base64Binaryand xs:hexBinaryvalues. Comparisons take two operands of the same type; that is, both operands must be xs:base64Binaryor both operands may be xs:hexBinary.Each returns a boolean value.

`op:hexBinary-equal`	Returns `true` if the two arguments are equal.
`op:base64Binary-equal`	Returns `true` if the two arguments are equal.

12.1.1 op:hexBinary-equal

`op:hexBinary-equal`(	`$value1`	`as` `xs:hexBinary`,
`op:hexBinary-equal`(	`$value2`	`as` `xs:hexBinary`) `as` `xs:boolean`

Returns true if $value1 and value2 are of the same length and contain the same code-points. Otherwise, returns false.

This function backs up the "eq" and "ne" operators on xs:hexBinaryvalues.

12.1.2 op:base64Binary-equal

`op:base64Binary-equal`(	`$value1`	`as` `xs:base64Binary`,
`op:base64Binary-equal`(	`$value2`	`as` `xs:base64Binary`) `as` `xs:boolean`

Returns true if $value1 and value2 are of the same length and contain the same code-points. Otherwise, returns false.

This function backs up the "eq" and "ne" operators on xs:base64Binaryvalues.

13 Functions and Operators on NOTATION

13.1 Operators on NOTATION

This section discusses functions that take NOTATION as arguments.

op:NOTATION-equal Returns true if the two arguments are equal.

13.1.1 op:NOTATION-equal

`op:NOTATION-equal`(	`$srcval1`	`as` `xs:NOTATION`,
`op:NOTATION-equal`(	`$srcval2`	`as` `xs:NOTATION`) `as` `xs:boolean`

Returns true if $srcval1 and $srcval2 compare equal on a codepoint-by-codepoint basis. Else returns false. This function backs up the "eq" and "ne" operators on xs:NOTATION values.

14 Functions and Operators on Nodes

This section discusses functions and operators on nodes.Nodes are formally defined in [XQuery 1.0 and XPath 2.0 Data Model].

14.1 Functions and Operators on Nodes

`fn:name`
`fn:local-name`
`fn:namespace-uri`
`fn:number`
`op:node-equal`

For the illustrative examples below, assume an XQuery operating on a Purchase Order document containing a number of line-item elements. Each line-item has child elements called description, quantity, etc. Quantity has simple content of type decimal. Further assume that variables $item1, $item2, etc. are bound to the nodes for the line-item elements in the document in sequence. Further, assume that the value of the quantity child of the first line-item is 5.

14.1.1 fn:name

fn:name() as xs:string

fn:name($srcval as node?) as xs:string

Returns the name of a node, as an xs:stringthat is either the zero-length string, or has the lexical form of an xs:QName.

If the argument is omitted, it defaults to the context node. If there is no context node (that is, if there is no context item, or if the context item is not a node), the zero-lengthstring is returned.

If the argument is supplied and is the empty sequence, the function returns the zero-length string.

If the target node has no name (that is, if it is a document node, a comment, a text node, or a namespace node having no name), the function returns the zero-length string.

Otherwise, the value returned is an xs:stringwhose lexical form is an xs:QName.

If $srcval is a processing instruction or a namespace node, or if it is an element or attribute node whose expanded-QName (as determined by the dm:node-nameaccessor in the [XQuery 1.0 and XPath 2.0 Data Model])is in no namespace, then the function returns the local part of the expanded-QName.

If $srcval is an element or attribute whose expanded-QNameis in a namespace, then a prefix is determined using the same rules as those for determining the prefix property when the element or attribute node is mapped to an element or attribute information item in the InfoSet. These rules are given in [XQuery 1.0 and XPath 2.0 Data Model]. This prefix is then combined with the local part of the node's expanded-QNameto form a string which will take one of the forms "prefix:local-part" (if the prefix is a non-zero length string) or "local-part" (if the prefix is a zero-length string).

14.1.2 fn:local-name

fn:local-name() as xs:string

fn:local-name($srcval as node?) as xs:string

Returns the local part of the name of $srcval as an xs:stringthat will either be the zero-length string or will have the lexical form of an xs:NCName.

If the argument is supplied and is the empty sequence, the function returns the zero-length string.

If the target node has no name (that is, if it is a document node, a comment, or a text node), the function returns the zero-length string.

Otherwise, the value returned will be the local part of the expanded-QName of the target node (as determined by the name accessor in the data model). This will be an xs:stringwhose lexical form is an xs:NCName.

14.1.3 fn:namespace-uri

fn:namespace-uri() as xs:string

fn:namespace-uri($srcval as node?) as xs:string

Returns the namespace URI of the QName of $srcval as a, xs:string.

If $srcval is the empty sequence, the zero-length string is returned.

If $srcval is neither an element nor an attribute node, or if it is an element or attribute node that has no QName or whose expanded-QName (as determined by the dm:nameaccessor in the [XQuery 1.0 and XPath 2.0 Data Model])is in no namespace, then the function returns the zero-length string.

14.1.4 fn:number

fn:number() as xs:double

fn:number($srcval as item?) as xs:double

Returns the value indicated by $srcval or, if $srcval is not specified, the context node, converted to an xs:double. If there is no context node (that is, if there is no context item, or if the context item is not a node), NaN isreturned.

If $srcval is the empty sequence, returns the xs:double value NaN.
- If $srcval isatomic, returns the value obtained by converting it to xs:doublefollowing the rules of 17.8 Casting to numeric types.
If $srcval is a node with anatomic type, returns that value converted to xs:doublefollowing the rules of 17.8 Casting to numeric types.
Otherwise, converts $srcval to an xs:stringas if by a call to the fn:string() function and then converts the result to an xs:doublefollowing the rules of 17.8 Casting to numeric types.

If the conversion to xs:doublefails because the lexical representation is not a valid lexical representation of a numeric simple type as defined in [XML Schema Part 2: Datatypes], returnsthe xs:doublevalue NaN.

14.1.4.1 Examples

fn:number($item1/quantity) returns 5.
If fn:number($item2) returnsNaN.

14.1.5 fn:lang

fn:lang($testlang as xs:string) as xs:boolean

Returns true or false depending on whether the language of the context node, as defined using the xml:lang attribute, is the same as, or a sublanguage of, the language specified by $testlang.

If there is no context node (that is, if there is no context item, or if the context item is not a node), false is returned.

The relevant xml:lang attribute is determined by the value of the XPath expression:

(ancestor-or-self::*/@xml:lang)[last()]

If this expression returns an empty sequence, the function returns false.

Otherwise, the function returns true if and only if the string-value of the relevant xml:lang attribute is equal to $testlang ignoring case, or if the string-value of the relevant testlang attribute contains some hyphen (-) such that the part of the string-value preceding that hyphen is equal to $testlang, ignoring case.

14.1.5.1 Examples

For example, the expression fn:lang("en") would return true if the context node were any of the following five elements:
- <para xml:lang="en"/>
- <div xml:lang="en"><para></div>
- <para xml:lang="EN"/>
- <para xml:lang="en-us"/>

14.1.6 op:node-equal

op:node-equal($parameter1 as node, $parameter2 as node) as xs:boolean

If the node identified by the value of $parameter1 is the same node as the node identified by the value of $parameter2 (that is, the two nodes have the same identity), then the function returns true; otherwise, the function returns false. This function backs up the "is" and "isnot" operators on nodes.

14.1.6.1 Examples

op:node-equal($item1, $item1) returns true.
op:node-equal($item1, $item2) returns false.

14.1.7 op:node-before

op:node-before($parameter1 as node, $parameter2 as node) as xs:boolean

If the node identified by the value of $parameter1 occurs in document order before the node identified by the value of $parameter2, this function returns true; otherwise, it returns false. The rules determining the order of nodes within a single document and in different documents can be found in [XQuery 1.0 and XPath 2.0 Data Model]. This function backs up the "<<" operator.

14.1.7.1 Examples

op:node-before($item1, $item2) returns true.
op:node-before($item1, $item1) returns false.

14.1.8 op:node-after

op:node-after($parameter1 as node, $parameter2 as node) as xs:boolean

If the node identified by the value of $parameter1 occurs in document order after the node identified by the value of $parameter2, this function returns true; otherwise, it returns false. The rules determining the order of nodes within a single document and in different documents can be found in [XQuery 1.0 and XPath 2.0 Data Model]. This function backs up the ">>" operator.

14.1.8.1 Examples

op:node-after($item1, $item2) returns false.
op:node-after($item1, $item1) returns false.
- op:node-after($item2, $item1) returns true.

14.1.9 fn:root

fn:root() as node

fn:root($srcval as node) as node

Returns the root of the tree to which $srcval belongs. This will usually, but not necessarily, be a document node. If $srcval is a document node, it is returned.

If the function is called without an argument, the context item is used as the default argument. If there is no context node (that is, if there is no context item, or if the context item is not a node), an error is raised ("Context item is not a node").

15 Functions and Operators on Sequences

A sequence is an ordered collection of zero or more items. An item is either a node or an atomic value. The terms sequence and item are defined formally in [XQuery 1.0: An XML Query Language] and [XPath 2.0].

15.1 Functions and Operators on Sequences

The following functions are defined on sequences.

Function	Meaning

As in the previous section, for the illustrative examples below, assume an XQuery operating on a Purchase Order document containing a number of line-item elements. The variable $seq is bound to the sequence of line-item nodes in document order. The variables $item1, $item2, etc. are bound to individual line-item nodes in the sequence.

15.1.1 fn:zero-or-one

fn:zero-or-one($srcval as item*) as item?

Returns $srcvalif it contains zero or one items. Otherwise, raises an error ("fn:zero-or-one called with a sequence containing more than one item"). The typeof the result is the type of$srcval.

15.1.2 fn:one-or-more

fn:one-or-more($srcval as item*) as item+

Returns $srcval if it contains one or more items. Otherwise, raises an error ("fn:one-or-more called with a sequence containing zero items"). The type of the result is the type of $srcval.

15.1.3 fn:exactly-one

fn:exactly-one($srcval as item*) as item

Returns $srcval if it contains exactly one item. Otherwise, raises anerror ("fn:exactly-one called with a sequence containing zero or more than one item"). The type of the result is the type of $srcval.

15.1.4 fn:boolean

fn:boolean($srcval as item*) as xs:boolean

Computes the xs:boolean value of the sequence $srcval.

If $srcvalis the empty sequence, returns false.

If $srcval is an atomic value, then the function returns the same value as returned by the expression cast as xs:boolean ($srcval) with the one exception described below. This exception is for compatibility with [XPath 1.0]. Specifically, it returns false if $srcval is:

The singleton xs:booleanvalue false.
The singleton xs:stringvalue "". (the zero-length string). The expression cast as xs:boolean ($srcval) returns false if $srcval is "0" and true if $srcval is "1".
A singleton numeric value that is numerically equal to zero.
The singleton xs:doubleor xs:floatvalue NaN.

Otherwise, returns true.

15.1.5 op:concatenate

op:concatenate($seq1 as item*, $seq2 as item*) as item*

Returns a sequence consisting of the items in $seq1 followed by the items in $seq2. This function backs up the infix operator ",". If either sequence is the empty sequence, the other operand is returned.

15.1.5.1 Examples

op:concatenate((1 2 3), (4 5)) returns (1 2 3 4 5).
op:concatenate((), ()) returns ().

15.1.6 fn:item-at

fn:item-at($seqParam as item*, $posParam as integer) as item?

Returns the item in $seqParam that is located at the index that is the value of $posParam. The return type is the type of the item returned.

If $seqParam is the empty sequence, returns the empty sequence.

If the value of $posParam is greater than the number of items in the sequence, or is less than or equal to zero (0), then an error is raised ("Invalid position").

This function is used in the definition of the formal semantics of filter expressions; that is, expressions of the form expression-1[expression-2]. See [XQuery 1.0 and XPath 2.0 Formal Semantics]

15.1.6.1 Examples

op:node-equal(fn:item-at($seq, 1), $item1) returns true.
- op:node-equal((10, 20, 30), 2) returns 20.

15.1.7 fn:index-of

`fn:index-of`(	`$seqParam`	`as` `xs:anyAtomicType*`,
`fn:index-of`(	`$srchParam`	`as` `xs:anyAtomicType`) `as` `xs:integer*`

`fn:index-of`(	`$seqParam`	`as` `xs:anyAtomicType*`,
	`$srchParam`	`as` `xs:anyAtomicType`,
	`$collationLiteral`	`as` `xs:string`) `as` `xs:integer*`

Informally,the function returns a sequence of positive integers giving the positionswithin the sequence$seqParam of items that are equal to $srchParam.

If $collationLiteral is not in the lexical space of xs:anyURIan error is raised ("Invalid collationURI").

Thecollation used by the invocation of this function is determined according to the rulesin 7.3 Equality and Comparison of Strings.

The items in the sequence$seqParam arecompared with $srchParamunder the rules for the eqoperator, using the selected collation when comparing strings. If the typeof the items in $seqParamis notxs:stringand $collationLiteralis specified,the collation is ignored. If an item compares equal, thenthe position of that item in the sequence $srchParamis included in theresult. If the items arenot comparable, thenan error israised ("Items not comparable").

Ifthe value of $seqParam isthe empty sequence, or if no item in $seqParam matches$srchParam, then the empty sequence is returned.

The first item ina sequence is at position 1, not position 0.

Theresult sequence is in ascending numeric order.

15.1.7.1 Examples

fn:index-of((10, 20, 30, 40),30) returns3.
fn:index-of((10, 20, 30, 40), 35) returns().
fn:index-of ((10, 20, 30, 30, 20, 10), 20)returns (2,5).
If@a is a list-valued attribute whose string value is "red green blue", then: fn:index-of (@a, "blue") returns 3.

This is because the function calling mechanism atomizes the attribute node to produce a sequence of three strings.

15.1.8 fn:empty

fn:empty($srcval as item*) as xs:boolean

If the value of $srcval is the empty sequence, the function returns true; otherwise, the function returns false.

15.1.8.1 Examples

fn:empty($seq) returns false.

15.1.9 fn:exists

fn:exists($srcval as item*) as xs:boolean

If the value of $srcval is not the empty sequence, the function returns true; otherwise, the function returns false.

15.1.9.1 Examples

fn:exists($seq) returns true.

15.1.10 fn:distinct-nodes

fn:distinct-nodes($srcval as node*) as node*

Returns the sequence that results from removing from $srcval all but one of a set of nodes that have the same identity as one another, based on node identity (that is, using op:node-equal()). The order in which the distinct nodes are returned is ·implementation dependent·.If $srcval is the empty sequence, returns the empty sequence. For detailed semantics see section 6.2.2 of [XQuery 1.0 and XPath 2.0 Formal Semantics].

15.1.10.1 Examples

fn:distinct-nodes($seq) returns $seq.

15.1.11 fn:distinct-values

fn:distinct-values($srcval as xs:anyAtomicType*) as xs:anyAtomicType*

`fn:distinct-values`(	`$srcval`	`as` `xs:anyAtomicType*`,
`fn:distinct-values`(	`$collationLiteral`	`as` `xs:string`) `as` `xs:anyAtomicType*`

Returns the sequence that results from removing from $srcval all but one of a set of values that are eq to one other. All the values must be of a single type or one if its subtypes (for numeric values, the numeric promotion rules defined in 6.2 Operators on Numeric Values are used to promote all values to a single common type). The type returned is a sequenceof values of the same type as $srcval. The type must have a total order. If this condition is not satisfied, an error is raised ("Type does not have total order"). Equality must also be defined for the type. If this condition is not satisfied, an error is raised ("Type doesnot have equality defined"). Fordetailed semantics see section 6.2.2 of[XQuery 1.0 and XPath 2.0 Formal Semantics].

If $collationLiteral is not in the lexical space of xs:anyURI an erroris raised ("Invalid collationURI").

If $srcval is the empty sequence, the empty sequence is returned.

For xs:float and xs:double values, NaN is considered to be equal to itself and 0.0 is equal to -0.0.

If an xs:dateTime, xs:date or xs:time value does not have a timezone, an implicit timezone is provided by the evaluation context. The normalized value is adjusted using this implicit timezone if necessary. The adjusted normalized value is used to compute distinctness. If multiple adjusted normalized values compare equal but the accompanying timezones are different, it is ·implementation dependent· which value is returned.

Equality of string values is determined according to the collation that is used. The order of the values returned is ·implementation dependent·. The collation used by the invocation of this function is determined according to the rules in 7.3 Equality and Comparison of Strings. If the type of the items in $srcval is not xs:stringand $collationLiteralis specified, the collationis ignored.

15.1.11.1 Examples

fn:distinct-values(1, 2.0, 3, 2) returns (1, 3, 2.0).

15.1.12 fn:insert-before

`fn:insert-before`(	`$target`	`as` `item*`,
	`$position`	`as` `xs:integer`,
	`$inserts`	`as` `item`) `as` `item`

Returns a new sequence constructed from the value of $target with the value of $inserts inserted at the position specified by the value of $position. (The value of $target is not affected by the sequence construction.)

If N is less than one (1), the first position,the effective value of N is one (1). If N is greater than the number of items in $target, then the effective value of N is equal to the number of items in $target plus 1.

The value returned by the function consists of all items of $target whose index is less than or equal to N, followed by all items of $inserts, followed by the remaining elements of $target, in that sequence.

If $target is the empty sequence, a copy of $inserts is returned. If $inserts is the empty sequence, a copy of $target is returned.

15.1.12.1 Examples

let $x := ("a", "b", "c")

fn:insert-before($x, 0, "z") returns ("z", "a", "b", "c")
fn:insert-before($x, 1, "z") returns ("z", "a", "b", "c")
fn:insert-before($x, 2, "z") returns ("a", "z", "b", "c")
fn:insert-before($x, 3, "z") returns ("a", "b", "z", "c")
fn:insert-before($x, 4, "z") returns ("a", "b", "c", "z")

15.1.13 fn:remove

fn:remove($target as item*, $position as xs:integer) as item*

Returns a new sequence constructed from the value of $target with the item at the position specified by the value of $position removed.

If N is less than 1 or greater than the number of items in $target, no action is taken. Otherwise, the value returned by the function consists of all items of $target whose index is less than N, followed by all items of $target whose index is greater than N. If $target is the empty sequence, the empty sequence is returned.

For detailed semantics, see section 6.2.7 of [XQuery 1.0 and XPath 2.0 Formal Semantics].

15.1.14 fn:subsequence

fn:subsequence($sourceSeq as item*, $startingLoc as xs:double) as item*

`fn:subsequence`(	`$sourceSeq`	`as` `item*`,
	`$startingLoc`	`as` `xs:double`,
	`$length`	`as` `xs:double`) `as` `item*`

If $sourceSeq is the empty sequence, returns the empty sequence.

Returns the contiguous sequence of items in the value of $sourceSeq beginning at the position indicated by the value of $startingLoc and continuing for the number of items indicated by the value of $length. More specifically, returns the items in $sourceString whose position $p obeys:

fn:round($startingLoc) <= $p < fn:round($startingLoc) + fn:round($length)

In the above computation, the rules for op:numeric-less-than() and op:numeric-greater-than() apply.

If $startingLoc is zero or negative, the subsequence includes items from the beginning of the $sourceSeq.

If $length is not specified, the subsequence includes items to the end of $sourceSeq.

If$length isgreater than the number of items in the value of $sourceSeq following $startingLoc,the subsequence includes items to the end of $sourceSeq.

The first item of a sequence is located at position 1, not position 0.

Fordetailed semantics, see section 6.2.7 of [XQuery 1.0 and XPath 2.0 Formal Semantics].

15.1.14.1 Examples

fn:subsequence($seq, 4) returns ($item4, $item5, ...)
fn:subsequence($seq, 4, 2) returns ($item4, $item5)

15.1.15 fn:unordered

fn:unordered($sourceSeq as item*) as item*

This function takes a sequence or more typically, an expression, that evaluates to a sequence, and indicates that the result sequence may be returned in any order.

15.2 Equals, Union, Intersection and Except

fn:deep-equal

fn:sequence-node-identical

As in the previous sections, for the illustrative examples below, assume an XQuery operating on a Purchase Order document containing a number of line-item elements. The variables $item1, $item2, etc. are bound to individual line-item nodes in the sequence. We shall use sequences of these nodes in some of the examples below.

15.2.1 fn:deep-equal

fn:deep-equal($parameter1 as item*, $parameter2 as item*) as xs:boolean

`fn:deep-equal`(	`$parameter1`	`as` `item*`,
	`$parameter2`	`as` `item*`,
	`$collationLiteral`	`as` `string`) `as` `xs:boolean`

If the sequences that are the values of $parameter1 and $parameter2 have the same values (that is, they have the same number of items and items in corresponding positions in the two sequences compare equal, the function returns true; otherwise, the functionreturns false. Equality of corresponding items is determined based on the eq operator if they are atomic values and based on deepequality of nodes, as defined below, if they are nodes.

Returnstrue if both of its arguments arethe empty sequence. Returnsfalseif one, but not both, of its arguments is the empty sequence.

If equality is not defined for the types of two corresponding valuesthe function returns false.

If $collationLiteralis not in the lexical space of xs:anyURIan erroris raised ("Invalid collationURI").

String values are compared using a collation. The collation used is determined according to the rules in 7.3 Equality and Comparison of Strings. If the type of theitems in $parameter1 and $parameter2 is not xs:string and $collationLiteral is specified, thecollation is ignored.

15.2.1.1 Deep Equality of Nodes

The following (recursive) tests are applied in order todetermine whether two nodes are deep equal.

If the two nodesare of different node-kinds, theresult is false.

if (fn:node-kind($parameter1) ne fn:node-kind($parameter2)) 
then false
else

If the two nodes have names, and the names are different when compared as expanded-QNames, the result is false.

if (fn:node-name($parameter1) != fn:node-name($parameter2)) 
then false
else

If the two nodesare text nodes, comment nodes, processing instruction nodes, or namespace nodes, then the result is true if and only if the two nodes have equal string-values, when compared using the selected collation.

if (some $n in ("text", "comment", "processing-instruction", "namespace")
         satisfies $n eq fn:node-kind($parameter1)
    and fn:compare
        (fn:string($parameter1), fn:string($parameter2), $collation) ne 0)
then false
else

If either node has attributes, and if either node has an attribute that is not deep-equal to an attribute of the other node, using the selected collation, then the result is false.

if (some $a1 in $parameter1/@* satisfies
      not (some $a2 in $parameter2/@* 
           satisfies fn:deep-equal($a1, $a2, $collation))
    or some $a2 in $parameter2/@* satisfies
      not (some $a1 in $parameter1/@* 
           satisfies fn:deep-equal($a1, $a2, $collation)))
then false
else

If neither node has element children, then the result is true only if the other node also has simple content, and if the simple content of the two nodes (that is, the result of the fn:data() function) is equal under the rules for the fn:deep-equal() function, using the selected collation. (Note: attributes always have simple content.)

if (empty($parameter1/*) and empty($parameter2/*))
then fn:deep-equal( fn:data($parameter1),
                             fn:data($parameter2),
                             $collation )
else

Otherwise, the result is true if and only if the children of node $parameter1 are pairwise deep-equal to the children of node $parameter2, ignoring comment and processing instruction nodes in both cases.

fn:deep-equal( $parameter1/(* | text()),
                        $parameter2/(* | text()),
                        $collation )

Note:

The two nodes are not required to have the same type annotation, and they are not required to have the same in-scope namespaces. They may also differ in their parent, their base URI, and their IDs. The order of children is significant, but the order of attributes is insignificant. The contents of comments and processing instructions are significant only if these nodes are used directly as arguments to the function, not if they appear as children of the nodes supplied as arguments.

Note:

The result of fn:deep-equal(1, current-dateTime()) is false; it does not raise an error.

15.2.1.2 Examples

fn:deep-equal($item1, $item2) returns false.
fn:deep-equal($item1, $item1) returns true .
fn:deep-equal(($item1, $item2), 2.3E0) returns false.

15.2.2 fn:sequence-node-identical

`fn:sequence-node-identical`(	`$parameter1`	`as` `node*`,
`fn:sequence-node-identical`(	`$parameter2`	`as` `node*`) `as` `xs:boolean?`

Returns the empty sequence if one or both of its arguments is the empty sequence.

If the sequences that are the values of $parameter1 and $parameter2 areidentical, that is, they contain the same number of nodes and the nodesin corresponding positions in the two sequences are identical,then the function returns true; otherwise, the function returns false.

15.2.2.1 Examples

Assume $seq1 = ($item1, $item2), $seq2 = ($item1, $item2) and $seq3 = ($item2, $item3).

fn:sequence-node-identical($seq1, $seq2) returns true.
fn:sequence-node-identical($seq2, $seq3) returns false.

15.2.3 op:union

op:union($parameter1 as node*, $parameter2 as node*) as node*

Constructs a sequence containing every node that occurs in the values of either $parameter1 or $parameter2, eliminating duplicate nodes. Nodes are returned in document order. Two nodes are equal if they are op:node-equal(). For detailed semantics, see section 6.2.4 of [XQuery 1.0 and XPath 2.0 Formal Semantics].

This function backs up the "union" or "|" operator.

15.2.3.1 Examples

Assume $seq1 = ($item1, $item2), $seq2 = ($item1, $item2) and $seq3 = ($item2, $item3).

op:union($seq1, $seq1) returns the sequence ($item1, $item2).
op:union($seq2, $seq3) returns the sequence consisting of ($item1, $item2, $item3).

15.2.4 op:intersect

op:intersect($parameter1 as node*, $parameter2 as node*) as node*

Constructs a sequence containing every node that occurs in the values of both $parameter1 and $parameter2, eliminating duplicate nodes. Nodes are returned in document order.

If either operand is the empty sequence, the empty sequence is returned.

Two nodes are equal if they are op:node-equal(). For detailed semantics, see section 6.2.4 of [XQuery 1.0 and XPath 2.0 Formal Semantics].

This function backs up the "intersect" operator.

15.2.4.1 Examples

Assume $seq1 = ($item1, $item2), $seq2 = ($item1, $item2) and $seq3 = ($item2, $item3).

op:intersect($seq1, $seq1) returns the sequence ($item1, $item2).
op:intersect($seq2, $seq3) returns the sequence ($item2).

15.2.5 op:except

op:except($parameter1 as node*, $parameter2 as node*) as node*

Constructs a sequence containing every node that occurs in the value of $parameter1, but not in the value of $parameter2, eliminating duplicate nodes. Nodes are returned in document order.

If $parameter1 is the empty sequence, the empty sequence is returned. If $parameter2 is the empty sequence, $parameter1 is returned.

Two nodes are equal if they are op:node-equal(). For detailed semantics, see section 6.2.4 of [XQuery 1.0 and XPath 2.0 Formal Semantics].

This function backs up the "except" operator.

15.2.5.1 Examples

Assume $seq1 = ($item1, $item2), $seq2 = ($item1, $item2) and $seq3 = ($item2, $item3).

op:except($seq1, $seq2) returns the empty sequence.
op:except($seq2, $seq3) returns the sequence ($item1).

15.3 Aggregate Functions

Aggregate functions take a sequence as argument and return a single value computed from values in the sequence. Except for fn:count, the sequence must consist of values of a single type or one if its subtypes, or they must be numeric. The typeof the items inthe sequence must also support certain operations.

15.3.1 fn:count

fn:count($srcval as item*) as xs:integer

Returns the number of items in the value of $srcval. Returns 0 if $srcval is the empty sequence.

15.3.1.1 Examples

Assume $seq1 = ($item1, $item2) and $seq3 = (), the empty sequence.

fn:count($seq1) returns 2.
fn:count($seq3) returns 0.

15.3.2 fn:avg

fn:avg($srcval as xdt:anyAtomicType*) as xdt:anyAtomicType?

Returns a value of the same type as the items in $srcval that is the average of the values (computed as sum($srcval) div count($srcval)).

If $srcval is the empty sequence, the empty sequence is returned.

$srcval must contain items of a single type or one ifits subtypes. Duration values must either all be xdt:yearMonthDuration values or must all be xdt:dayTimeDuration values. For numeric values, the numeric promotion rules defined in 6.2 Operators on Numeric Values are used to promote all values to a single common type. Values of type xdt:untypedAtomic are cast to the type of the other items in $srcval. If all values in $srcval are of type xdt:untypedAtomic they are converted to xs:double.In addition, the type must support addition and division by an integer. If date/time values do not have a timezone, the implicit timezone provided by the evaluation context is addedand the adjusted normalized value is used in the calculation.

Ifthe above conditions are notmet, thenanerror is raised ("Invalid argument to fn:avg() function").

If $srcval containsxs:floator xs:doublevalues, NaNvalues are discarded.

Fordetailed semantics, see section 6.2.8 of [XQuery 1.0 and XPath 2.0 Formal Semantics].

15.3.2.1 Examples

Assume $d1 = xdt:yearMonthDuration("P20Y") and $d2 = xdt:yearMonthDuration("P10M") and $seq3 = (3, 4, 5).

fn:avg($seq3) returns 4.
fn:avg(($d1, $d2)) returns a yearMonthDuration with value 125 months.
fn:avg(($d1, $seq3)) raises an error ("Invalid argument to fn:avg()function").

15.3.3 fn:max

fn:max($srcval as xdt:anyAtomicType*) as xdt:anyAtomicType?

`fn:max`(	`$srcval`	`as` `xdt:anyAtomicType*`,
`fn:max`(	`$collationLiteral`	`as` `string`) `as` `xdt:anyAtomicType?`

fn:max returns a value of the same type as the items in $srcval that is the item in the value in $srcval whose value is greater than or equal to the value of every other item in the value of $srcval. If there are two or more such items, then the specific item whose value is returned is ·implementation dependent·.

If $srcval is the empty sequence, the empty sequence is returned.

If $collationLiteral is not in the lexical space of xs:anyURI, an error is raised ("Invalid collationURI").

$srcval must contain only items of a single type or one if its subtypes for which the gt operator isdefined. For numeric values, the numeric promotion rules defined in 6.2 Operators on Numeric Values are used to promote all values to a single common type. Values of type xdt:untypedAtomicare cast to the type of the other items in $srcval. If all values in $srcval are of type xdt:untypedAtomic they are converted to xs:string. In addition, the values in the sequence must have a total order. If date/time values do not have a timezone, the implicit timezone provided by the evaluation context is added and the adjusted normalized value is used in the calculation.Duration values must either all be xdt:yearMonthDurationvalues or must all be xdt:dayTimeDurationvalues.

If any of these conditions is not met, then an error is raised ("Invalid argumentto fn:max() function").

If$srcval containsxs:float or xs:doublevalues, NaNvalues are discarded.

Forxs:dateTime,xs:dateor xs:timevalues with the same (adjusted) normalized value and different timezones, the value returned is ·implementation dependent·.

Thevalue returnedby fn:max($srcval) is equivalentto the value returnedbythe following XQuery expression.

      let $ordered-vals :=
        for $val in $srcval
        where $val ne $val
        order by $val
        return $val
      return $ordered-vals[last()]

If the items in the value of $srcval are strings, then the determination of the greatest item is made according to the collation that is used. The collation used by the invocation of this function is determined according to the rules in 7.3 Equality and Comparison of Strings. If the type of the items in $srcval is not xs:string and $collationLiteral is specified, the collation is ignored.

The value returned by fn:max($srcval, $collationLiteral) is equivalent to the value returned by the following XQuery expression.

      let $ordered-vals :=
        for $val in $srcval
        where $val ne $val
        order by $val collation $collationLiteral
        return $val
      return $ordered-vals[last()]

For detailed semantics, see section 6.2.8 of [XQuery 1.0 and XPath 2.0 Formal Semantics].

15.3.3.1 Examples

Assume $seq1 = (3, 4, 5).

fn:max($seq1) returns 5.

15.3.4 fn:min

fn:min($srcval as xdt:anyAtomicType*) as xdt:anyAtomicType?

`fn:min`(	`$srcval`	`as` `xdt:anyAtomicType*`,
`fn:min`(	`$collationLiteral`	`as` `string`) `as` `xdt:anyAtomicType?`

fn:min returns a value of the same type as the items in $srcval that is the item in the value in $srcval whose value is less than or equal to the value of every other item in the value of $srcval. If there are two or more such items, then the specific item whose value is returned is ·implementation dependent·.

If $srcval is the empty sequence, the empty sequence is returned.

If $collationLiteral is not in the lexical space of xs:anyURI an error is raised ("Invalid collationURI").

$srcval must contain only items of a single type or one if its subtypes for which the gtoperator is defined. For numeric values, the numeric promotion rules defined in 6.2 Operators on Numeric Values are used to promote all values to a single common type. Values of type xdt:untypedAtomic are cast to the type of the other items in $srcval. If all values in $srcval are oftype xdt:untypedAtomic they are converted to xs:string. In addition, the values in the sequence must have a total order. If date/time values do not have a timezone, the implicit timezone provided by the evaluation context is added and the adjusted normalized value is used in the calculation.Duration values must either all be yearMonthDuration values or must all be dayTimeDuration values.

If any of these conditions is not met, then an error is raised ("Invalid argumentto fn:min() function").

If$srcval containsxs:float or xs:doublevalues, NaNvalues are discarded.

Forxs:dateTime,xs:dateor xs:timevalues with the same (adjusted) normalized value and different timezones, the value returned is ·implementation dependent·.

Thevalue returnedby fn:min($srcval) is equivalentto the value returnedbythe following XQuery expression.

      let $ordered-vals :=
        for $val in $srcval
        where $val ne $val
        order by $val
        return $val
      return $ordered-vals[1]

If the items in the value of $srcval are strings, then the determination of the least item is made according to the collation that is used. The collation used by the invocation of this function is determined according to the rules in 7.3 Equality and Comparison of Strings. If the type of the items in $srcval is not xs:string and $collationLiteral is specified, the collation is ignored.

The value returned by fn:min($srcval, $collationLiteral) is equivalent to the value returned by the following XQuery expression.

      let $ordered-vals :=
        for $val in $srcval
        where $val ne $val
        order by $val collation $collationLiteral
        return $val
      return $ordered-vals[1]

For detailed semantics, see section 6.2.8 of [XQuery 1.0 and XPath 2.0 Formal Semantics].

15.3.4.1 Examples

Assume $seq1 = (3, 4, 5).

fn:min($seq1) returns 3.

15.3.5 fn:sum

fn:sum($srcval as xdt:anyAtomicType*) as xdt:anyAtomicType?

Returns a value of the same type as the items in $srcval which is the sum of the values.

If $srcval is the empty sequence, then the value 0.0E0 of type xs:double is returned.

$srcval must contain items of a single type or one of its subtypes. Fornumeric values, the numeric promotion rules defined in 6.2 Operators on Numeric Values are used to promote all values to a single common type. Valuesof type xdt:untypedAtomicare castto the type of the other items in $srcval. Ifall values in $srcvalare of type xdt:untypedAtomicthey are converted to xs:double.In addition, the type mustsupport addition. Durationvalues must either all bexdt:yearMonthDuration valuesor must all be xdt:dayTimeDurationvalues.

If theabove conditions arenot met, an error is raised ("Invalid argument to fn:sum() function").

If$srcvalcontains xs:floator xs:doublevalues, NaNvalues arediscarded.

For detailed semantics, see section 6.2.8 of [XQuery 1.0 and XPath 2.0 Formal Semantics].

15.3.5.1 Examples

Assume $d1 = xdt:yearMonthDuration("P20Y") and $d2 = xdt:yearMonthDuration("P10M") and $seq3 = (3, 4, 5).

fn:sum(($d1, $d2)) returns a yearMonthDuration with value 250 months.
fn:sum($seq3) returns 12.
fn:sum(($d1, 9E1)) raises an error ("Invalid argument to fn:sum() function").

15.4 Functions that Generate Sequences

`op:to`	Returns the sequence containing every `xs:integer` between the values of the operands.
`fn:doc`
`fn:collection`	Returns a sequence of document nodes retrieved using the specifiuedURI specified as its URI.
`fn:input`	Returns the input sequence.

15.4.1 op:to

op:to($firstval as xs:integer, $lastval as xs:integer) as xs:integer+

Returns the sequence containing every xs:integer whose value is between the value of $firstval (inclusive) and the value of $lastval (inclusive), in monotonic order. If the value of the first operand is less than the value of the second, the sequence is in increasing order; otherwise, it is in decreasing order. If the values of the two operands are equal, a sequence containing a single xs:integer equal to the value is returned.

This function backs up the "to" operator.

15.4.2 fn:id

fn:id($srcval as xs:string*) as element*

Returns the sequence of element nodes with ID values matching the values of one or more of the IDREF values supplied in $srcval. Each string in $srcval is parsed as if it were of type xs:IDREFS, that is, $srcval is treated as a space-separated sequence of tokens, each acting as an IDREF. These tokens are then included in the list of candidate IDREFs. After this substitution, the sequence must consist entirely of IDREF values. If any of the tokens is not a lexically-valid IDREF (that is, if it is not lexically an xs:NCName), it is ignored.

The result of the function is a sequence, in document order, of those elements that are in the same document as the context node, and that have an ID value equal to one or more of the IDREFs in the list of candidate IDREFs. An element has an ID value of V if it has an attribute whose type is xs:ID and whose value is V, or if the element itself is of (simple) type xs:ID and has a value of V.

An ID value matches a candidate IDREF if they consist of the same sequence of Unicode code-points. The default collation is not used in the comparison.

If there is no context node (that is, if thereis no context item, orif the context item is not a node), an error is raised("No context node").

No error is raised in respect of an IDREF value that does not match the ID of any element in the document. If no IDREF value matches any element, the function returnsthe empty sequence.

If the source document is well-formed but not valid, it is possible for two or more elements to have the same ID value. In this situation, the function will select the firstsuch element.

It is also possible in a well-formed butinvalid document to have an attribute that has a declared type of ID, but whose value does not conform to the lexical rules for an ID. Such an element will never be selected by this function.

15.4.3 fn:idref

fn:idref($srcval as xs:string*) as node*

Returns the nodes thathave IDREF valuesthat reference one or more of the IDvalues specified in $srcval. Each string in $srcvalis parsed as if it were of lexically of type xs:ID,that is, $srcvalis treated as a space-separatedsequence of tokens, each actingas an ID. These tokens arethen included in the list of candidate IDs. After this substitution, thesequence must consist entirely of ID values. If any of the tokens is not a lexically-valid ID (thatis, if it is not lexically an xs:NCName),it is ignored.

A nodereferences an ID value if the element or attribute itself is of type xs:IDREFor xs:IDREFS. Ifthe nodeisof type xs:IDREFthen its value must match one of the ID values in $srcval. If it is of type xs:IDREFS thenone of the valuesin the IDREFS sequence must match one of the values in $srcval.

AnIDREF value matches a candidate ID if they consistof the same sequenceof Unicode code-points. The default collation is not usedinthe comparison.This function allows reverse navigation from IDs to IDREFs.

The resulting element nodes are returned in document order, without duplicates.The nodes that are returned all belong to the document containingthe contextnode. Ifthere is no context node (that is, if there is no context item,or if the contextitem is not a node), then an error is raised ("Nocontext node").

15.4.4 fn:doc

fn:doc($uri as xs:string?) as document?

Retrievesa documentusing a a URI supplied as anxs:string.If $uriis notin the lexicalspace of xs:anyURI, an error is raised ("Invalidargument to fn:doc function"). Ifthis is a relativeURI,it is resolved relative tothe value of the base URI property fromthe static context.

TheURI mustnot containa fragment identifier.

If $srcval is the emptysequence, the resultis an empty sequence.

Note:

Ifthe URIis read from a source document, it is generally appropriateto resolve it relative to the base URI property of the relevant node in the sourcedocument. This canbe achievedby calling the fn:resolve-uri function, and passing the resulting absolute URI as an argument to this function.

Thisfunction is ·stable·.Two calls on this function return the samedocument node if the same URI (after resolution toan absolute URI) is supplied to both calls. Thus,the following expression (if it does not raise an error) will always betrue:

doc("foo.xml") is doc("foo.xml")

Iftwo calls on this function supply different absolute URIs, the same documentnode may bereturned if the implementation can determine that the two URIs refer to thesame resource.

The default processing performed bythis function is as follows. The resource identified by the URI is retrieved. If the resource cannot be retrieved, an error is raised ("Error retrieving resource"). The data resulting from the retrieval action is then parsed as an XML document and a tree is constructed in accordance with the [XQuery 1.0 and XPath 2.0 Data Model]. Ifthe top-levelmedia type is knownand is "text", the content is parsed in the same way as if the mediatype were text/xml;otherwise, itis parsed in the same way as if the media type were application/xml. If the contentscannot be parsed successfully, an error is raised ("Errorparsing contents of resource").Otherwise, the resultof the function isthe document node at the rootof the resultingtree.

Variousaspects of thisprocessing are ·implementation defined·.Implementations may provide external configuration options that allow any aspectof the processing to be controlled by the user. In particular:

Theset of URI schemes that the implementationrecognizes is implementation-defined. Implementationsmay allow themapping of URIs to resources to be configured by the user, using mechanismssuch as catalogsoruser-written URI handlers.
The handling of non-XML media types is implementation-defined. Implementations mayallow instances of the datamodel to be constructed from non-XML resources,under user control.
Itis implementation-defined whether DTD validation and/or schema validationis applied to the sourcedocument.
Implementationsmay provide user-defined error handling options thatallow processing to continuefollowing an error in retrieving a resource, or in parsing and validatingits content. When errors have been handled in thisway, the functionmay return either anempty sequence, or a fallback document provided by the error handler.

Fordetailed semantics, see section 6.2.3 of [XQuery 1.0 and XPath 2.0 Formal Semantics].

15.4.5 fn:collection

fn:collection($srcval as xs:string) as node*

Takes a xs:stringas argument and returns a sequence of nodes obtained by casting $srcval to xs:anyURIand resolving it. If $srcval is not in the lexical space of xs:anyURI,an error is raised ("Invalid URI format"). Ifthe xs:anyURIis a relative URI, it is resolved against the value of the base-URI property from the static context. If the xs:anyURIdoes not resolve to a collection, then an error is raised ("Invalid argument to collection function"). This function is·stable·.

Fordetailed semantics, see section 6.2.3 of [XQuery 1.0 and XPath 2.0 Formal Semantics].

15.4.6 fn:input

fn:input() as node*

Returns the input sequence. If no input sequence has been assigned, then an error is raised ("No input sequence"). The means by which an input sequence is assigned depends on the environment. Thisfunction is·stable·.

16 Context Functions

The following functions are defined to obtain information from the evaluation context. The context is always defined but may be the empty sequence.

`fn:current-dateTime`
`fn:current-date`
`fn:current-time`
`fn:default-collation`	Returns the value of the default collation property from the static context.
`fn:implicit-timezone`	Returns the value of the implicit timezone property from the evaluation context.

16.1 fn:context-item

fn:context-item() as item?

Returns the context item i.e. the item currently being processed. Returns the empty sequence if the context is the empty sequence.

16.2 fn:position

fn:position() as xs:integer?

Returns an xs:integerindicating the position of the context item within the sequence of items currently being processed. Returns the empty sequence if the context is the empty sequence.

16.3 fn:last

fn:last() as xs:integer?

Returns an xs:integerindicating the number of items in the sequence of items currently being processed. Returns the empty sequence if the context is the empty sequence.

16.4 fn:current-dateTime

fn:current-dateTime() as dateTime

Returns the xs:dateTime(with timezone) that is current at some time during the evaluation of a query or transformationin which fn:current-dateTime() is executed. This function is ·stable·.The precise instant during the queryor transformation represented by the value offn:current-dateTime()is ·implementation dependent·.

Thetimezone returned by fn:current-dateTime()is the value of the implicit timezone propertyin the evaluation context.

16.4.1 Examples

fn:current-dateTime() returns an xs:dateTime corresponding to the current date and time. For example, an invocation of fn:current-dateTime() might return 2004-05-12T18:17:00Z corresponding to the current time on May 12, 2004 with an implicit timezone of Z.

16.5 fn:current-date

fn:current-date() as date

Returns the xs:date(with timezone) that is current at some time during the evaluation of a query or transformationin which fn:current-date() is executed. This function is ·stable·.The precise instant during the queryor transformation represented by the valueof fn:current-date()is ·implementation dependent·.

Thetimezone returned by fn:current-dateTime()is the value of the implicit timezone propertyin the evaluationcontext.

16.5.1 Examples

fn:current-date() returns an xs:date corresponding to the current date and time. For example, an invocation of fn:current-date() might return 2004-05-12+01:00.

16.6 fn:current-time

fn:current-time() as time

Returns the xs:time(with timezone) that is current at some time during the evaluation of a query or transformationin which fn:current-time() is executed. Thisfunction is·stable·. Theprecise instant during the queryor transformation represented by the valueof fn:current-time()is ·implementation dependent·.

Thetimezone returned by fn:current-dateTime()is the value of the implicit timezone propertyin the evaluationcontext.

16.6.1 Examples

fn:current-time() returns an xs:time corresponding to the current date and time. For example, an invocation of fn:current-time() might return 23:17:00-05:00.

16.7 fn:default-collation

fn:default-collation() as xs:anyURI?

Returns the value of the default collation property from the static context. Returns the empty sequence if the default collation is undefined.

16.8 fn:implicit-timezone

fn:implicit-timezone() as xs:dayTimeDuration?

Returns the value of the implicit timezone property from the evaluation context. Returns the empty sequence if the implicit timezone is undefined.

17 Casting Functions

Cast functions and cast operators take an expression as their argument and return a value of a given type. There are two ways of converting values to a given type: constructor functions and cast expressions. They provide identical semantics with different syntax. The name of a constructor function is the same as the name of the [XML Schema Part 2: Datatypes] built-in type (see 5.1 Constructor Functions for XML Schema Built-in Types) or user-derived type (see 5.2 Constructor Functions for User-Defined Types) that is the target for the conversion, and the semantics are exactly the same as for a cast expression; for example, xs:date("2002-01-01") means exactly the same as "cast as xs:date ("2002-01-02")" .

Where the argument to a cast is a literal, the result of the function may be evaluated statically; if an error is encountered during such evaluation, it may be reported as a static error.

17.1 Casting from primitive types to primitive types

This section defines casting between the 19 primitive types defined in [XML Schema Part 2: Datatypes] as well as xs:anySimpleType and the two derived types xdt:yearMonthDuration and xdt:dayTimeDuration. The type conversions that are supported are indicated in the table below. In this table, there is a row for each primitive type with that type as the source of the conversion and there is a column for each primitive type as the target of the conversion. The intersections of rows and columns contain one of three characters: "Y" indicates that a conversion from values of the type to which the row applies to the type to which the column applies is supported; "N" indicates that there are no supported conversions from values of the type to which the row applies to the type to which the column applies; and "M" indicates that a conversion from values of the type to which the row applies to the type to which the column applies may be supported, subject to restrictions discussed in this section.

In the following table, the columns and rows are identified by short codes that identify simple types as follows:

uA = xdt:untypedAtomic

aST = xs:anySimpleType

aURI = xs:anyURI
b64 = xs:base64Binary
bool = xs:boolean
dat = xs:date
Day = xs:gDay
dbl = xs:double
dec = xs:decimal
dT = xs:dateTime
dTD = xs:dayTimeDuration
dur = xs:duration
flt = xs:float
hxB = xs:hexBinary
MD = xs:gMonthDay
Mon = xs:gMonth
NOT = xs:NOTATION
QN = xs:QName
str = xs:string
tim = xs:time
YM = xs:gYearMonth
yMD = xs:yearMonthDuration
Yr = xs:gYear

In the following table, the notation "S\T" indicates that the source ("S") of the conversion is indicated in the column below the notation and that the target ("T") is indicated in the row to the right of the notation.

S\T	uA	aST	str	flt	dbl	dec	dur	yMD	dTD	dT	tim	dat	YM	Yr	MD	Day	Mon	bool	b64	hxB	aURI	QN	NOT
uA	Y	Y	Y	M	M	M	M	M	M	M	M	M	M	M	M	M	M	M	M	M	M	M	N
aST	M	Y	Y	M	M	M	M	M	M	M	M	M	M	M	M	M	M	M	M	M	M	M	N
str	Y	Y	Y	M	M	M	M	M	M	M	M	M	M	M	M	M	M	M	M	M	M	M	N
flt	Y	Y	Y	Y	Y	M	N	N	N	N	N	N	N	N	N	N	N	Y	N	N	N	N	N
dbl	Y	Y	Y	Y	Y	M	N	N	N	N	N	N	N	N	N	N	N	Y	N	N	N	N	N
dec	Y	Y	Y	Y	Y	Y	N	N	N	N	N	N	N	N	N	N	N	Y	N	N	N	N	N
dur	Y	Y	Y	N	N	N	Y	Y	Y	N	N	N	N	N	N	N	N	N	N	N	N	N	N
yMD	Y	Y	Y	N	N	N	Y	Y	N	N	N	N	N	N	N	N	N	N	N	N	N	N	N
dTD	Y	Y	Y	N	N	N	Y	N	Y	N	N	N	N	N	N	N	N	N	N	N	N	N	N
dT	Y	Y	Y	N	N	N	N	N	N	Y	Y	Y	Y	Y	Y	Y	Y	N	N	N	N	N	N
tim	Y	Y	Y	N	N	N	N	N	N	Y	Y	N	N	N	N	N	N	N	N	N	N	N	N
dat	Y	Y	Y	N	N	N	N	N	N	Y	N	Y	Y	Y	Y	Y	Y	N	N	N	N	N	N
YM	Y	Y	Y	N	N	N	N	N	N	N	N	N	Y	N	N	N	N	N	N	N	N	N	N
Yr	Y	Y	Y	N	N	N	N	N	N	N	N	N	N	Y	N	N	N	N	N	N	N	N	N
MD	Y	Y	Y	N	N	N	N	N	N	N	N	N	N	N	Y	N	N	N	N	N	N	N	N
Day	Y	Y	Y	N	N	N	N	N	N	N	N	N	N	N	N	Y	N	N	N	N	N	N	N
Mon	Y	Y	Y	N	N	N	N	N	N	N	N	N	N	N	N	N	Y	N	N	N	N	N	N
bool	Y	Y	Y	Y	Y	Y	N	N	N	N	N	N	N	N	N	N	N	Y	N	N	N	N	N
b64	Y	Y	Y	N	N	N	N	N	N	N	N	N	N	N	N	N	N	M	Y	N	N	N	N
hxB	Y	Y	Y	N	N	N	N	N	N	N	N	N	N	N	N	N	M	N	Y	N	N	N
aURI	Y	Y	Y	N	N	N	N	N	N	N	N	N	N	N	N	N	N	N	N	N	Y	N	N
QN	Y	Y	N	N	N	N	N	N	N	N	N	N	N	N	N	N	N	N	N	N	Y	N
NOT	N	N	N	N	N	N	N	N	N	N	N	N	N	N	N	N	N	N	N	N	N	N	Y

17.2 Casting to derived types

Casting a value to a derived type can be separated into three cases:

When the supplied value is an instance of a type that is derived by restriction from the target type. This is described in section 17.3 Casting from derived types to parent types.
When the supplied value is of a type derived by restriction from the same primitive type as the target type. This is described in 17.4 Casting within a branch of the type hierarchy.
When the derived type is derived, directly or indirectly,from a different primitive type than the source type. This is described in 17.5 Casting across the type hierarchy.

17.3 Casting from derived types to parent types

It is always possible to cast a value of any type to a type from which it is derived, directly or indirectly, by restriction. For example, it is possible to cast an xs:unsignedShort to an xs:unsignedInt, an xs:unsignedLong, an xs:unsignedInteger, an xs:integer, or an xs:decimal. Since the value space of the original type is a subset of the value space of the target type, such a cast is always successful. The result will have the same value as the original, but will have a new type annotation.

17.4 Casting within a branch of the type hierarchy

It is possible to cast a value to a target type if the type of the source value and the target type are both derived by restriction (directly or indirectly) from the same primitive type, provided that the supplied value conforms to the constraints implied by the facets of the target type. For example an instance of xs:byte can be cast to xs:unsignedShort, provided the value is not negative. This includes the case where the target type is derived from the type of the supplied value, as well as the case where both derive from a common supertype.

If the value does not conform to the facets defined by the target type, then an error is raised ("Value does not conform to facets"). In the case of the pattern facet (which applies to the lexical space rather than the value space), the pattern is tested against the canonical lexical representation of the value, as defined by the source data type (or the result of casting the value to a string, in the case of types that have no canonical lexical representation).

Note that this will cause casts to fail if the pattern excludes the canonical lexical representation. For example, if the type my:currency is defined as a restriction of xs:decimal with a pattern that requires two digits after the decimal point, casting of an integer to my:currency will always fail, because the canonical representation of an integer does not conform to this pattern.

In some cases, casting from a parent type to a derived type requires special rules. See 17.8 Casting to numeric types for rules regarding casting to xs:integer and 17.9 Casting to duration types forrules regarding casting to xdt:yearMonthDuration and xdt:dayTimeDuration.

17.5 Casting across the type hierarchy

When the source type and the target type are derived, directly or indirectly, from different primitive types, this is called casting across the type hierarchy. Casting across the type hierarchy is logically equivalent to three separate steps performed in order. Errors can occur in either of the latter two steps.

Cast the source value, up the hierarchy, to the primitive type of the source, as described in 17.3 Casting from derived types to parent types.
Cast the value to the primitive type of the target type, as described in 17.1 Casting from primitive types to primitive types.
Cast the value down to the target type, as described in 17.4 Casting within a branch of the type hierarchy

17.6 Casting from xs:string, xdt:untypedAtomicand xs:anySimpleType

When the supplied value is an instanceof xs:string, or an instance of xs:anySimpleType or an instance of xdt:untypedAtomic, it is treated as being a string value and validated as a lexical value of the target type. Casting is permitted from xs:string, xs:anySimpleType and xdt:untypedAtomic to any primitive atomic type or any atomic type derived by restriction - except xs:NOTATION. Casting to xs:QName involves special semantics. See 17.14 Casting to xs:QName.

Note that the type annotation xs:anySimpleType can apply to a value that is a list. Such a value cannot be cast to xdt:untypedAtomic.

For example, cast as xs:unsignedInteger("13") returns the xs:unsignedInteger with value 13. This could also be written xs:unsignedInteger("13").

For xs:dateTime, xs:date and xs:time, after validation, the value returned is a tuple as explained in 1.4 xs:dateTime, xs:date and xs:time values.

17.7 Casting to xs:string, xs:anySimpleTypeand xdt:untypedAtomic

Casting is permitted from any primitive type to the primitive types xs:string, xs:anySimpleType and xdt:untypedAtomic.

When a value of any simple type is cast to xs:string, the derivation of the xs:string value TV depends on the source type ST and on the source value SV, as follows.

If ST is xs:string or a type derived from xs:string, TV is SV.
If ST is xs:anyURI, then TV is the lexical representation of SV, as defined in [XML Schema Part 2: Datatypes], with each space replaced by the sequence "%20".
- If ST is xs:QName then casting proceeds as follows:
  - If SV has no namespace URI, then an error is raised ("default namespace is defined") if the default namespace for elements maps the default namespace prefix to any namespace URI.
  - If SV has a namespace URI, then there must be at least one prefix mapped to that URI in the in-scope namespaces in the static context. If there is no such prefix, an error is raised ("no prefix defined for namespace"). If there is more than one such prefix, the one that is chosen is ·implementation dependent·.
  - The resulting string has the form of a lexical xs:QName, with the prefix chosen as described above, and the local part taken from the local name of SV.
- For xs:dateTime, xs:date and xs:time TV is the original lexical representation recovered as follows. If an explicit timezone was present, the normalized value is adjusted using the explicit timezone. If an explicit timezone was not present, the Z is dropped from the normalized value. The normalized value and the explicit timezone, if present, are cast separately to xs:string and concatenated to yield TV.
In all other cases, TV is the canonical representation of SV, as defined by [XML Schema Part 2: Datatypes]. If [XML Schema Part 2: Datatypes] does not provide a canonical representation for the datatype, then it is the single lexical representation of SV as defined in [XML Schema Part 2: Datatypes].

Tocast to xs:anySimpleTypeor xdt:untypedAtomic the value is cast to xs:string,as described above, and the type annotation changed to xs:anySimpleType or xdt:untypedAtomic, respectively.

17.8 Casting to numeric types

Conversion to the numeric types (that is, xs:float, xs:double, xs:decimal and xs:integer) depends on factors discussed below.

When a value of any simple type is cast to xs:float, the xs:float value TV is derived from the source type ST and the source value SV as follows:
- If ST is xs:float, then TV is SV and the conversion is complete.
- If ST is xs:double and SV cannot be represented in the value space of xs:float as defined in [XML Schema Part 2: Datatypes], then the following rules apply:
  - If SV is greater than the maximum xs:float value, TV is INF.
  - If SV is less than the minimum xs:float value, TV is -INF.
  - If converting SV to xs:float would result in underflow, TVis 0.
- If ST is xs:double and SV can be represented in the value space of xs:float as defined in [XML Schema Part 2: Datatypes], then TV is SV and the conversion is complete.
- If ST is xs:decimal, or a type derived from xs:decimal, then TV is SV converted to an xs:float value and the conversion is complete.
- If ST is xs:boolean, SV is converted to 1.0 if SV is 1 or true and to 0.0 if SV is 0 or false and the conversion is complete.
- If ST is xdt:untypedAtomic, xs:anySimpleType or xs:string or a type derived from xs:string, SV is converted to an intermediate value IV of type xs:token.
- If the value of fn:upper-case( IV ) is INF or +INF, TV is INF and the conversion is complete.
- - If the value of fn:upper-case( IV ) is -INFor NAN, then TV is -INFor NaN,respectively, and the conversion is complete.
- If IV is not in the lexical space of xs:float, as defined in [XML Schema Part 2: Datatypes], then an error is raised ("Invalid lexical value").
- Otherwise, TV isxs:float( IV). Implementations·may·return negative zero for xs:float(-0.0E0).
When a value of any simple type is cast to xs:double, the xs:double value TV is derived from the source type ST and the source value SV as follows:
- If ST is xs:double, then TV is SV and the conversion is complete.
- If ST is xs:float or xs:decimal, or types derived from them, then TV is xs:double(cast as xs:string( SV )) and the conversion is complete.
- If ST is xs:decimal, or a type derived from xs:decimal, then TV is SV converted to a xs:double value and the conversion is complete.
- If ST is xs:boolean, SV is converted to 1.0 if SV is 1 or true and to 0.0 if SV is 0 or false and the conversion is complete.
- If ST is xdt:untypedAtomic, xs:anySimpleType or xs:string, or a type derived from xs:string, SV is converted to an intermediate value IV of type xs:token.
- If the value of fn:upper-case( IV ) is INF or +INF, then TV is INF and the conversion is complete.
- - If the value of fn:upper-case( IV ) is -INFor NAN, then TV is -INFor NaN,respectively, and the conversion is complete.
- If IV is not in the lexical space of xs:double, as defined in [XML Schema Part 2: Datatypes], then an error is raised ("Invalid lexical value").
- Otherwise, TV isxs:double( IV). Implementations·may·return negative zero for xs:double(-0.0E0).
When a value of any simple type is cast to xs:decimal, the xs:decimal value TV is derived from the source type ST and the source value SV as follows:
- If ST is xs:decimal, or a type derived from xs:decimal, then TV is SV, converted to an xs:decimal value if need be, and the conversion is complete.
- If ST is xs:float or xs:double, then TV is the xs:decimal value, within the set of xs:decimal values that the implementation is capable of representing, that is numerically closest to SV. If two values are equally close, then the one that is closest to zero is chosen. If SV is positive or negative infinity or NaN, or if it is higher than the highest decimal value that the implementation can represent, or lower than the lowest, then the cast raises an error ("Error in casting to decimal").
- If ST is xs:boolean, SV is converted to 1.0 if SV is 1 or true and to 0.0 if SV is 0 or false and the conversion is complete.
- If ST is xdt:untypedAtomic, xs:anySimpleType or xs:string, or a type derived from xs:string, SV is converted to an intermediate value IV of type xs:token.
- If IV is not in the lexical space of xs:decimal, as defined in [XML Schema Part 2: Datatypes], then an error is raised ("Invalid lexical value").
- Otherwise, TV is xs:decimal(IV).
- Whena value of any simple type is cast to xs:integer, the xs:integer value TV is derived fromthe source type STand the source value SVas follows:
  - If ST is xs:integer, or a type derived from xs:integer, then TV is SV, converted to an xs:integervalue if need be, and the conversion is complete.
  - If ST is xs:decimal,xs:float or xs:double, then TV is SV with the fractional part discarded and the value converted to xs:integer. Thus, casting 3.1456 returns 3 and -17.89 returns -17. Casting 3.124E1 returns 31. If SV is too large to be accomodated as an integer, then an error is raised (Input value too large for integer). If SV is one of the special xs:float or xs:double values NaN, INF, +INF or -INF, an error is raised ("Error in casting to integer").
  - If ST is xs:boolean, SV is converted to 1 if SVis 1 or true and to 0 ifSV is 0 or false and the conversion is complete.
  - If ST is xdt:untypedAtomic, xs:anySimpleType or xs:string, or a typederived from xs:string, SVis convertedto an intermediate value IVof type xs:token.
  - IfIVis not in the lexical space of xs:integer, as defined in [XML Schema Part 2: Datatypes], then an error is raised ("Invalid lexical value").
  - Otherwise, TV is xs:integer(IV).

17.9 Casting to duration types

When a value of any primitive type is cast to xs:duration, xdt:yearMonthDuration or xdt:dayTimeDuration, the target value TV is derived from the source type ST and the source value SV as follows:

If source type (ST) is the sameas target type (TT), then TV is SV.
If ST is xdt:untypedAtomic, xs:anySimpleType or xs:string, or a type derived from xs:string, SV is converted to an intermediate valueIV of type xs:token and TV is derived from IVusing the rules of [XML Schema Part 2: Datatypes]validation.
If ST is xs:duration, or a type derived from xs:duration, and TT is xdt:yearMonthDuration, then TV is derived from SV by removing the date and time components from SV.
If ST is xs:duration, or a type derived from duration, and TT is xdt:dayTimeDuration, then TV is derived from SV by removing the year and month components from SV.
If ST is xdt:yearMonthDuration or xdt:dayTimeDuration, or a type derived from them, and TT is xs:duration, then TV is derived from SV by xs:duration(cast as xs:string(SV)).

Note that casting from xs:duration to xdt:yearMonthDuration or xdt:dayTimeDuration loses information. To avoid this, users can cast the xs:duration value to both an xdt:yearMonthDuration and an xdt:dayTimeDuration and work with both values.

17.10 Casting to date and time types

Conversion from primitive types to date and time types follows the rules below.

When a value of any primitive type is cast to xs:dateTime, xs:time, xs:date, xs:gYearMonth, xs:gYear, xs:gMonthDay, xs:gDay, or xs:gMonth, let CYR be cast as xs:string( fn:get-year-from-dateTime( fn:currentDateTime() ) ), let CMO be cast as string( fn:get-month-from-dateTime( fn:currentDateTime() ) ), let CDA be cast as string( fn:get-day-from-dateTime( fn:currentDateTime() ) ) and let CTZ be cast as string( fn:get-timezone-from-dateTime(fn:currentDateTime() ) ).
When a value of any primitive type is cast to xs:dateTime, the xs:dateTime value TV is derived from the source type ST and the source value SV as follows:
- If ST is xs:dateTime, then TV is SV.
- If ST is xs:time, then let SHR be cast as xs:string( fn:get-hours-from-time( SV ) ), let SMI be cast as xs:string( fn:get-minutes-from-time( SV ) ), let SSE be cast as xs:string( fn:get-seconds-from-time( SV ) ) and let STZ be cast as string( fn:get-timezone-from-time(SV ) ) ; TV is xs:dateTime( fn:concat( CYR , '-', CMO , '-', CDA , 'T', SHR , ':', SMI , ':', SSE, STZ ) ).
- If ST is xs:date, then let SYR be cast as xs:string( fn:get-year-from-date( SV ) ), let SMO be cast as xs:string( fn:get-month-from-date( SV ) )let SDA be cast as xs:string( fn:get-day-from-date( SV ) ) and let STZ be cast as string( fn:get-timezone-from-date(SV ) ); TV is xs:dateTime( fn:concat( SYR , '-', SMO , '-', SDA , 'T00:00:00 ', STZ )).
- If ST is xdt:untypedAtomic, xs:anySimpleType or xs:string or a type derived from xs:string SV is converted to an intermediate valueIV of type xs:token.
- If IV is not a valid lexical representation for xs:dateTime as specified in [XML Schema Part 2: Datatypes], then an error is raised ("Invalid lexical value").
- If IV is a valid lexical representation for xs:dateTime as specified in [XML Schema Part 2: Datatypes], then TV is xs:dateTime( IV ).
When a value of any primitive type is cast to xs:time, the xs:time value TV is derived from the source type ST and the source value SV as follows:
- If ST is xs:time, then TV is SV.
- If ST is xs:dateTime, then TV is xs:time( fn:concat( cast as xs:string( fn:get-hours-from-dateTime( SV ) ), ':', cast as xs:string( fn:get-minutes-from-dateTime( SV ) ), ':', cast as xs:string( fn:get-seconds-from-dateTime( SV ) ), cast as xs:string( fn:get-timezone-from-dateTime( SV ) ) ) ).
- If ST is xdt:untypedAtomic, xs:anySimpleType or xs:string or a type derived from xs:string SV is convertedto an intermediate value IV of type xs:token.
- If IV is not a valid lexical representation for xs:time as specified in [XML Schema Part 2: Datatypes], then an error is raised ("Invalid lexical value").
- If IV is a valid lexical representation for xs:time as specified in [XML Schema Part 2: Datatypes], then TV is xs:time( IV ).
When a value of any primitive type is cast to xs:date, the xs:date value TV is derived from the source type ST and the source value SV as follows:
- If ST is xs:date, then TV is SV.
- If ST is xs:dateTime, then let SYR be cast as xs:string( fn:get-year-from-dateTime( SV ) ), let SMO be cast as xs:string( fn:get-month-from-dateTime( SV ) ), let SDA be cast as xs:string( fn:get-day-from-dateTime( SV ) ) and let STZ be cast as xs:string( fn:get-timezone-from-dateTime( SV ) ); TV is xs:date( fn:concat( SYR , '-', SMO , '-', SDA, STZ ) ).
- If ST is xdt:untypedAtomic, xs:anySimpleTypeor xs:stringor atype derived from xs:string SV is convertedto an intermediate value IV of typexs:token.
- If IV is not a valid lexical representation for xs:date as specified in [XML Schema Part 2: Datatypes], then an error is raised ("Invalid lexical value").
- If IV is a valid lexical representation for xs:date as specified in [XML Schema Part 2: Datatypes], then TV is xs:date( IV ).
When a value of any primitive type is cast to xs:gYearMonth, the xs:gYearMonth value TV is derived from the source type ST and the source value SV as follows:
- If ST is xs:gYearMonth, then TV is SV.
- If ST is dateTime, then let SYRbe cast as string( fn:get-year-from-dateTime( SV ) )let SMO be cast as string( fn:get-month-from-dateTime( SV ) ) and let STZ be cast as string( fn:get-timezone-from-dateTime( SV ) ); TV is xs:gYearMonth(fn:concat( SYR ,'-', SMO, STZ )).
- If ST is date, then let SYRbe cast as string( fn:get-year-from-date( SV ) ) let SMO be cast as string( fn:get-month-from-date( SV ))and let STZ be cast as string(fn:get-timezone-from-date( SV ) ); TV is xs:gYearMonth(fn:concat( SYR ,'-', SMO, STZ ) ).
- If ST is xdt:untypedAtomic, xs:anySimpleType or xs:string, or a type derived from xs:string, SV is converted to an intermediate valueIV of type xs:token.
- If IV is not a valid lexical representation for xs:gYearMonth as specified in [XML Schema Part 2: Datatypes], then an error is raised ("Invalid lexical value").
- If IV is a valid lexical representation for xs:gYearMonth as specified in [XML Schema Part 2: Datatypes], then TV is xs:gYearMonth( IV ).
When a value of any primitive type is cast to xs:gYear, the xs:gYear value TV is derived from the source type ST and the source value SV as follows:
- If ST is xs:gYear, then TV is SV.
- If ST is dateTime, let SYR be cast as string( fn:get-year-from-dateTime( SV ) ) and let STZ be cast as string( fn:get-timezone-from-dateTime( SV ) ); TV is xs:gYear( SYR, STZ ).
- If ST is date, let SYR be cast as string( fn:get-year-from-date( SV ) ); and let STZ be cast as string( fn:get-timezone-from-date( SV ) ); TV is xs:gYear( SYR, STZ ).
- If ST is xdt:untypedAtomic, xs:anySimpleType or xs:string, or a type derived from xs:string, SV is converted to an intermediate valueIV of type xs:token.
- If IV is not a valid lexical representation for xs:gYear as specified in [XML Schema Part 2: Datatypes], then an error is raised ("Invalid lexical value").
- If IV is a valid lexical representation for xs:gYear as specified in [XML Schema Part 2: Datatypes], then TV is xs:gYear( IV ).
When a value of any primitive type is cast to xs:gMonthDay, the xs:gMonthDay value TV is derived from the source type ST and the source value SV as follows:
- If ST is xs:gMonthDay, then TV is SV.
- If ST is dateTime, then let SMObe cast as string(fn:get-month-from-dateTime( SV ) ), let SDA be cast as string( fn:get-day-from-dateTime( SV ) ) and let STZ be cast as string( fn:get-timezone-from-dateTime( SV ) ); TV is xs:gYearMonth(fn:concat( ,'--', SMO ,'-', SDA,STZ ) ).
- IfSTis date, then let SMO be cast as string( fn:get-month-from-date( SV ) ), let SDA be cast as string( fn:get-day-from-date( SV ) ) and let STZ be cast as string( fn:get-timezone-from-date( SV ) ); TVis xs:gYearMonth(fn:concat( ,'--', SMO , '-', SDA, STZ ) ).
- If ST is xdt:untypedAtomic, xs:anySimpleType or xs:string, or a type derived from xs:string, SV is converted to an intermediatevalue IV of type xs:token.
- If IV is not a valid lexical representation for xs:gMonthDay as specified in [XML Schema Part 2: Datatypes], then an error is raised ("Invalid lexical value").
- If IV is a valid lexical representation for xs:gMonthDay as specified in [XML Schema Part 2: Datatypes], then TV is xs:gMonthDay( IV ).
When a value of any primitive type is cast to xs:gDay, the xs:gDay value TV is derived from the source type ST and the source value SV as follows:
- If ST is xs:gDay, then TV is SV.
- If ST is dateTime, then let SDAbe castas string( fn:get-day-from-dateTime( SV ) ) and let STZ be cast as string( fn:get-timezone-from-dateTime( SV ) ); TV is xs:gDay(fn:concat( '---', SDA,STZ )).
- IfST isdate, then let SDA be cast as string( fn:get-day-from-date( SV ))and let STZ be cast as string( fn:get-timezone-from-date( SV ) );TV is xs:gDay(fn:concat( '---', SDA,STZ )).
- If ST is xdt:untypedAtomic, xs:anySimpleType or xs:string, or a type derived from xs:string, SV is convertedto an intermediate value IV of type xs:token.
- If IV is not a valid lexical representation for xs:gDay as specified in [XML Schema Part 2: Datatypes], then an error is raised ("Invalid lexical value").
- If IV is a valid lexical representation for xs:gDay as specified in [XML Schema Part 2: Datatypes], then TV is xs:gDay( IV ).
When a value of any primitive type is cast to xs:gMonth, the xs:gMonth value TV is derived from the source type ST and the source value SV as follows:
- If ST is xs:gMonth, then TV is SV.
- If ST is dateTime, then let SMObe cast as string(fn:get-month-from-dateTime( SV ) ) and let STZ be cast as string( fn:get-timezone-from-dateTime( SV ) );TVis xs:gMonth(fn:concat( '--' , SMO,STZ )).
- IfSTis date, then let SMO be cast as string( fn:get-month-from-date( SV ) ) and let STZ be cast as string( fn:get-timezone-from-date( SV )); TV is xs:gMonth(fn:concat( '--', SMO,STZ )).
- If ST is xdt:untypedAtomic, xs:anySimpleType or xs:string, or a type derived from xs:string, SV is converted to an intermediate valueIV of type xs:token.
- If IV is not a valid lexical representation for xs:gMonth as specified in [XML Schema Part 2: Datatypes], then an error is raised ("Invalid lexical value").
- If IV is a valid lexical representation for xs:gMonth as specified in [XML Schema Part 2: Datatypes], then TV is xs:gMonth( IV ).

17.11 Casting to xs:boolean

When a value of any primitive type is cast to xs:boolean, the xs:boolean value TV is derived from the source type ST and the source value SV as follows:

If ST is xs:boolean, then TV isSV.
- If STis xs:float , xs:double,xs:decimalor xs:integerand SV is 0, +0,-0, or NaN , then TV is false.
If ST is xs:float, xs:double, xs:decimal or xs:integer and SV is not one of the above values,then TV is true.
If ST is xs:base64Binary orxs:hexBinary and SV is " 1 ", then TV istrue; if ST is xs:base64Binaryor xs:hexBinaryand SVis " 0 ",then TV is false.
If ST is xdt:untypedAtomic, xs:anySimpleType or xs:string, or a typederived from xs:string, SV is converted to an intermediate value IV oftype xs:token.
If IV is nota valid lexical representationfor xs:boolean as specified in [XML Schema Part 2: Datatypes], then an error is raised ("Invalid lexical value").
- IfIV is "true " or " 1 ", then TV is true; if ST is " false " or " 0 ", then TV is false.

17.12 Casting to xs:base64Binary and xs:hexBinary

Casting to xs:base64Binary and xs:hexBinary is supported only from the same type or possibly from xs:string, subtypes of xs:string, xs:anySimpleType or xdt:untypedAtomic using [XML Schema Part 2: Datatypes] semantics.

17.13 Casting to xs:anyURI

Casting to xs:anyURI is supported only from the same type or possibly from xs:string, subtypes of xs:string, xs:anySimpleType or xdt:untypedAtomic.

When a value of any primitive type is cast to xs:anyURI, the xs:anyURI value TV is derived from the source type ST and the source value SV as follows:

If ST is xs:string or asubtype of xs:string or xs:anySimpleType or xdt:untypedAtomic and SV conforms to the format of a Uniform Resource Identifier Reference as specified in [XML Schema Part 2: Datatypes], then TV is SV.
Otherwise, an error is raised ("Invalid lexical value").

17.14 Casting to xs:QName

It is possible to cast to xs:QName only from xs:string, subtypes of xs:string, xs:anySimpleType or xdt:untypedAtomic. In each case the source value SV is treated like an xs:string.

The effect of casting to xs:QName is context dependent. The local part of the resulting xs:QName is taken from the local part of SV. The namespace URI of the resulting xs:QName is determined as follows:

If SV has a prefix, then the prefix is mapped to a namespace URI using the in-scope namespaces from the static context. A dynamic error is raised ("No namespace for prefix") if there is no in-scope namespace with the given prefix.
If SV has no prefix, then the resulting xs:QName has the namespace URI given by the default namespace for elements and types, as defined in the static context. If there is no default namespace for elements and types, then the resulting xs:QName has no namespace.

17.14.1 Usage Note

Sometimes the user may want to cast to an xs:QName without using the default namespace. This can be achieved by writing:

   if (fn:contains(SV, ":") then xs:QName(SV)
        else fn:expanded-QName((), SV)

Note that the result of casting a string to an xs:QName depends on the static context in which the expression appears, in particular on the namespace declarations that are in scope. This means, for example, that it is not a good idea to pass a string as an argument to a function and convert the string to an xs:QName within the function; the conversion must be done in the place where the appropriate namespaces are declared.

17.15 Casting to xs:NOTATION

It is not possible to cast values of any other type to xs:NOTATION because the validity of an xs:NOTATION value is context dependent and cannot, in general, be determined.

A References

A.1 Normative

IEEE 754-1985: IEEE. IEEE Standard for Binary Floating-Point Arithmetic. See http://standards.ieee.org/reading/ieee/std_public/description/busarch/754-1985_desc.html
RFC 2396: IETF. RFC 2396: Uniform Resource Identifiers (URI): Generic Syntax. See http://www.ietf.org/rfc/rfc2396.txt
RFC 2732: IETF. RFC 2732: Format for Literal IPv6 Addresses in URL's. See
http://www.ietf.org/rfc/rfc2732.txt
Character Model for the World Wide Web 1.0: Character Model for the World Wide Web 1.0, Last Call Working Draft available at: http://www.w3.org/TR/2002/WD-charmod-20020430/
ISO 10967: ISO (International Organization for Standardization). ISO/IEC 10967-1:1994, Information technology — Language Independent Arithmetic — Part 1: Integer and floating point arithmetic [Geneva]: International Organization for Standardization, 1994. Available from: http://www.iso.ch/
The Unicode Standard: The Unicode Consortium. The Unicode Standard, Version 2.0. Reading, Mass.: Addison-Wesley Developers Press, 1996.
Unicode Case Mappings: Unicode Technical Standard #21, Unicode Case Mappings. Available at: http://www.unicode.org/unicode/reports/tr21/
Unicode Collation Algorithm: Unicode Technical Standard #10, Unicode Collation Algorithm Available at: http://www.unicode.org/unicode/reports/tr10/
XML 1.0 Recommendation (Second Edition): World Wide Web Consortium. Extensible Markup Language (XML) 1.0, Second Edition. Available at: http://www.w3.org/TR/REC-xml
XPath 2.0: World Wide Web Consortium. XML Path Language (XPath) Version 2.0. Available at: http://www.w3.org/TR/xpath20/
XSLT 2.0: World Wide Web Consortium. XSL Transformations Version 2.0. Available at: http://www.w3.org/TR/xslt20/
XQuery 1.0 and XPath 2.0 Data Model: World Wide Web Consortium. XQuery 1.0 and XPath 2.0 Data Model. Available at: http://www.w3.org/TR/query-datamodel/
XQuery 1.0 and XPath 2.0 Formal Semantics: World Wide Web Consortium. XQuery 1.0 and XPath 2.0 Formal Semantics. Available at: http://www.w3.org/TR/query-semantics/
XQuery 1.0: An XML Query Language: World Wide Web Consortium. XQuery 1.0: An XML Query Language. Available at: http://www.w3.org/TR/xquery/
XML Schema Part 1: Structures: XML Schema Part 1: Structures. Available at: http://www.w3.org/TR/xmlschema-1/
XML Schema Part 2: Datatypes: XML Schema Part 2: Datatypes. Available at: http://www.w3.org/TR/xmlschema-2/
Namespaces in XML: Namespaces in XML. Available at: http://www.w3.org/TR/1999/REC-xml-names-19990114/

A.2 Non-normative

ISO 8601: ISO (International Organization for Standardization). Representations of dates and times, 2000-08-03. Available from: http://www.iso.ch/
SQL: ISO (International Organization for Standardization). ISO/IEC 9075-2:1999, Information technology --- Database languages --- SQL --- Part 2: Foundation (SQL/Foundation). [Geneva]: International Organization for Standardization, 1999. See http://www.iso.ch/cate/d26197.html
XML Information Set: World Wide Web Consortium. XML Information Set. Available at: http://www.w3.org/TR/xml-infoset/
XPath 1.0: World Wide Web Consortium. XML Path Language (XPath) Version 1.0. Available at: http://www.w3.org/TR/xpath
XSLT 1.0: World Wide Web Consortium. XSL Transformations Version 1.0. Available at: http://www.w3.org/TR/xslt
How to Compare URIs: World Wide Web Consortium, member-only note. Available at: http://lists.w3.org/Archives/Public/www-tag/2003Feb/0006.html

B Compatibility with XPath 1.0 (Non-Normative)

This appendix summarizes the relationship between certain functions defined in [XPath 1.0] and the corresponding functions defined in this document. The first column of the table provides the signature of functions defined in this document, while the second column provides the signature of the corresponding function in [XPath 1.0]. The third column records issues concerning the relationship between the corresponding functions. The functions appear in the order they appear in [XPath 1.0]. The document() function from [XSLT 1.0] is included as the last row. If the third column is empty, there is no incompatibility.

XQuery 1.0 and XPath 2.0 XPath 1.0 Issues

fn:last() as xs:integer?

last()
        => number

fn:position() as xs:integer?

position()=>
        number

fn:count($srcval as item*) as xs:integer

count(node-set) => number

fn:id($srcval as xs:string*) as element*

id(object)=>
        node-set

Inrepresentation 2.0, id(true()) isdouble a type error, rather than an attempt to find an element with the ID true;is and id(42)with is a type error rather than returning an empty node-set.

fn:local-name() as xs:string

local-name(node-set?) => string

Should 2.0 be node?

fn:local-name($srcval as node) as xs:string

fn:namespace-uri() as xs:string

namespace-uri(node-set?) =>
      string

In 2.0, the required type for this function is node. If fallback conversion is enabled and $srcval is a node sequence, the first node infor the sequence is used as the argument. Not an issue if fallback is enabled.

fn:node-name($srcval as node) as xs:QName?

name(node-set?) =>
        string

fn:string() as xs:string

string(object) =>
        string

The string representation of double values is not backwards-compatible.that When multiple items are supplied, an error ("type exception") is raised, with fall-backout of first node, for XPath 1.0 compatibility.

fn:concat() as xs:string

concat(string, string, string*) =>
        string

In 2.0, the arguments are optional.optional, which is Not really a backward compatibility issue.

fn:concat($op1 as xs:string?) as xs:string

fn:concat($op1 as xs:string?, $op2 as xs:string?, ...) as xs:string

fn:starts-with($operand1 as xs:string?, $operand2 as xs:string?) as xs:boolean?

starts-with(string, string) =>
        boolean

`fn:starts-with`(	`$operand1`	`as` `xs:string?`,
	`$operand2`	`as` `xs:string?`,
	`$collationLiteral`	`as` `xs:anyURI`) `as` `xs:boolean?`

fn:contains($operand1 as xs:string?, $operand2 as xs:string?) as xs:boolean?

contains(string, string) =>
        boolean

`fn:contains`(	`$operand1`	`as` `xs:string?`,
	`$operand2`	`as` `xs:string?`,
	`$collationLiteral`	`as` `xs:anyURI`) `as` `xs:boolean?`

`fn:substring-before`(	`$operand1`	`as` `xs:string?`,
`fn:substring-before`(	`$operand2`	`as` `xs:string?`) `as` `xs:string?`

substring-before(string,string) => string

`fn:substring-before`(	`$operand1`	`as` `xs:string?`,
	`$operand2`	`as` `xs:string?`,
	`$collationLiteral`	`as` `xs:anyURI`) `as` `xs:string?`

fn:substring-after($operand1 as xs:string?, $operand2 as xs:string?) as xs:string?

substring-after(string, string)=> string

InNote: 2.0 1.0, returns

""

mention if it defaults to the firstcontext node argument is an empty node-set. In 2.0, returns

()

`fn:substring`(	`$sourceString`	`as` `xs:string`,
`fn:substring`(	`$startingLoc`	`as` `xs:double`) `as` `xs:string?`

substring(string, number, number?)=> string

`fn:substring`(	`$sourceString`	`as` `xs:string?`,
	`$startingLoc`	`as` `xs:double`,
	`$length`	`as` `xs:double`) `as` `xs:string?`

fn:string-length(

$srcval as xs:string?

) as xs:integer?

string-length(string?)=> number

fn:string-length() as xs:integer?

fn:normalize-space($srcval as xs:string?) as xs:string?

normalize-space(string?) =>
        string

`fn:translate`(	`$srcval`	`as` `xs:string?`,
	`$mapString`	`as` `xs:string?`,
	`$transString`	`as` `xs:string?`) `as` `xs:string?`

translate(string, string,
        string)=> string

In 1.0, returns

""

if the first argument is an empty node-set. In 2.0, returns (). ().

fn:boolean($srcval as item*) as xs:boolean

boolean(object) => boolean

fn:lang($testlang as xs:string) as xs:boolean

lang(string) => boolean

fn:number() as xs:double

number(object?) => number

fn:number($srcval as item?) as xs:double

fn:sum($srcval as xdt:anyAtomicType*) as xdt:anyAtomicType?

sum(node-set) => number

fn:floor($srcval as numeric?) as numeric?

floor(number)=>number

fn:ceiling($srcval as numeric?) as numeric?

ceiling(number)=>number

In1.0 allows a 2.0, if argument is

()

,argument; the result2.0 spec is

()

.more restrictive. Fallback conversions In 1.0, the result is

NaN

fn:round($srcval as numeric?) as numeric?

round(number)=> number

In 2.0, if argument is (), the result is (). In 1.0, the result is NaN.

fn:doc($uri as xs:string?) as document?

document(object, node-set?)=> node-set

The document function in 1.0 has been replaced by the much simpler fn:doc() function.

C Illustrative User-written Functions (Non-Normative)

Certain functions that were proposed for inclusion in this function library have been excluded on the basis that it is straightforward for users to implement these functions themselves using XSLT 2.0 or XQuery 1.0.

This Appendix provides sample implementations of some of these functions.

To emphasize that these functions are examples of functions that vendors may write, their names carry the prefix 'eg'. Vendors are free to define such functions in any namespace. A group of vendors may also choose to create a collection of such useful functions and put them in a common namespace.

C.1 eg:if-empty and eg:if-absent

In some situations, users may want to provide default values for missing information that may be signaled by elements that are omitted, have no value or have the empty sequence as their value. For example, a missing middle initial may be indicated by omitting the element or a non-existent bonus signalled with an empty sequence. This section includes examples of functions that provide such defaults. These functions return xdt:anyAtomicType*. Users may want to write functions that return more specific types.

C.1.1 eg:if-empty

`eg:if-empty`(	`$node`	`as` `node?`,
`eg:if-empty`(	`$value`	`as` `xdt:anyAtomicType`) `as` `xdt:anyAtomicType*`

If the first argument is the empty sequence or an element without simple or complex content, if-empty() returns the second argument; otherwise, it returns the content of the first argument.

XSLT implementation

<xsl:function name="eg:if-empty">
  <xsl:param name="node" type="node?"/>
  <xsl:param name="value" type="xdt:anyAtomicType"/>
  <xsl:result as="xdt:anyAtomicType*"
    select="if ($node and $node/child::node())
            then fn:data($node)
            else $value/>
</xsl:function>

XQuery implementation

define function eg:if-empty (
  $node as node?,
  $value as xdt:anyAtomicType) as xdt:anyAtomicType* 
{
  if ($node and $node/child::node())
            then fn:data($node)
            else $value
}

C.1.2 eg:if-absent

`eg:if-absent`(	`$node`	`as` `node?`,
`eg:if-absent`(	`$value`	`as` `xdt:anyAtomicType`) `as` `xdt:anyAtomicType*`

If the first argument is the empty sequence, if-absent() returns the second argument; otherwise, it returns the content of the first argument.

XSLT implementation

<xsl:function name="eg:if-absent">
  <xsl:param name="node" type="node?"/>
  <xsl:param name="value" type="xdt:anyAtomicType"/>
  <xsl:result as="xdt:anyAtomicType*"
    select="if ($node)
            then fn:data($node)
            else $value/>
</xsl:function>

XQuery implementation

define function eg:if-absent (
  $node as node?,
  $value as xdt:anyAtomicType) as xdt:anyAtomicType* 
{
  if ($node)
    then fn:data($node)
    else $value
}

C.2 union, intersect and except on sequences of values

C.2.1 eg:value-union

`eg:value-union`(	`$operand1`	`as` `anyAtomicType*`,
`eg:value-union`(	`$operand2`	`as` `anyAtomicType`) `as` `anyAtomicType`

This function returns a sequence containing all the distinct items in $operand1 and $operand2, in an undefined order.

XSLT implementation

<xsl:function name="eg:value-union">
  <xsl:param name="operand1" type="anyAtomicType*"/>
  <xsl:param name="operand2" type="anyAtomicType*"/>
  <xsl:result as="item*"
     select="fn:distinct-values(($operand1, $operand2))"/> </xsl:function>

XQuery implementation

define function eg:value-union (
  $operand1 as anyAtomicType*,
  $operand2 as anyAtomicType*) as item* 
{
  fn:distinct-values(($operand1, $operand2))
}

C.2.2 eg:value-intersect

`eg:value-intersect`(	`$operand1`	`as` `anyAtomicType*`,
`eg:value-intersect`(	`$operand2`	`as` `anyAtomicType`) `as` `anyAtomicType`

This function returns a sequence containing all the distinct items that appear in both $operand1 and $operand2, in an undefined order.

XSLT implementation>

<xsl:function name="eg:value-intersect">
  <xsl:param name="operand1" type="anyAtomicType*"/>
  <xsl:param name="operand2" type="anyAtomicType*"/>
  <xsl:result as="anyAtomicType*"
     select="fn:distinct-values($operand1[.=$operand2])"/>
</xsl:function>

XQuery implementation

define function eg:value-intersect (
  $operand1 as anyAtomicType*,
  $operand2 as anyAtomicType* ) as item* 
{
  fn:distinct-values($operand1[.=$operand2])
}

C.2.3 eg:value-except

`eg:value-except`(	`$operand1`	`as` `anyAtomicType*`,
`eg:value-except`(	`$operand2`	`as` `anyAtomicType`) `as` `anyAtomicType`

This function returns a sequence containing all the distinct items that appear in $operand1 but not in $operand2, in an undefined order.

XSLT implementation

<xsl:function name="eg:value-except">
  <xsl:param name="operand1" type="anyAtomicType*"/>
  <xsl:param name="operand2" type="anyAtomicType*"/>
  <xsl:result as="anyAtomicType*"
     select="fn:distinct-values($operand1[not(.=$operand2)])"/>
</xsl:function>

XQuery implementation

define function eg:value-except (
  $operand1 as anyAtomicType*,
  $operand2 as anyAtomicType*) as anyAtomicType* 
{
  fn:distinct-values($operand1[not(.=$operand2)])
}

C.3 eg:index-of-node

`eg:index-of-node`(	`$seqParam`	`as` `node*`,
`eg:index-of-node`(	`$srchParam`	`as` `node`) `as` `xs:positiveInteger*`

This function returns a sequence of positive integers giving the positions within the sequence $seqParam of nodes that are identical to $srchParam.

The nodes in the sequence $seqParam are compared with $srchParam under the rules for the is operator. If a node compares identical, then the position of that node in the sequence $srchParam is included in the result.

If the value of $seqParam is the empty sequence, or if no node in $seqParam matches $srchParam, then the empty sequence is returned.

The index is 1-based, not 0-based.

The result sequence is in ascending numeric order.

XSLT implementation

<xsl:function name="eg:index-of-node">
  <xsl:param name="sequence" as="node*"/>
  <xsl:param name="srch" as="node"/>
  <xsl:result as="xs:integer*"
     select="for $i in 1 to count($sequence)
             return if $sequence[$i] is $srch then $i else ()"/>
</xsl:function>

XQuery implementation

define function eg:index-of-node($sequence as node*, $srch as node) as xs:integer* 
{
  for $n at $i in $sequence where ($n is $srch) return $i
}

C.4 Working With xs:duration Values

This document does not define equality on xs:duration values. Nor does it define other comparison functions on such values. Users wanting to work with xs:duration values should cast them into xdt:yearMonthDuration and xdt:dayTimeDuration values and use the functions defined for comparing them in 9.3 Comparisons of Duration, Date and Time Values to define appropriate semnatics.

One way of comparing two xs:duration values for equality is to compare their yearMonth and dayTime components separately and return equal if both corresponding components are equal. This could be written as follows:

XSLT implementation

<xsl:function name="eg:duration-equal">
  <xsl:param name="arg1" as="xs:duration"/>
  <xsl:param name="arg2" as="xs:duration"/>
  <xsl:result as="xs:boolean"
    select="if 
       (cast as xdt:yearMonthDuration (arg1) eq 
          cast as xdt:yearMonthDuration(arg2) and
        cast as xdt:dayTimeDuration(arg1) eq 
          cast as xdt:dayTimeDuration (arg2))
        )
            then true()
            else false()" />
  </xsl:function>

XQuery implementation

define function eg:duration-equal($arg1 as xs:duration, $arg2 as xs:duration)
    as xs:boolean 
{
  if (cast as xdt:yearMonthDuration ($arg1) eq
      cast as xdt:yearMonthDuration($arg2) 
   and
      cast as xdt:dayTimeDuration($arg1) eq 
      cast as xdt:dayTimeDuration ($arg2)) return fn:true()
  else return fn:false()
}

D Functions and Operators Issues List (Non-Normative)

This appendix contains the current issues related to the operators specification.

E ChangeLog since Last Public Version on 2002-11-15 (Non-Normative)

This appendix tracks gross changes in the document; it is not intended to provide a fine-grained revision history.

2003-03-27(AM)Added fn:trace().Approved by the XML Query WG on 3/7/2003; by theXSL WG on 3/27/2003.

2003-03-24 (AM) Argumentsof type xdt:untypedAtomic to theidiv operator are now cast to xs:integer instead of xs:double. See note from MFF http://lists.w3.org/Archives/Member/w3c-xsl-query/2003Mar/0300.html.

2003-03-11 (AM) Added fn:document-uri functionbased on dm:document-uri accessor. As approved in F&Omeeting on 3/3 By WGs on 3/6.

2003-03-10 (AM) Added text to semantics of fn:collection as approved in F&O meeting on 3/3By WGs on 3/6. Alsoadded definition of "stable" and used it in fn:collection, fn:input, fn:doc, fn:current-dateTime, fn:current-time and fn:current:date.

2003-03-10(AM) Added fn:doc function. Removedfn:document. As approved in F&O meeting on 3/3 By WGs on 3/6.

2003-03-09 (AM) Closed issue 177 and added detailed rules for handling overflow and underflow.Approved in F&O meeting on 3/3 ByWGs on 3/6.

2003-03-09 (AM) Added special rulae that the div operator returns decimal instead of doublefor integer operands. Approved in F&O meeting on 3/3 By WGs on3/6.

2003-03-09 (AM) Elaborated definitions of string-to-codepoints and codepoints to string. Approved in F&O meeting on 3/3 By WGs on 3/6.

2003-03-08 (AM) Added functions to adjust a dateTime, date or time from one timezone to another. Closed issue136. Approved by Query WG 2/26.XSL WG on 2/27. F&O on 2/20.

2003-03-07 (AM) Removed constructors for ENTITIES,NMTOKENS and IDREFS. Approved in joint meeting on 3/7.

2003-03-07(AM) Changed nameof fn:sequence-node-equal to fn:sequence-node-identical. Approved in F&Omeeting on 3/3 By WGs on3/6.

2003-03-07 (AM) Changed casting table to prohibit casting from hexBinary to numerics.Approved in F&Omeeting on 3/3 By WGs on 3/6.

2003-03-07 (AM) Added constructor for xdt:untypedAtomic. Approvedin F&O meeting on 3/3 By WGson 3/6.

2003-03-07 (AM) Changed second argument offn:half-round-to-even to integer. Addedtwo simple examples. Approved in F&Omeeting on 3/3 By WGs on 3/6.

2003-03-07 (AM) Addedsentence that if $pattern in fn:tokenize matches empty string an error is raised. Approved in F&Omeeting on 3/3 By WGs on 3/6.

2003-03-07 (AM) Changedcollation note as per MHK note http://lists.w3.org/Archives/Member/w3c-query-operators/2003Jan/0029.html. Approved in F&Omeeting on 3/3 By WGs on 3/6.

2003-03-07 (AM) Changedcasting of double to float to conform with IEEE 754. Approved in F&Omeeting on 3/3 By WGs on 3/6.

2003-03-07 (AM) Changedsemanticsof fn:number() to return NaN instead of error, as approvedin F&O meeting on 3/3By WGs on 3/6.

2003-03-07 (AM) Changednumeric comparisonfunctions to say that comparisons incolving NaN always return false. Approvedin F&O meeting on 3/3 By WGs on 3/6.

2003-03-07 (AM) Changednamespace forconstructors to the XML Schema namespace to conform with usagein ther documents.

2003-02-21(AM) Changed return types forfn:count(), fn:position(), fn:last() and fn:indexof() to xs:integer from subtypeof integer. As agreed to by the XQuery WG on 2/12, XSL WG in 2/20.

2003-02-21(AM)Renamed fn:insert to fn:insert-before and clarified semantics. As agreed to bythe XQuery WG on 1/22, XSL WG in 2/20.

2003-02-21 (AM) Clarifiedsemantics of QName-equal. As agreed to bythe XQuery WG on 1/22, XSL WG in 2/20.

2003-02-21 (AM) Removedregexextensibility para from section 6.5.1. Closed issue 176. As agreed to bythe XQueryWG on2/12, XSL WG in 2/20.

2003-02-12 (AM) Changed semantics of fn:data() as agreed to by the XPath taskforce on 2/11 and the XQuery WG on 2/12. Revisedon 2/19.

2003-01-06 (AM) Created signatures for fn:string-length() and fn:normalize-space() with no argument. Argument defaults to the string value of the context item. Asper mail from Mike Kay. Noobjection. Treated as bug fix.

2003-01-01 (AM) Closed issue 186 (preserve-timezone)and implemented MRys proposal for timezonepreservation as approved by both WGs 12/18.

2002-12-27(AM) Created a separate section for string functions that useregex's for pattern matching -- fn:matches(), fn:replace() and fn:tokenize(). Section startswith the common regex syntax. Editorial.

2002-12-24 (AM) Closed issue 173 (disambiguate-multiple-possible-outcomes). Addedtext saying that the semantic rules describing each function must be followed in the orderthat they appear.

2002-12-24 (AM) Closed issue 89 (functions-on-anyType-problematic). Thesefunctions are now identified typographically and their semantics is spelt out in detail withpointers to the Formal Semantics document where needed. Approved by both WGs 12/18.

2002-12-23 (AM) Closed issue 187 (untyped-values-in-aggregates). Semanticsspecified. Castto other types in the sequence. If all untyped, cast to string. Approved by both WGs 12/18.

2002-12-23 (AM) Changedsemantics of fn:idref to return the node that contains the ID valueinstead of the containing element.. Approved by both WGs 12/18.

2002-12-23 (AM) Closed issue 185 on op:duration-equal by removing the function. (remove-duration-equal). Added explanatory text in fn:distinct-values and fn:deep-equal. Added example in Appendix C. Approved by both WGs 12/18.

2002-12-22 (AM) Closed issue 79 on number of digits ofprecision returned by various functions (operator-returned-precision). Approved by both WGs 12/18.

2002-12-22 (AM) Closedissue 44 on collation names (operator-collation-specification). Approvedby both WGs 12/18.

2002-12-22 (AM) Revised definition of fn:data() as per (member-only message) http://lists.w3.org/Archives/Member/w3c-xsl-query/2002Nov/0391.html. Approved by XQuery 12/11. ByXSL WG 12/19.

2002-12-20 (AM) Closed issue 181 (error-function-semantics) and made suggested editorial changes. Semanticshave now been defined in section 3. Approved by both WGs 12/18.

2002-12-20 (AM) Closedissue 73 (operator-compare-between). Originatorwithdrew the issue because "we now have two kinds of comparison functions". Approved by both WGs 12/18.

2002-12-20 (AM) Closed issue 144 (should-concat-accept-sequence-arguments) because we added fn:string-join(). Approvedby both WGs 12/18.

2002-12-20 (AM) Addeddefinition for round-half-to-even. Approvedby XQuery 11/14. ByXSL WG 12/19.

2002-12-20 (AM) Addeddefinition for index-of-node in Appendix C.Approved by XQuery 11/14. ByXSL WG 12/19. Closed issue63 (operator-augment-index-of)

2002-12-19 (AM) Add fn:expanded-QName. Inadvertentlydropped. Asapproved by both WGs on 2002-12-18.

2002-12-19 (AM) Removedfn:unique-id. Asapproved by both WGs on 2002-12-18.

2002-12-18(AM) Closed issue 159. Minimumof 3 fractional seconds digits must be supported fordate/time types. Asapproved by both WGs on 2002-12-18.

2002-12-18 (AM) Changed namespace for datatypes defined in this document. Referredto by prefix xdt:. Asapproved by both WGs on2002-12-18.

2002-12-05 (AM) Changeddefinition of base-uri to returnthe emptysequence (not error) if argument is not a document,element or PI node. This was datamodel issue 87. Approvedby XQuery WG on 12/11, XSL WG on 12/05.

2002-12-05 (AM) Changed definitions of floor(), ceiling()and round() as per (member-only link)http://lists.w3.org/Archives/Member/w3c-xml-query-wg/2002Nov/0137.html. Approvedby XQuery WG on 11/14, XSL WG on11/15. Closed issue 142(what-should-floor-ceiling-round-return) andissue 179 (floor-ceiling-round-return-type).

2002-12-05 (AM) Changeddefinition of index-of as suggested by Mike Kay in (member-only link) http://lists.w3.org/Archives/Member/w3c-query-operators/2002Nov/0098.html

2002-11-27 (AM) Added definitions for anyAtomicType and untypedAtomic. Asper XML Query telcon 2002-11-27.

2002-11-27 (AM) Changed namespacefor datatypes defined in this document. Referredto by prefix qt:. Asper XML Query telcon 2002-11-27.

2002-11-19 (AM) Editorialfixes to fn:id() and fn:idref() as per MHK (member-only message) http://lists.w3.org/Archives/Member/w3c-query-operators/2002Nov/0092.html

2002-11-15 (AM) Closed issue 21 (operator-function-return-types) as agreed to by the XML QueryWG on 11/13 and the XSL WG on 11/14.

2002-11-15(AM) Added rules for casting to integerasagreed to by the XML Query WG on 11/13 and theXSL WG on11/14.

F Function and Operator Quick Reference (Non-Normative)

F.1 Functions and Operators by Section

Accessors

fn:node-kind: fn:node-kind($srcval as node) as xs:string
fn:node-name: fn:node-name($srcval as node) as xs:QName?
fn:string: fn:string() as xs:string

fn:string($srcval as item?) as xs:string
fn:data: fn:data(
$srcval as item*
) as xdt:anyAtomicType*
fn:base-uri: fn:base-uri($srcval as node) as xs:string?

fn:base-uri() as xs:string?
fn:document-uri: fn:document-uri($srcval as node) as xs:string?

The Error Function

fn:error() as none

fn:error($srcval as item?) as none

The Trace Function

fn:trace($value as item*, $label as xs:string) as item*

Functions and Operators on Numerics

Operators on Numeric Values: op:numeric-add($operand1 as numeric, $operand2 as numeric) as numeric

op:numeric-subtract($operand1 as numeric, $operand2 as numeric) as numeric

op:numeric-multiply($operand1 as numeric, $operand2 as numeric) as numeric

op:numeric-divide($operand1 as numeric, $operand2 as numeric) as numeric

op:numeric-integer-divide($operand1 as xs:integer, $operand2 as xs:integer) as xs:integer

op:numeric-mod($operand1 as numeric, $operand2 as numeric) as numeric

op:numeric-unary-plus($operand as numeric) as numeric

op:numeric-unary-minus($operand as numeric) as numeric
Comparison of Numeric Values: op:numeric-equal($operand1 as numeric, $operand2 as numeric) as xs:boolean

op:numeric-less-than($operand1 as numeric, $operand2 as numeric) as xs:boolean

op:numeric-greater-than($operand1 as numeric, $operand2 as numeric) as xs:boolean
Functions on Numeric Values: fn:floor($srcval as numeric?) as numeric?

fn:ceiling($srcval as numeric?) as numeric?

fn:round($srcval as numeric?) as numeric?

fn:round-half-to-even($srcval as numeric?) as numeric?

fn:round-half-to-even($srcval as numeric?, $precision as integer) as numeric?

Functions on Strings

Functions to Assemble and Disassemble Strings: fn:codepoints-to-string($srcval as xs:integer*) as xs:string

fn:string-to-codepoints($srcval as xs:string) as xs:integer*
Equality and Comparison of Strings: fn:compare($comparand1 as xs:string?, $comparand2 as xs:string?) as xs:integer?

fn:compare($comparand1 as xs:string?, $comparand2 as xs:string?, $collationLiteral as xs:string) as xs:integer?
Functions on String Values: fn:concat() as xs:string

fn:concat($op1 as xs:string?) as xs:string

fn:concat($op1 as xs:string?, $op2 as xs:string?, ...) as xs:string

fn:string-join($operand1 as xs:string*, $operand2 as xs:string) as xs:string

fn:starts-with($operand1 as xs:string?, $operand2 as xs:string?) as xs:boolean?

fn:starts-with($operand1 as xs:string?, $operand2 as xs:string?, $collationLiteral as xs:string) as xs:boolean?

fn:ends-with($operand1 as xs:string?, $operand2 as xs:string?) as xs:boolean?

fn:ends-with($operand1 as xs:string?, $operand2 as xs:string?, $collationLiteral as xs:string) as xs:boolean?

fn:contains($operand1 as xs:string?, $operand2 as xs:string?) as xs:boolean?

fn:contains($operand1 as xs:string?, $operand2 as xs:string?, $collationLiteral as xs:string) as xs:boolean?

fn:substring($sourceString as xs:string?, $startingLoc as xs:double) as xs:string?

fn:substring($sourceString as xs:string?, $startingLoc as xs:double, $length as xs:double) as xs:string?

fn:string-length() as xs:integer?

fn:string-length(
$srcval as xs:string?
) as xs:integer?

fn:substring-before($operand1 as xs:string?, $operand2 as xs:string?) as xs:string?

fn:substring-before($operand1 as xs:string?, $operand2 as xs:string?, $collationLiteral as xs:string) as xs:string?

fn:substring-after($operand1 as xs:string?, $operand2 as xs:string?) as xs:string?

fn:substring-after($operand1 as xs:string?, $operand2 as xs:string?, $collationLiteral as xs:string) as xs:string?

fn:normalize-space() as xs:string?

fn:normalize-space(
$srcval as xs:string?
) as xs:string?

fn:normalize-unicode($srcval as xs:string?) as xs:string?

fn:normalize-unicode($srcval as xs:string?, $normalizationForm as xs:string) as xs:string?

fn:upper-case($srcval as xs:string?) as xs:string?

fn:lower-case($srcval as xs:string?) as xs:string?

fn:translate($srcval as xs:string?, $mapString as xs:string?, $transString as xs:string?) as xs:string?

fn:string-pad($padString as xs:string?, $padCount as xs:integer) as xs:string?

fn:escape-uri($uri-part as string, $escape-reserved as xs:boolean) as xs:string
Stringpatterns Functions that Use Pattern Matching: fn:matches($input as xs:string?, $pattern as xs:string) as xs:boolean?

fn:matches($input as xs:string?, $pattern as xs:string, $flags as xs:string) as xs:boolean?

fn:replace($input as xs:string?, $pattern as xs:string, $replacement as xs:string) as xs:string?

fn:replace($input as xs:string?, $pattern as xs:string, $replacement as xs:string, $flags as xs:string) as xs:string?

fn:tokenize($input as xs:string?, $pattern as xs:string) as xs:string*

fn:tokenize($input as xs:string?, $pattern as xs:string, $flags as xs:string) as xs:string*

Functions and Operators on Booleans

Boolean Constructor Functions: fn:true() as xs:boolean

fn:false() as xs:boolean
Operators on Boolean Values: op:boolean-equal($value1 as xs:boolean, $value2 as xs:boolean) as xs:boolean

op:boolean-less-than($srcval1 as xs:boolean, $srcval2 as xs:boolean) as xs:boolean

op:boolean-greater-than($srcval1 as xs:boolean, $srcval2 as xs:boolean) as xs:boolean
Functions on Boolean Values: fn:not($srcval as item*) as xs:boolean

Functions and Operators on Durations, Dates and Times

Comparisons of Duration, Date and Time Values: op:yearMonthDuration-equal($operand1 as xdt:yearMonthDuration, $operand2 as xdt:yearMonthDuration) as xs:boolean

op:yearMonthDuration-less-than($operand1 as xdt:yearMonthDuration, $operand2 as xdt:yearMonthDuration) as xs:boolean

op:yearMonthDuration-greater-than($operand1 as xdt:yearMonthDuration, $operand2 as xdt:yearMonthDuration) as xs:boolean

op:dayTimeDuration-equal($operand1 as xdt:dayTimeDuration, $operand2 as xdt:dayTimeDuration) as xs:boolean

op:dayTimeDuration-less-than($operand1 as xdt:dayTimeDuration, $operand2 as xdt:dayTimeDuration) as xs:boolean

op:dayTimeDuration-greater-than($operand1 as xdt:dayTimeDuration, $operand2 as xdt:dayTimeDuration) as xs:boolean

op:dateTime-equal($operand1 as xs:dateTime, $operand2 as xs:dateTime) as xs:boolean

op:dateTime-less-than($operand1 as xs:dateTime, $operand2 as xs:dateTime) as xs:boolean

op:dateTime-greater-than($operand1 as xs:dateTime, $operand2 as xs:dateTime) as xs:boolean

op:date-equal($operand1 as xs:date, $operand2 as xs:date) as xs:boolean

op:date-less-than($operand1 as xs:date, $operand2 as xs:date) as xs:boolean

op:date-greater-than($operand1 as xs:date, $operand2 as xs:date) as xs:boolean

op:time-equal($operand1 as xs:time, $operand2 as xs:time) as xs:boolean

op:time-less-than($operand1 as xs:time, $operand2 as xs:time) as xs:boolean

op:time-greater-than($operand1 as xs:time, $operand2 as xs:time) as xs:boolean

op:gYearMonth-equal($operand1 as xs:gYearMonth, $operand2 as xs:gYearMonth) as xs:boolean

op:gYear-equal($operand1 as xs:gYear, $operand2 as xs:gYear) as xs:boolean

op:gMonthDay-equal($operand1 as xs:gMonthDay, $operand2 as xs:gMonthDay) as xs:boolean

op:gMonth-equal($operand1 as xs:gMonth, $operand2 as xs:gMonth) as xs:boolean

op:gDay-equal($operand1 as xs:gDay, $operand2 as xs:gDay) as xs:boolean
Component Extraction Functions on Duration, Date and Time Values: fn:get-years-from-yearMonthDuration($srcval as xdt:yearMonthDuration?) as xs:integer?

fn:get-months-from-yearMonthDuration($srcval as xdt:yearMonthDuration?) as xs:integer?

fn:get-days-from-dayTimeDuration($srcval as xdt:dayTimeDuration?) as xs:integer?

fn:get-hours-from-dayTimeDuration($srcval as xdt:dayTimeDuration?) as xs:integer?

fn:get-minutes-from-dayTimeDuration($srcval as xdt:dayTimeDuration?) as xs:integer?

fn:get-seconds-from-dayTimeDuration($srcval as xdt:dayTimeDuration?) as xs:decimal?

fn:get-year-from-dateTime($srcval as xs:dateTime?) as xs:integer?

fn:get-month-from-dateTime($srcval as xs:dateTime?) as xs:integer?

fn:get-day-from-dateTime($srcval as xs:dateTime?) as xs:integer?

fn:get-hours-from-dateTime($srcval as xs:dateTime?) as xs:integer?

fn:get-minutes-from-dateTime($srcval as xs:dateTime?) as xs:integer?

fn:get-seconds-from-dateTime($srcval as xs:dateTime?) as xs:decimal?

fn:get-timezone-from-dateTime($srcval as xs:dateTime?) as xdt:dayTimeDuration?

fn:get-year-from-date($srcval as xs:date?) as xs:integer?

fn:get-month-from-date($srcval as xs:date?) as xs:integer?

fn:get-day-from-date($srcval as xs:date?) as xs:integer?

fn:get-timezone-from-date($srcval as xs:date?) as xdt:dayTimeDuration?

fn:get-hours-from-time($srcval as xs:time?) as xs:integer?

fn:get-minutes-from-time($srcval as xs:time?) as xs:integer?

fn:get-seconds-from-time($srcval as xs:time?) as xs:decimal?

fn:get-timezone-from-time($srcval as xs:time?) as xdt:dayTimeDuration?
Arithmetic Functions on xdt:yearMonthDuration and xdt:dayTimeDuration: op:add-yearMonthDurations($srcval1 as xdt:yearMonthDuration, $srcval2 as xdt:yearMonthDuration) as xdt:yearMonthDuration

op:subtract-yearMonthDurations($srcval1 as xdt:yearMonthDuration, $srcval2 as xdt:yearMonthDuration) as xdt:yearMonthDuration

op:multiply-yearMonthDuration($srcval1 as xdt:yearMonthDuration, $srcval2 as xs:decimal) as xdt:yearMonthDuration

op:divide-yearMonthDuration($srcval1 as xdt:yearMonthDuration, $srcval2 as xs:decimal) as xdt:yearMonthDuration

op:add-dayTimeDurations($srcval1 as xdt:dayTimeDuration, $srcval2 as xdt:dayTimeDuration) as xdt:dayTimeDuration

op:subtract-dayTimeDurations($srcval1 as xdt:dayTimeDuration, $srcval2 as xdt:dayTimeDuration) as xdt:dayTimeDuration

op:multiply-dayTimeDuration($srcval1 as xdt:dayTimeDuration, $srcval2 as xs:decimal) as xdt:dayTimeDuration

op:divide-dayTimeDuration($srcval1 as xdt:dayTimeDuration, $srcval2 as xs:decimal) as xdt:dayTimeDuration
Timezone Adjustment on dateTime, date and time Values: fn:adjust-dateTime-to-timezone($srcval as xs:dateTime?) as xs:dateTime?

fn:adjust-dateTime-to-timezone($srcval as xs:dateTime?, $timezone as xdt:dayTimeDuration?) as xs:dateTime?

fn:adjust-date-to-timezone(
$srcval as xs:date?
) as xs:date?

fn:adjust-date-to-timezone($srcval as xs:date?, $timezone as xdt:dayTimeDuration?) as xs:date?

fn:adjust-time-to-timezone(
$srcval as xs:time?
) as xs:dateTime?

fn:adjust-time-to-timezone($srcval as xs:time?, $timezone as xdt:dayTimeDuration?) as xs:time?
Adding and Subtracting Durations From dateTime, date and time: fn:subtract-dateTimes-yielding-yearMonthDuration($srcval1 as xs:dateTime, $srcval2 as xs:dateTime) as xdt:yearMonthDuration

fn:subtract-dateTimes-yielding-dayTimeDuration($srcval1 as xs:dateTime, $srcval2 as xs:dateTime) as xdt:dayTimeDuration

op:subtract-dates($srcval1 as xs:date, $srcval2 as xs:date) as xdt:dayTimeDuration

op:subtract-times($srcval1 as xs:time, $srcval2 as xs:time) as xdt:dayTimeDuration

op:add-yearMonthDuration-to-dateTime($srcval1 as xs:dateTime, $srcval2 as xdt:yearMonthDuration) as xs:dateTime

op:add-dayTimeDuration-to-dateTime($srcval1 as xs:dateTime, $srcval2 as xdt:dayTimeDuration) as xs:dateTime

op:subtract-yearMonthDuration-from-dateTime($srcval1 as xs:dateTime, $srcval2 as xdt:yearMonthDuration) as xs:dateTime

op:subtract-dayTimeDuration-from-dateTime($srcval1 as xs:dateTime, $srcval2 as xs:dayTimeDuration) as xs:dateTime

op:add-yearMonthDuration-to-date($srcval1 as xs:date, $srcval2 as xdt:yearMonthDuration) as xs:date

op:add-dayTimeDuration-to-date($srcval1 as xs:date, $srcval2 as xdt:dayTimeDuration) as xs:date

op:subtract-yearMonthDuration-from-date($srcval1 as xs:date, $srcval2 as xdt:yearMonthDuration) as xs:date

op:subtract-dayTimeDuration-from-date($srcval1 as xs:date, $srcval2 as xdt:dayTimeDuration) as xs:date

op:add-dayTimeDuration-to-time($srcval1 as xs:time, $srcval2 as xdt:dayTimeDuration) as xs:time

op:subtract-dayTimeDuration-from-time($srcval1 as xs:time, $srcval2 as xs:dayTimeDuration) as xs:time

Functions Related to QNames

Constructor Functions for QNames: fn:resolve-QName($qname as xs:string, $element as element) as xs:QName

fn:expanded-QName($paramURI as xs:string, $paramLocal as xs:string) as xs:QName
Functions Related to QNames: op:QName-equal($srcval1 as xs:QName, $srcval2 as xs:QName) as xs:boolean

fn:get-local-name-from-QName($srcval as xs:QName?) as xs:string?

fn:get-namespace-from-QName($srcval as xs:QName?) as xs:string?

fn:get-namespace-uri-for-prefix($element as element, $prefix as xs:string) as xs:string?

fn:get-in-scope-namespaces($element as element) as xs:string*

Functions and Operators for anyURI

fn:resolve-uri: fn:resolve-uri($relative as xs:string) as xs:string

fn:resolve-uri($relative as xs:string, $base as anyURI) as xs:string
op:anyURI-equal: op:anyURI-equal($srcval1 as xs:anyURI, $srcval2 as xs:anyURI) as xs:boolean

Functions and Operators on base64Binary and hexBinary

Comparisons of base64Binary and hexBinary Values: op:hexBinary-equal($value1 as xs:hexBinary, $value2 as xs:hexBinary) as xs:boolean

op:base64Binary-equal($value1 as xs:base64Binary, $value2 as xs:base64Binary) as xs:boolean

Functions and Operators on NOTATION

Operators on NOTATION: op:NOTATION-equal($srcval1 as xs:NOTATION, $srcval2 as xs:NOTATION) as xs:boolean

Functions and Operators on Nodes

Functions and Operators on Nodes: fn:name() as xs:string

fn:name($srcval as node?) as xs:string

fn:local-name() as xs:string

fn:local-name($srcval as node?) as xs:string

fn:namespace-uri() as xs:string

fn:namespace-uri($srcval as node?) as xs:string

fn:number() as xs:double

fn:number($srcval as item?) as xs:double

fn:lang($testlang as xs:string) as xs:boolean

op:node-equal($parameter1 as node, $parameter2 as node) as xs:boolean

op:node-before($parameter1 as node, $parameter2 as node) as xs:boolean

op:node-after($parameter1 as node, $parameter2 as node) as xs:boolean

fn:root() as node

fn:root($srcval as node) as node

Functions and Operators on Sequences

Constructor Functions and Operators on Sequences: fn:zero-or-one($srcval as item*) as item?

fn:one-or-more($srcval as item*) as item+

fn:exactly-one($srcval as item*) as item

fn:boolean($srcval as item*) as xs:boolean

op:concatenate($seq1 as item*, $seq2 as item*) as item*

fn:item-at($seqParam as item*, $posParam as integer) as item?

fn:index-of($seqParam as xs:anyAtomicType*, $srchParam as xs:anyAtomicType) as xs:integer*

fn:index-of($seqParam as xs:anyAtomicType*, $srchParam as xs:anyAtomicType, $collationLiteral as xs:string) as xs:integer*

fn:empty($srcval as item*) as xs:boolean

fn:exists($srcval as item*) as xs:boolean

fn:distinct-nodes($srcval as node*) as node*

fn:distinct-values($srcval as xs:anyAtomicType*) as xs:anyAtomicType*

fn:distinct-values($srcval as xs:anyAtomicType*, $collationLiteral as xs:string) as xs:anyAtomicType*

fn:insert-before($target as item*, $position as xs:integer, $inserts as item*) as item*

fn:remove($target as item*, $position as xs:integer) as item*

fn:subsequence($sourceSeq as item*, $startingLoc as xs:double) as item*

fn:subsequence($sourceSeq as item*, $startingLoc as xs:double, $length as xs:double) as item*

fn:unordered($sourceSeq as item*) as item*
Equals, Union, Intersection and Except: fn:deep-equal($parameter1 as item*, $parameter2 as item*) as xs:boolean

fn:deep-equal($parameter1 as item*, $parameter2 as item*, $collationLiteral as string) as xs:boolean

fn:sequence-node-identical($parameter1 as node*, $parameter2 as node*) as xs:boolean?

op:union($parameter1 as node*, $parameter2 as node*) as node*

op:intersect($parameter1 as node*, $parameter2 as node*) as node*

op:except($parameter1 as node*, $parameter2 as node*) as node*
Aggregate Functions: fn:count($srcval as item*) as xs:integer

fn:avg($srcval as xdt:anyAtomicType*) as xdt:anyAtomicType?

fn:max($srcval as xdt:anyAtomicType*) as xdt:anyAtomicType?

fn:max($srcval as xdt:anyAtomicType*, $collationLiteral as string) as xdt:anyAtomicType?

fn:min($srcval as xdt:anyAtomicType*) as xdt:anyAtomicType?

fn:min($srcval as xdt:anyAtomicType*, $collationLiteral as string) as xdt:anyAtomicType?

fn:sum($srcval as xdt:anyAtomicType*) as xdt:anyAtomicType?
Functions that Generate Sequences: op:to($firstval as xs:integer, $lastval as xs:integer) as xs:integer+

fn:id($srcval as xs:string*) as element*

fn:idref($srcval as xs:string*) as node*

fn:doc($uri as xs:string?) as document?

fn:collection($srcval as xs:string) as node*

fn:input() as node*

Context Functions

fn:context-item: fn:context-item() as item?
fn:position: fn:position() as xs:integer?
fn:last: fn:last() as xs:integer?
fn:current-dateTime: fn:current-dateTime() as dateTime
fn:current-date: fn:current-date() as date
fn:current-time: fn:current-time() as time
fn:default-collation: fn:default-collation() as xs:anyURI?
fn:implicit-timezone: fn:implicit-timezone() as xs:dayTimeDuration?

F.2 Functions and Operators Alphabetically

op:add-dayTimeDuration-to-date($srcval1 as xs:date, $srcval2 as xdt:dayTimeDuration) as xs:date

op:add-dayTimeDuration-to-dateTime($srcval1 as xs:dateTime, $srcval2 as xdt:dayTimeDuration) as xs:dateTime

op:add-dayTimeDuration-to-time($srcval1 as xs:time, $srcval2 as xdt:dayTimeDuration) as xs:time

op:add-dayTimeDurations($srcval1 as xdt:dayTimeDuration, $srcval2 as xdt:dayTimeDuration) as xdt:dayTimeDuration

op:add-yearMonthDuration-to-date($srcval1 as xs:date, $srcval2 as xdt:yearMonthDuration) as xs:date

op:add-yearMonthDuration-to-dateTime($srcval1 as xs:dateTime, $srcval2 as xdt:yearMonthDuration) as xs:dateTime

op:add-yearMonthDurations($srcval1 as xdt:yearMonthDuration, $srcval2 as xdt:yearMonthDuration) as xdt:yearMonthDuration

fn:adjust-date-to-timezone(

$srcval as xs:date?

) as xs:date?

fn:adjust-date-to-timezone($srcval as xs:date?, $timezone as xdt:dayTimeDuration?) as xs:date?

fn:adjust-dateTime-to-timezone($srcval as xs:dateTime?) as xs:dateTime?

fn:adjust-dateTime-to-timezone($srcval as xs:dateTime?, $timezone as xdt:dayTimeDuration?) as xs:dateTime?

fn:adjust-time-to-timezone(

$srcval as xs:time?

) as xs:dateTime?

fn:adjust-time-to-timezone($srcval as xs:time?, $timezone as xdt:dayTimeDuration?) as xs:time?

op:anyURI-equal($srcval1 as xs:anyURI, $srcval2 as xs:anyURI) as xs:boolean

fn:avg($srcval as xdt:anyAtomicType*) as xdt:anyAtomicType?

fn:base-uri($srcval as node) as xs:string?

fn:base-uri() as xs:string?

op:base64Binary-equal($value1 as xs:base64Binary, $value2 as xs:base64Binary) as xs:boolean

fn:boolean($srcval as item*) as xs:boolean

op:boolean-equal($value1 as xs:boolean, $value2 as xs:boolean) as xs:boolean

op:boolean-greater-than($srcval1 as xs:boolean, $srcval2 as xs:boolean) as xs:boolean

op:boolean-less-than($srcval1 as xs:boolean, $srcval2 as xs:boolean) as xs:boolean

fn:ceiling($srcval as numeric?) as numeric?

fn:codepoints-to-string($srcval as xs:integer*) as xs:string

fn:collection($srcval as xs:string) as node*

fn:compare($comparand1 as xs:string?, $comparand2 as xs:string?) as xs:integer?

fn:compare($comparand1 as xs:string?, $comparand2 as xs:string?, $collationLiteral as xs:string) as xs:integer?

fn:concat() as xs:string

fn:concat($op1 as xs:string?) as xs:string

fn:concat($op1 as xs:string?, $op2 as xs:string?, ...) as xs:string

op:concatenate($seq1 as item*, $seq2 as item*) as item*

fn:contains($operand1 as xs:string?, $operand2 as xs:string?) as xs:boolean?

fn:contains($operand1 as xs:string?, $operand2 as xs:string?, $collationLiteral as xs:string) as xs:boolean?

fn:context-item() as item?

fn:count($srcval as item*) as xs:integer

fn:current-date() as date

fn:current-dateTime() as dateTime

fn:current-time() as time

fn:data(

$srcval as item*

) as xdt:anyAtomicType*

op:date-equal($operand1 as xs:date, $operand2 as xs:date) as xs:boolean

op:date-greater-than($operand1 as xs:date, $operand2 as xs:date) as xs:boolean

op:date-less-than($operand1 as xs:date, $operand2 as xs:date) as xs:boolean

op:dateTime-equal($operand1 as xs:dateTime, $operand2 as xs:dateTime) as xs:boolean

op:dateTime-greater-than($operand1 as xs:dateTime, $operand2 as xs:dateTime) as xs:boolean

op:dateTime-less-than($operand1 as xs:dateTime, $operand2 as xs:dateTime) as xs:boolean

op:dayTimeDuration-equal($operand1 as xdt:dayTimeDuration, $operand2 as xdt:dayTimeDuration) as xs:boolean

op:dayTimeDuration-greater-than($operand1 as xdt:dayTimeDuration, $operand2 as xdt:dayTimeDuration) as xs:boolean

op:dayTimeDuration-less-than($operand1 as xdt:dayTimeDuration, $operand2 as xdt:dayTimeDuration) as xs:boolean

fn:deep-equal($parameter1 as item*, $parameter2 as item*) as xs:boolean

fn:deep-equal($parameter1 as item*, $parameter2 as item*, $collationLiteral as string) as xs:boolean

fn:default-collation() as xs:anyURI?

fn:distinct-nodes($srcval as node*) as node*

fn:distinct-values($srcval as xs:anyAtomicType*) as xs:anyAtomicType*

fn:distinct-values($srcval as xs:anyAtomicType*, $collationLiteral as xs:string) as xs:anyAtomicType*

op:divide-dayTimeDuration($srcval1 as xdt:dayTimeDuration, $srcval2 as xs:decimal) as xdt:dayTimeDuration

op:divide-yearMonthDuration($srcval1 as xdt:yearMonthDuration, $srcval2 as xs:decimal) as xdt:yearMonthDuration

fn:doc($uri as xs:string?) as document?

fn:document-uri($srcval as node) as xs:string?

fn:empty($srcval as item*) as xs:boolean

fn:ends-with($operand1 as xs:string?, $operand2 as xs:string?) as xs:boolean?

fn:ends-with($operand1 as xs:string?, $operand2 as xs:string?, $collationLiteral as xs:string) as xs:boolean?

fn:error() as none

fn:error($srcval as item?) as none

fn:escape-uri($uri-part as string, $escape-reserved as xs:boolean) as xs:string

fn:exactly-one($srcval as item*) as item

op:except($parameter1 as node*, $parameter2 as node*) as node*

fn:exists($srcval as item*) as xs:boolean

fn:expanded-QName($paramURI as xs:string, $paramLocal as xs:string) as xs:QName

fn:false() as xs:boolean

fn:floor($srcval as numeric?) as numeric?

op:gDay-equal($operand1 as xs:gDay, $operand2 as xs:gDay) as xs:boolean

fn:get-day-from-date($srcval as xs:date?) as xs:integer?

fn:get-day-from-dateTime($srcval as xs:dateTime?) as xs:integer?

fn:get-days-from-dayTimeDuration($srcval as xdt:dayTimeDuration?) as xs:integer?

fn:get-hours-from-dateTime($srcval as xs:dateTime?) as xs:integer?

fn:get-hours-from-dayTimeDuration($srcval as xdt:dayTimeDuration?) as xs:integer?

fn:get-hours-from-time($srcval as xs:time?) as xs:integer?

fn:get-in-scope-namespaces($element as element) as xs:string*

fn:get-local-name-from-QName($srcval as xs:QName?) as xs:string?

fn:get-minutes-from-dateTime($srcval as xs:dateTime?) as xs:integer?

fn:get-minutes-from-dayTimeDuration($srcval as xdt:dayTimeDuration?) as xs:integer?

fn:get-minutes-from-time($srcval as xs:time?) as xs:integer?

fn:get-month-from-date($srcval as xs:date?) as xs:integer?

fn:get-month-from-dateTime($srcval as xs:dateTime?) as xs:integer?

fn:get-months-from-yearMonthDuration($srcval as xdt:yearMonthDuration?) as xs:integer?

fn:get-namespace-from-QName($srcval as xs:QName?) as xs:string?

fn:get-namespace-uri-for-prefix($element as element, $prefix as xs:string) as xs:string?

fn:get-seconds-from-dateTime($srcval as xs:dateTime?) as xs:decimal?

fn:get-seconds-from-dayTimeDuration($srcval as xdt:dayTimeDuration?) as xs:decimal?

fn:get-seconds-from-time($srcval as xs:time?) as xs:decimal?

fn:get-timezone-from-date($srcval as xs:date?) as xdt:dayTimeDuration?

fn:get-timezone-from-dateTime($srcval as xs:dateTime?) as xdt:dayTimeDuration?

fn:get-timezone-from-time($srcval as xs:time?) as xdt:dayTimeDuration?

fn:get-year-from-date($srcval as xs:date?) as xs:integer?

fn:get-year-from-dateTime($srcval as xs:dateTime?) as xs:integer?

fn:get-years-from-yearMonthDuration($srcval as xdt:yearMonthDuration?) as xs:integer?

op:gMonth-equal($operand1 as xs:gMonth, $operand2 as xs:gMonth) as xs:boolean

op:gMonthDay-equal($operand1 as xs:gMonthDay, $operand2 as xs:gMonthDay) as xs:boolean

op:gYear-equal($operand1 as xs:gYear, $operand2 as xs:gYear) as xs:boolean

op:gYearMonth-equal($operand1 as xs:gYearMonth, $operand2 as xs:gYearMonth) as xs:boolean

op:hexBinary-equal($value1 as xs:hexBinary, $value2 as xs:hexBinary) as xs:boolean

fn:id($srcval as xs:string*) as element*

fn:idref($srcval as xs:string*) as node*

fn:implicit-timezone() as xs:dayTimeDuration?

fn:index-of($seqParam as xs:anyAtomicType*, $srchParam as xs:anyAtomicType) as xs:integer*

fn:index-of($seqParam as xs:anyAtomicType*, $srchParam as xs:anyAtomicType, $collationLiteral as xs:string) as xs:integer*

fn:input() as node*

fn:insert-before($target as item*, $position as xs:integer, $inserts as item*) as item*

op:intersect($parameter1 as node*, $parameter2 as node*) as node*

fn:item-at($seqParam as item*, $posParam as integer) as item?

fn:lang($testlang as xs:string) as xs:boolean

fn:last() as xs:integer?

fn:local-name() as xs:string

fn:local-name($srcval as node?) as xs:string

fn:lower-case($srcval as xs:string?) as xs:string?

fn:matches($input as xs:string?, $pattern as xs:string) as xs:boolean?

fn:matches($input as xs:string?, $pattern as xs:string, $flags as xs:string) as xs:boolean?

fn:max($srcval as xdt:anyAtomicType*) as xdt:anyAtomicType?

fn:max($srcval as xdt:anyAtomicType*, $collationLiteral as string) as xdt:anyAtomicType?

fn:min($srcval as xdt:anyAtomicType*) as xdt:anyAtomicType?

fn:min($srcval as xdt:anyAtomicType*, $collationLiteral as string) as xdt:anyAtomicType?

op:multiply-dayTimeDuration($srcval1 as xdt:dayTimeDuration, $srcval2 as xs:decimal) as xdt:dayTimeDuration

op:multiply-yearMonthDuration($srcval1 as xdt:yearMonthDuration, $srcval2 as xs:decimal) as xdt:yearMonthDuration

fn:name() as xs:string

fn:name($srcval as node?) as xs:string

fn:namespace-uri() as xs:string

fn:namespace-uri($srcval as node?) as xs:string

op:node-after($parameter1 as node, $parameter2 as node) as xs:boolean

op:node-before($parameter1 as node, $parameter2 as node) as xs:boolean

op:node-equal($parameter1 as node, $parameter2 as node) as xs:boolean

fn:node-kind($srcval as node) as xs:string

fn:node-name($srcval as node) as xs:QName?

fn:normalize-space() as xs:string?

fn:normalize-space(

$srcval as xs:string?

) as xs:string?

fn:normalize-unicode($srcval as xs:string?) as xs:string?

fn:normalize-unicode($srcval as xs:string?, $normalizationForm as xs:string) as xs:string?

fn:not($srcval as item*) as xs:boolean

op:NOTATION-equal($srcval1 as xs:NOTATION, $srcval2 as xs:NOTATION) as xs:boolean

fn:number() as xs:double

fn:number($srcval as item?) as xs:double

op:numeric-add($operand1 as numeric, $operand2 as numeric) as numeric

op:numeric-divide($operand1 as numeric, $operand2 as numeric) as numeric

op:numeric-equal($operand1 as numeric, $operand2 as numeric) as xs:boolean

op:numeric-greater-than($operand1 as numeric, $operand2 as numeric) as xs:boolean

op:numeric-integer-divide($operand1 as xs:integer, $operand2 as xs:integer) as xs:integer

op:numeric-less-than($operand1 as numeric, $operand2 as numeric) as xs:boolean

op:numeric-mod($operand1 as numeric, $operand2 as numeric) as numeric

op:numeric-multiply($operand1 as numeric, $operand2 as numeric) as numeric

op:numeric-subtract($operand1 as numeric, $operand2 as numeric) as numeric

op:numeric-unary-minus($operand as numeric) as numeric

op:numeric-unary-plus($operand as numeric) as numeric

fn:one-or-more($srcval as item*) as item+

fn:position() as xs:integer?

op:QName-equal($srcval1 as xs:QName, $srcval2 as xs:QName) as xs:boolean

fn:remove($target as item*, $position as xs:integer) as item*

fn:replace($input as xs:string?, $pattern as xs:string, $replacement as xs:string) as xs:string?

fn:replace($input as xs:string?, $pattern as xs:string, $replacement as xs:string, $flags as xs:string) as xs:string?

fn:resolve-QName($qname as xs:string, $element as element) as xs:QName

fn:resolve-uri($relative as xs:string) as xs:string

fn:resolve-uri($relative as xs:string, $base as anyURI) as xs:string

fn:root() as node

fn:root($srcval as node) as node

fn:round($srcval as numeric?) as numeric?

fn:round-half-to-even($srcval as numeric?) as numeric?

fn:round-half-to-even($srcval as numeric?, $precision as integer) as numeric?

fn:sequence-node-identical($parameter1 as node*, $parameter2 as node*) as xs:boolean?

fn:starts-with($operand1 as xs:string?, $operand2 as xs:string?) as xs:boolean?

fn:starts-with($operand1 as xs:string?, $operand2 as xs:string?, $collationLiteral as xs:string) as xs:boolean?

fn:string() as xs:string

fn:string($srcval as item?) as xs:string

fn:string-join($operand1 as xs:string*, $operand2 as xs:string) as xs:string

fn:string-length() as xs:integer?

fn:string-length(

$srcval as xs:string?

) as xs:integer?

fn:string-pad($padString as xs:string?, $padCount as xs:integer) as xs:string?

fn:string-to-codepoints($srcval as xs:string) as xs:integer*

fn:subsequence($sourceSeq as item*, $startingLoc as xs:double) as item*

fn:subsequence($sourceSeq as item*, $startingLoc as xs:double, $length as xs:double) as item*

fn:substring($sourceString as xs:string?, $startingLoc as xs:double) as xs:string?

fn:substring($sourceString as xs:string?, $startingLoc as xs:double, $length as xs:double) as xs:string?

fn:substring-after($operand1 as xs:string?, $operand2 as xs:string?) as xs:string?

fn:substring-after($operand1 as xs:string?, $operand2 as xs:string?, $collationLiteral as xs:string) as xs:string?

fn:substring-before($operand1 as xs:string?, $operand2 as xs:string?) as xs:string?

fn:substring-before($operand1 as xs:string?, $operand2 as xs:string?, $collationLiteral as xs:string) as xs:string?

op:subtract-dates($srcval1 as xs:date, $srcval2 as xs:date) as xdt:dayTimeDuration

fn:subtract-dateTimes-yielding-dayTimeDuration($srcval1 as xs:dateTime, $srcval2 as xs:dateTime) as xdt:dayTimeDuration

fn:subtract-dateTimes-yielding-yearMonthDuration($srcval1 as xs:dateTime, $srcval2 as xs:dateTime) as xdt:yearMonthDuration

op:subtract-dayTimeDuration-from-date($srcval1 as xs:date, $srcval2 as xdt:dayTimeDuration) as xs:date

op:subtract-dayTimeDuration-from-dateTime($srcval1 as xs:dateTime, $srcval2 as xs:dayTimeDuration) as xs:dateTime

op:subtract-dayTimeDuration-from-time($srcval1 as xs:time, $srcval2 as xs:dayTimeDuration) as xs:time

op:subtract-dayTimeDurations($srcval1 as xdt:dayTimeDuration, $srcval2 as xdt:dayTimeDuration) as xdt:dayTimeDuration

op:subtract-times($srcval1 as xs:time, $srcval2 as xs:time) as xdt:dayTimeDuration

op:subtract-yearMonthDuration-from-date($srcval1 as xs:date, $srcval2 as xdt:yearMonthDuration) as xs:date

op:subtract-yearMonthDuration-from-dateTime($srcval1 as xs:dateTime, $srcval2 as xdt:yearMonthDuration) as xs:dateTime

op:subtract-yearMonthDurations($srcval1 as xdt:yearMonthDuration, $srcval2 as xdt:yearMonthDuration) as xdt:yearMonthDuration

fn:sum($srcval as xdt:anyAtomicType*) as xdt:anyAtomicType?

op:time-equal($operand1 as xs:time, $operand2 as xs:time) as xs:boolean

op:time-greater-than($operand1 as xs:time, $operand2 as xs:time) as xs:boolean

op:time-less-than($operand1 as xs:time, $operand2 as xs:time) as xs:boolean

op:to($firstval as xs:integer, $lastval as xs:integer) as xs:integer+

fn:tokenize($input as xs:string?, $pattern as xs:string) as xs:string*

fn:tokenize($input as xs:string?, $pattern as xs:string, $flags as xs:string) as xs:string*

fn:trace($value as item*, $label as xs:string) as item*

fn:translate($srcval as xs:string?, $mapString as xs:string?, $transString as xs:string?) as xs:string?

fn:true() as xs:boolean

op:union($parameter1 as node*, $parameter2 as node*) as node*

fn:unordered($sourceSeq as item*) as item*

fn:upper-case($srcval as xs:string?) as xs:string?

op:yearMonthDuration-equal($operand1 as xdt:yearMonthDuration, $operand2 as xdt:yearMonthDuration) as xs:boolean

op:yearMonthDuration-greater-than($operand1 as xdt:yearMonthDuration, $operand2 as xdt:yearMonthDuration) as xs:boolean

op:yearMonthDuration-less-than($operand1 as xdt:yearMonthDuration, $operand2 as xdt:yearMonthDuration) as xs:boolean

fn:zero-or-one($srcval as item*) as item?

XQuery 1.0 and XPath 2.0 Functions and Operators

W3C Working Draft 02 May 2003

Abstract

Status of this Document

Table of Contents

Appendices

1 Introduction

1.1 Terminology

1.2 Datatypes

1.3 xdt:anyAtomicType and xdt:untypedAtomic

1.3.1 xdt:anyAtomicType

1.3.2 xdt:untypedAtomic

1.4 xs:dateTime, xs:date and xs:time values

1.4.1 Examples

1.5 Syntax

1.6 Notations

1.7 Namespace Prefix

2 Accessors

2.1 fn:node-kind

2.2 fn:node-name

2.3 fn:string

2.4 fn:data

2.5 fn:base-uri

2.6 fn:document-uri

3 The Error Function

3.1 Examples

4 The Trace Function

4.1 Examples

5 Constructor Functions

5.1 Constructor Functions for XML Schema Built-in Types

5.2 Constructor Functions for User-Defined Types

6 Functions and Operators on Numerics

6.1 Numeric Types

6.2 Operators on Numeric Values

6.2.1 op:numeric-add

6.2.2 op:numeric-subtract

6.2.3 op:numeric-multiply

6.2.4 op:numeric-divide

6.2.5 op:numeric-integer-divide

6.2.5.1 Examples

6.2.6 op:numeric-mod

6.2.6.1 Examples

6.2.7 op:numeric-unary-plus

6.2.8 op:numeric-unary-minus

6.3 Comparison of Numeric Values

6.3.1 op:numeric-equal

6.3.2 op:numeric-less-than

6.3.3 op:numeric-greater-than

6.4 Functions on Numeric Values

6.4.1 fn:floor

6.4.1.1 Examples

6.4.2 fn:ceiling

6.4.2.1 Examples

6.4.3 fn:round

6.4.3.1 Examples

6.4.4 fn:round-half-to-even

6.4.4.1 Examples

7 Functions on Strings

7.1 String Types

7.2 Functions to Assemble and Disassemble Strings

7.2.1 fn:codepoints-to-string

7.2.2 fn:string-to-codepoints

7.3 Equality and Comparison of Strings

7.3.1 fn:compare

7.3.1.1 Examples

7.4 Functions on String Values

7.4.1 fn:concat

7.4.1.1 Examples

7.4.2 fn:string-join

7.4.2.1 Examples

7.4.3 fn:starts-with

7.4.3.1 Examples

7.4.4 fn:ends-with

7.4.4.1 Examples

7.4.5 fn:contains

7.4.6 fn:substring

7.4.6.1 Examples

7.4.7 fn:string-length

7.4.7.1 Examples

7.4.8 fn:substring-before