XQuery 1.0 and XPath 2.0 Functions and Operators

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 two datatypes 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/xpath-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/xpath-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:string arguments. In addition, the functions defined in 6 Functions and Operators on Numerics that take numeric arguments take arguments of type xs:integer, xs:decimal, xs:float or xs:double. Operators such as "+" may be overloaded.

1.6 Notations

This document defines a few new datatypes, constructor functions and functions that take typed values as arguments. Some of 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 describe the 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 semantic rules. These rules are 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 type of 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 languages and 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	`xs:string`
`fn:node-name`	`node-name`	any kind of node	zero or one `xs:QName`
`fn:string`	`string-value`	item	`xs:string`
`fn:data`	`typed-value`	zero or more nodes	a sequence of atomic values
`fn:base-uri`	`base-uri`	Element, document or PI node or no argument	zero or one `xs:string`
`fn:document-uri`	`document-uri`	Node	zero or one `xs:string`

2.1 fn:node-kind

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

This function returns a xs:string representing 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-value of 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:double values is not backwards-compatible with the representation of number values in [XPath 1.0]. Ordinary xs:double values 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 sequence of atomic values.

The result of fn:data is the sequence of atomic values produced by applying the following rules to each item in $srcval:

If the item is an atomic value, it is returned.
If the item is a node, fn:data() returns the typed value of the node 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?

Returns the value of the base-uri property for $srcval as defined by the accessor function dm:base-uri for that kind of node in [XQuery 1.0 and XPath 2.0 Data Model]. Document, element and processing-instruction nodes have a base-uri property. If that property is non-empty, its value is returned. The base-uri of all other node types is the empty sequence.

If the accessor is called on a node that does not have a base-uri property, or whose base-uri property is empty, the base-uri of that node's parent is returned. If the node has no parent, the empty sequence is returned.

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

This version of the function returns the value of the base-uri property from the static context using the preceding rules.

2.6 fn:document-uri

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

Returns the value of the document-uri property for $srcval as defined by the accessor function dm:document-uri in [XQuery 1.0 and XPath 2.0 Data Model]. The empty sequence is returned if the node does not 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.

If the document-uri property of $srcval is not the 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:untypedAtomic and 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 type in 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.

Operators	Meaning
`op:numeric-add`	Addition
`op:numeric-subtract`	Subtraction
`op:numeric-multiply`	Multiplication
`op:numeric-divide`	Division
`op:numeric-integer-divide`	Integer division
`op:numeric-mod`	Modulus
`op:numeric-unary-plus`	Unary plus
`op:numeric-unary-minus`	Unary minus (negation)

The arguments and return types for the arithmetic operators are the basic numeric types: xs:integer, xs:decimal, xs:float and 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:decimal if called with two xs:integer operands.)

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)`	`xs:integer` (except for `op:numeric-divide(integer, integer)`, which returns `xs:decimal`)
`op:operation(xs:decimal, xs:decimal)`	`xs:decimal`
`op:operation(xs:float, xs:float)`	`xs:float`
`op:operation(xs:double, xs:double)`	`xs:double`
`op:operation(xs:integer)`	`xs:integer`
`op:operation(xs:decimal)`	`xs:decimal`
`op:operation(xs:float)`	`xs:float`
`op:operation(xs:double)`	`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 loss of 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 overflow and underflow situations during arithmetic operations conforming implementations ·must· behave as follows:

For xs:float and xs:double operations, overflow behavior ·must· be conformant with [IEEE 754-1985]. This specification allows a number of options:
- Raising an error ("overflow on float or double operation") via an overflow trap.
- Returning INF or -INF.
- Returning the largest (positive or negative) non-infinite number.
For xs:float and xs:double operations, 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 underflow trap.
- Returning 0.0E0 or +/- 2**Emin or a denormalized value; where Emin is the smallest possible xs:float or xs:double exponent.
For xs:decimal operations, overflow behavior ·must· raise an error ("overflow on decimal operation"). On underflow, 0.0 must 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 error and 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-divide and 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:integer value 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 function returns the remainder resulting from dividing $operand1, the dividend, by $operand2, the divisor. The operation a mod b for operands that are xs:integer or xs:decimal, or types derived from them, produces a result such that (a/b)*b+(a mod b) is equal to a and the magnitude of the result is always less than the magnitude of the divisor. This identity holds even in the special case that the dividend is the negative integer of largest possible magnitude for its type and the 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 result obeys (a/b)*b+(a mod b) = a. Division is 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 defines the 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.

Operator	Meaning
`op:numeric-equal`	Equality comparison
`op:numeric-less-than`	Less-than comparison
`op:numeric-greater-than`	Greater-than comparison

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-NaN values; negative infinity is less than all other non-NaN values. If $operand1 or $operand2 is 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-NaN values; negative infinity is less than all other non-NaN values. If $operand1 or $operand2 is 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 type of 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, if the argument is positive or negative infinity, positive or negative infinity is returned.

Function	Meaning
`fn:floor`	Returns the largest number with no fractional part that is less than or equal to the argument.
`fn:ceiling`	Returns the smallest number with no fractional part that is greater than or equal to the argument.
`fn:round`	Rounds to the nearest number with no fractional part.
`fn:round-half-to-even`	Takes a number and a precision and returns a number rounded to the given precision. If the fractional part is exactly half, the result is the number whose least significant digit is 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 part that 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. If the 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 part that is not less than the value of $srcval.

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 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 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 same result 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 $srcval that 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 $srcval is 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 corresponding to 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 to 0.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:string datatype 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`	Creates an `xs:string` from a sequence of code points.
`fn:string-to-codepoints`	Returns the sequence of code points that constitute an `xs:string`.

7.2.1 fn:codepoints-to-string

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

Creates an xs:string from 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:string or a type derived from xs:string are 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/xpath-functions/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:

All collations 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 such as 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 occasionally lead to surprises. For example, consider a collation that treats "Jaeger" and "Jäger" as equal. It might do this by treating "ä" as representing two collation units, in which case the expression fn:contains("Jäger", "eg") will return true. Alternatively, a collation might treat "ae" as a single collation unit, in which case the expression fn:contains("Jaeger", "eg") will return false. The results 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().

Function	Meaning
`fn:compare`	Compares two `xs:string`s; a collation may optionally be specified

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.

Function	Meaning
`fn:concat`	Concatenates two or more `xs:string`s.
`fn:string-join`	Accepts a sequence of `xs:string`s and returns them concatenated together using an optional separator.
`fn:starts-with`	Indicates whether the value of one `xs:string` begins with the characters in another `xs:string`.
`fn:ends-with`	Indicates whether the value of one `xs:string` ends with the characters in another `xs:string`.
`fn:contains`	Indicates whether one `xs:string` contains another `xs:string`. A collation may optionally be specified.
`fn:substring`	Returns the `xs:string` located at a specified place in an `xs:string`.
`fn:string-length`	Returns the length of the argument.
`fn:substring-before`	Returns the characters of one `xs:string` that precede in that `xs:string` the characters in another `xs:string`. A collation may optionally be specified.
`fn:substring-after`	Returns the characters of one `xs:string` that follow in that `xs:string` the characters in another `xs:string`. A collation may optionally be specified.
`fn:normalize-space`	Returns the whitespace-normalized value of the argument.
`fn:normalize-unicode`	Returns the normalized value of the first argument in the normalization form specified by the second argument.
`fn:upper-case`	Returns the upper-cased value of the argument.
`fn:lower-case`	Returns the lower-cased value of the argument.
`fn:translate`	Returns the first `xs:string` argument with occurrences of characters in the second argument replaced by the character at the corresponding position in the third argument.
`fn:string-pad`	Returns an `xs:string` composed of as many copies of its first argument as specified in its second argument.
`fn:escape-uri`	Returns the string representing an `xs:anyURI` value with certain characters escaped as specified in [RFC 2396] and [RFC 2732].

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:strings as arguments. Returns the xs:string that is the concatenation of the values of its arguments. The resulting xs:string might not be normalized according to any 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:string arguments 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:string created 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:boolean indicating 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 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, 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.

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:boolean indicating 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 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, the empty sequence is returned.

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 $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, the empty sequence is returned.

Otherwise, returns an xs:boolean indicating whether or not the value of $operand1 contains (at the beginning, at the end, or anywhere within) a string equal to the value of $operand2 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.

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, returns the 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 point above 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 2 and 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:integer equal 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 point above 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 $srcval with 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, returns the 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.

Conforming implementations ·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, returns the 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, returns the 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 value in 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 point above 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 the empty sequence.

Otherwise, returns an xs:string consisting of $padCount copies of $padString concatenated together without any 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

This function applies the URI escaping rules defined in section 2 of [RFC 2396] as amended by [RFC 2732] to the string supplied as $uri-part, which typically represents all or part of a URI. The effect of the function is to replace any special character in the string by an escape sequence of the form %xx%yy..., where xxyy... is the hexadecimal 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 letters A-Z, digits 0-9 and the characters referred to in [RFC 2396] as "marks": specifically, "-" | "_" | "." | "!" | "~" | "*" | "'" | "(" | ")". The "%" character itself is escaped only if it is not followed by two hexadecimal digits (that is, 0-9, a-f and A-F).

If $escape-reserved is 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 define whether escaped URIs 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 using the upper-case letters A-F.

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

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 String Functions that Use Pattern Matching

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

Function	Meaning
`fn:matches`	Returns an `xs:boolean` value that indicates whether the value of the first argument is matched by the regular expression that is the value of the second argument.
`fn:replace`	Returns the value of the first argument with every substring 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 omits some facilities that are widely-used with languages such as Perl. This section, 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 substring 1, the second identifies captured substring 2, 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.5 of [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:string that is obtained by replacing all non-overlapping substrings of $input that match the given $pattern with an occurrence of the $replacement string.

If two overlapping substrings of $input both match the $pattern, then only the first one (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 value of $flags is invalid according to the rules described in section 7.5.1 Regular Expression Syntax.

An error is raised ("Regular expression matches 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 $input is the empty sequence, the result is the empty sequence.

If the supplied $pattern matches a zero-length string, the fn:tokenize() function breaks the string into its component characters. The nth character in the $input string becomes the nth string in the result sequence; each string in the result sequence has a string length of one.

If a separator occurs at the start of the $input string, the result sequence will start with a zero-length string. Zero-length strings will also occur in the result sequence if a separator occurs at the end of the $input string, or if two adjacent substrings match the supplied $pattern.

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

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

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.4.1 Examples

fn:tokenize("The cat 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.

Function	Meaning
`fn:true`	The xs:boolean value 'true'.
`fn:false`	The xs:boolean value 'false'.

8.1.1 fn:true

fn:true() as xs:boolean

Returns the xs:boolean value true.

8.1.1.1 Examples

fn:true() returns true.

8.1.2 fn:false

fn:false() as xs:boolean

Returns the xs:boolean value 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]:

Operator	Meaning
`op:boolean-equal`	Equality of `xs:boolean` values
`op:boolean-less-than`	A less-than operator on `xs:boolean` values: `false` is less than `true`.
`op:boolean-greater-than`	A greater-than operator on `xs:boolean` values: `true` is greater than `false`.

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:boolean values.

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:boolean values.

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" operators on xs:boolean values.

8.3 Functions on Boolean Values

The following functions are defined on boolean values:

Function	Meaning
`fn:not`	Inverts the `xs:boolean` value of the argument.

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:duration that 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 the limits ·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

Two totally ordered subtypes of xs:duration are 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/xpath-datatypes.

Note:

The W3C XML Query Working Group has requested the W3C XML Schema Working Group that these two subtypes of xs:duration be 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:yearMonthDuration is derived from xs:duration by restricting its lexical representation to contain only the year and month components. The value space of xdt:yearMonthDuration is the set of xs:integer month values. The year and month components of xdt:yearMonthDuration correspond to the Gregorian year and month components defined in section 5.5.3.2 of [ISO 8601], respectively.

xdt:yearMonthDuration is derived from xs:duration as 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:yearMonthDuration is 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:yearMonthDuration of 1 year, 2 months, one would write: P1Y2M. One could also indicate a xdt:yearMonthDuration of 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:yearMonthDuration lexical 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:yearMonthDuration restricts the value of the months component to xs:integer values 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:integer months 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, if the 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:yearMonthDuration in the manner described above be called V(d). Then for two xdt:yearMonthDuration values x and y, x > y if and only if V(x) > V(y). The order relation on yearMonthDuration is a total order.

9.2.2 xdt:dayTimeDuration

[Definition] xdt:dayTimeDuration is derived from xs:duration by restricting its lexical representation to contain only the day, hour, minute and second components. The value space of xdt:dayTimeDuration is the set of fractional second values. The components of xdt:dayTimeDuration correspond to the day, hour, minute and second components defined in Section 5.5.3.2 of [ISO 8601], respectively. xdt:dayTimeDuration is derived from xs:duration as 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:dayTimeDuration is 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:dayTimeDuration lexical 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:dayTimeDuration restricts the value of the hours component to xs:integer values between 0 and 23, both inclusive; the value of the minutes component to xs:integer values between 0 and 59; both inclusive; and the value of the seconds component to xs:decimal valued 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, if all 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:dayTimeDuration in the manner described above be called V(d). Then for two xdt:dayTimeDuration values x and y, x > y if and only if V(x) > V(y). The order relation on xdt:dayTimeDuration is a total order.

9.3 Comparisons of Duration, Date and Time Values

Operator	Meaning
`op:yearMonthDuration-equal`	Equality comparison on `xdt:yearMonthDuration` values
`op:yearMonthDuration-less-than`	Less-than comparison on `xdt:yearMonthDuration` values
`op:yearMonthDuration-greater-than`	Greater-than comparison on `xdt:yearMonthDuration` values
`op:dayTimeDuration-equal`	Equality comparison on `xdt:dayTimeDuration` values
`op:dayTimeDuration-less-than`	Less-than comparison on `xdt:dayTimeDuration` values
`op:dayTimeDuration-greater-than`	Greater-than comparison on `xdt:dayTimeDuration` values
`op:dateTime-equal`	Equality comparison on `xs:dateTime` values
`op:dateTime-less-than`	Less-than comparison on `xs:dateTime` values
`op:dateTime-greater-than`	Greater-than comparison on `xs:dateTime` values
`op:date-equal`	Equality comparison on `xs:date` values
`op:date-less-than`	Less-than comparison on `xs:date` values
`op:date-greater-than`	Greater-than comparison on `xs:date` values
`op:time-equal`	Equality comparison on `xs:time` values
`op:time-less-than`	Less-than comparison on `xs:time` values
`op:time-greater-than`	Greater-than comparison on `xs:time` values
`op:gYearMonth-equal`	Equality comparison on `xs:gYearMonth` values
`op:gYear-equal`	Equality comparison on `xs:gYear` values
`op:gMonthDay-equal`	Equality comparison on `xs:gMonthDay` values
`op:gMonth-equal`	Equality comparison on `xs:gMonth` values
`op:gDay-equal`	Equality comparison on `xs:gDay` values

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:duration and the date and time datatypes is not a total order but, rather, a partial order. For this reason, no functions 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 values the value is defined as a tuple. Comparison operators on these three datatypes operate on the first, or normalized value, part of the tuple and disregard the second, or timezone, part of the tuple. If the timezone part 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:yearMonthDuration values.

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:yearMonthDuration values.

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:yearMonthDuration values.

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:dayTimeDuration values.

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:dayTimeDuration values.

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:dayTimeDuration values.

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 the normalized value of $operand1 is equal to the normalized value of $operand2. Returns false otherwise.

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

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 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 ond xs:dateTime values.

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 the normalized value of $operand1 is greater than the normalized value of $operand2. Returns false otherwise.

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

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 the normalized value of $operand1 is equal to the normalized value of $operand2. Returns false otherwise.

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

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 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:date values.

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 the normalized value of $operand1 is greater than the normalized value of $operand2. Returns false otherwise.

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

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 the normalized value of $operand1 is equal to the normalized value of $operand2. Returns false otherwise.

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

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:time values.

9.3.14.1 Examples

Assume that 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 true since it compares the normalized values 28:00:00Z (23:00:00 adjusted 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 the normalized value of $operand1 is greater than the normalized value of $operand2. Returns false otherwise.

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

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:gYearMonth values.

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:gYear values.

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:gMonthDay values.

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:gMonth values.

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:gDay values.

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`	Returns the year component of an `xdt:yearMonthDuration` value.
`fn:get-months-from-yearMonthDuration`	Returns the months component of an `xdt:yearMonthDuration` value.
`fn:get-days-from-dayTimeDuration`	Returns the days component of an `xdt:dayTimeDuration` value.
`fn:get-hours-from-dayTimeDuration`	Returns the hours component of an `xdt:dayTimeDuration` value.
`fn:get-minutes-from-dayTimeDuration`	Returns the minutes component of an `xdt:dayTimeDuration` value.
`fn:get-seconds-from-dayTimeDuration`	Returns the seconds component of an `xdt:dayTimeDuration` value.
`fn:get-year-from-dateTime`	Returns the year from an `xs:dateTime` value.
`fn:get-month-from-dateTime`	Returns the month from an `xs:dateTime` value.
`fn:get-day-from-dateTime`	Returns the day from an `xs:dateTime` value.
`fn:get-hours-from-dateTime`	Returns the hours from an `xs:dateTime` value.
`fn:get-minutes-from-dateTime`	Returns the minutes from an `xs:dateTime` value.
`fn:get-seconds-from-dateTime`	Returns the seconds from an `xs:dateTime` value.
`fn:get-timezone-from-dateTime`	Returns the timezone from an `xs:dateTime` value.
`fn:get-year-from-date`	Returns the year from an `xs:date` value.
`fn:get-month-from-date`	Returns the month from an `xs:date` value.
`fn:get-day-from-date`	Returns the day from an `xs:date` value.
`fn:get-timezone-from-date`	Returns the timezone from an `xs:date` value.
`fn:get-hours-from-time`	Returns the hours from an `xs:time` value.
`fn:get-minutes-from-time`	Returns the minutes from an `xs:time` value.
`fn:get-seconds-from-time`	Returns the seconds from an `xs:time` value.
`fn:get-timezone-from-time`	Returns the timezone from an `xs:time` value.

9.4.1 fn:get-years-from-yearMonthDuration

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

Returns an xs:integer representing 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:integer representing 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:integer representing 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:integer representing 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:integer representing 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 an xs:decimal representing 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:integer representing 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:integer between 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:integer between 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 component in 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:integer value 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 an xs:decimal value 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 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:dayTimeDuration that 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:integer representing 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:integer between 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:integer between 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 in the normalized value of $srcval. The result is an xdt:dayTimeDuration that 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:dayTimeDuration with 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:integer between 0 and 23, both inclusive, representing the value of the hours component in the normalized value of $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:integer value between 0 to 59, both inclusive, representing the value of the minutes 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:decimal value 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:dayTimeDuration representing the timezone component of $srcval. The result is a xdt:dayTimeDuration that 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:dayTimeDuration whose value is -PT5H.

9.5 Arithmetic Functions on xdt:yearMonthDuration and xdt:dayTimeDuration

Function	Meaning
`op:add-yearMonthDurations`	Adds two `xdt:yearMonthDuration`s. Returns an `xdt:yearMonthDuration`.
`op:subtract-yearMonthDurations`	Subtracts one `xdt:yearMonthDuration` from another. Returns an `xdt:yearMonthDuration`.
`op:multiply-yearMonthDuration`	Multiplies a `xdt:yearMonthDuration` by an `xs:decimal`. Returns an `xdt:yearMonthDuration`.
`op:divide-yearMonthDuration`	Divides an `xdt:yearMonthDuration` by an `xs:decimal`. Returns an `xdt:yearMonthDuration`.
`op:add-dayTimeDurations`	Adds two `xdt:dayTimeDurations`. Returns an `xdt:dayTimeDuration`.
`op:subtract-dayTimeDurations`	Subtracts one `xdt:dayTimeDuration` from another. Returns an `xdt:dayTimeDuration`.
`op:multiply-dayTimeDuration`	Multiplies an `xdt:dayTimeDuration` by a `xs:decimal`. Returns an `xdt:dayTimeDuration`.
`op:divide-dayTimeDuration`	Divides an `xdt:dayTimeDuration` by an `xs:decimal`. Returns an `xdt: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:yearMonthDuration values.

9.5.1.1 Examples

op:add-yearMonthDurations(xdt:yearMonthDuration("P2Y11M"), xdt:yearMonthDuration("P3Y3M")) returns a xdt:yearMonthDuration value 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:yearMonthDuration values.

9.5.2.1 Examples

op:subtract-yearMonthDurations(xdt:yearMonthDuration("P2Y11M"), xdt:yearMonthDuration("P3Y3M")) returns a xdt:yearMonthDuration value 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:yearMonthDuration values.

9.5.3.1 Examples

op:multiply-yearMonthDuration(xdt:yearMonthDuration("P2Y11M"), 2.3) returns a xdt:yearMonthDuration value 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:yearMonthDuration values.

9.5.4.1 Examples

op:divide-yearMonthDuration(xdt:yearMonthDuration("P2Y11M"), 1.5) returns a xdt:yearMonthDuration value 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:dayTimeDuration values.

9.5.5.1 Examples

op:add-dayTimeDurations(xdt:dayTimeDuration("P2DT12H5M"), xdt:dayTimeDuration("P5DT12H")) returns a xdt:dayTimeDuration value 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:dayTimeDuration values.

9.5.6.1 Examples

op:subtract-dayTimeDurations(xdt:dayTimeDuration("P2DT12H"), xdt:dayTimeDuration("P1DT10H30M")) returns a xdt:dayTimeDuration value corresponding to 1 day, .5 hour and 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:dayTimeDuration values.

9.5.7.1 Examples

op:multiply-dayTimeDuration(xdt:dayTimeDuration("PT2H10M"), 2.1) returns a xdt:dayTimeDuration value 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:dayTimeDuration values.

9.5.8.1 Examples

op:divide-dayTimeDuration(xdt:yearMonthDuration("P1DT2H30M10.5S"), 1.5) returns a xdt:dayTimeDuration value 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` value to a specific timezone, or to no timezone at all.
`fn:adjust-date-to-timezone`	Adjusts an `xs:date` value to a specific timezone, or to no timezone at all.
`fn:adjust-time-to-timezone`	Adjusts an `xs:time` value to a specific timezone, or to no timezone at all.

For purposes of timezone adjustment, an xs:date is treated as an xs:dateTime with 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:dateTime value to a specific timezone, or to no timezone at all. If $timezone is the empty sequence, returns an xs:dateTime without a timezone. Otherwise, returns an xs:dateTime with a timezone.

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

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

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

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

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

If $srcval has a timezone component and $timezone is the empty sequence, then the result is $srcval without its timezone component.

If $srcval has a timezone component and $timezone is not the empty sequence, then the result is an xs:dateTime value with a timezone component of $timezone that 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:date value to a specific timezone, or to no timezone at all. If $timezone is the empty sequence, returns an xs:date without a timezone. Otherwise, returns an xs:date with a timezone.

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

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

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

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

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

If $srcval has a timezone component and $timezone is the empty sequence, then the result is $srcval without its timezone component.

If $timezone is 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"), ()) returns 2002-03-07
fn:adjust-date-to-timezone(xs:date("2002-03-07-07:00"), ()) returns 2002-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?`

Adjusts an xs:time value to a specific timezone, or to no timezone at all. If $timezone is the empty sequence, returns an xs:time without a timezone. Otherwise, returns an xs:time with a timezone.

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

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

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

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

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

If $srcval has a timezone component and $timezone is the empty sequence, then the result is $srcval without its timezone component.

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

Let $srcdt be an xs:dateTime value, with an arbitrary date for the date component and time and timezone components that are the same as the time and timezone components of $srcval.
Let $r be the result of evaluating

fn:adjust-dateTime-to-timezone($srcdt, $timezone)
The result of this function will be 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:date or an xs:time value. 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:date or xs:time that does not contain 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.

Function	Meaning
`fn:subtract-dateTimes-yielding-yearMonthDuration`	Returns the difference between two `xs:dateTime`s as an `xdt:yearMonthDuration`.
`fn:subtract-dateTimes-yielding-dayTimeDuration`	Returns the difference between two `xs:dateTimes` as an `xdt:dayTimeDuration`.
`op:subtract-dates`	Returns the difference between two `xs:date`s as an `xdt:dayTimeDuration`.
`op:subtract-times`	Returns the difference between two `xs:time`s as an `xdt:dayTimeDuration`.
`op:add-yearMonthDuration-to-dateTime`	Returns the end of a time period by adding an `xdt:yearMonthDuration` to the `xs:dateTime` that starts the period.
`op:add-dayTimeDuration-to-dateTime`	Returns the end of a time period by adding an `xdt:dayTimeDuration` to the `xs:dateTime` that starts the period.
`op:subtract-yearMonthDuration-from-dateTime`	Returns the beginning of a time period by subtracting an `xdt:yearMonthDuration` from the `xs:dateTime` that ends the period.
`op:subtract-dayTimeDuration-from-dateTime`	Returns the beginning of a time period by subtracting an `xdt:dayTimeDuration` from the `xs:dateTime` that ends the period.
`op:add-yearMonthDuration-to-date`	Returns the end of a time period by adding an `xdt:yearMonthDuration` to the `xs:date` that starts the period.
`op:add-dayTimeDuration-to-date`	Returns the end of a time period by adding an `xdt:dayTimeDuration` to the `xs:date` that starts the period.
`op:subtract-yearMonthDuration-from-date`	Returns the beginning of a time period by subtracting an `xdt:yearMonthDuration` from the `xs:date` that ends the period.
`op:subtract-dayTimeDuration-from-date`	Returns the beginning of a time period by subtracting an `xdt:dayTimeDuration` from the `xs:date` that ends the period.
`op:add-dayTimeDuration-to-time`	Adds the value of the hours, minutes and seconds components of an `xdt:dayTimeDuration` to an `xs:time` value.
`op:subtract-dayTimeDuration-from-time`	Subtracts the value of the hours, minutes and seconds components of an `xdt:dayTimeDuration` to an `xs:time` value.

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:yearMonthDuration that 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:dateTime values 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:yearMonthDuration plus 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:dayTimeDuration in seconds. Then, starting from $srcval2, the maximum number of months in the duration are calculated. If there is a remaining number of days, they are 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:yearMonthDuration value 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:dayTimeDuration that 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

Assume that the evaluation context 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:dayTimeDuration value 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`

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

9.7.3.1 Examples

op:subtract-dates(xs:date("2000-10-30"), xs:date("1999-11-28")) returns an xdt:dayTimeDuration value 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:time values.

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:dayTimeDuration value 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:dateTime computed 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:dateTime 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:dateTime and 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:dateTime value 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`

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:dateTime and 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:dateTime value 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:dateTime computed 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:dateTime returned 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:dateTime and 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:dateTime value 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:dateTime and xdt:dayTimeDuration values.

9.7.8.1 Examples

op:subtract-dayTimeDuration-from-dateTime(xs:dateTime("2000-10-30T11:12:00"), xdt:dayTimeDuration("P3DT1H15M")) returns an xs:dateTime value 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:date computed 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:date returned 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:date and xdt:yearMonthDuration values.

9.7.9.1 Examples

op:add-yearMonthDuration-to-date(xs:date("2000-10-30"), xdt:yearMonthDuration("P1Y2M")) returns the xs:date whose 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:date and xdt:dayTimeDuration values.

9.7.10.1 Examples

op:add-dayTimeDuration-to-date(xs:date("2000-10-30"), xdt:dayTimeDuration("P2DT2H30M0S")) returns the xs:date whose 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:date computed 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:date returned 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:date and xdt:yearMonthDuration values.

9.7.11.1 Examples

op:subtract-yearMonthDuration-from-date(xs:date("2000-10-30"), xdt:yearMonthDuration("P1Y2M")) returns the xs:date whose 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`

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:date and xdt:dayTimeDuration values.

9.7.12.1 Examples

op:subtract-dayTimeDuration-from-date(xs:date("2000-10-30"), xdt:dayTimeDuration("P3DT1H15M")) returns a xs:date whose 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:dayTimeDuration is 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:time and 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:dayTimeDuration is 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:time and 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 corresponding to 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.

Function	Meaning
`fn:resolve-QName`	Returns an `xs: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`	Returns 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:QName value (that is, an expanded QName) by taking an xs:string that has the lexical form of an xs:QName (a string in the form "prefix:local-name" or "local-name") and resolving it using the in-scope namespaces for a given element.

More specifically, the function searches the namespace nodes of $element for a node whose name matches the prefix of $qname, or the zero-length string if it has no prefix, and constructs an expanded QName whose local name is taken from the supplied $qname, and whose namespace URI is taken from the string value of the namespace node.

If the $qname has a prefix and if there is no namespace node for $element that matches this prefix, then an error is raised ("no namespace found for prefix").

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

10.1.1.1 Usage Note

Sometimes the requirement is to construct an xs:QName without using 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 requirement is to construct an xs:QName using the namespaces in the static context, then the xs:QName constructor should be used.

10.1.1.2 Examples

Assume that the element bound to $element has a single namespace node bound to the prefix eg.

fn:resolve-QName("hello", $element) returns a QName with local name "hello" that is in no namespace.
fn:resolve-QName("eg:myFunc", $element) returns an xs:QName whose namespace URI is specified by the namespace node corresponding 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

Returns an xs:QName with the namespace URI given in $paramURI and the local name in $paramLocal. If $paramURI is the empty string, it represents "no namespace".

10.1.2.1 Examples

fn:expanded-QName("http://www.example.com/example", "person") returns an xs: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].

Function	Meaning
`op:QName-equal`	Returns `true` if the local names and namespace URIs of the two arguments are equal.
`fn:get-local-name-from-QName`	Returns an `xs:string` representing the local part of the `xs:QName` argument.
`fn:get-namespace-from-QName`	Returns the namespace URI for the `xs:QName` argument. This may be the empty sequence if the `xs:QName` is in no namespace.
`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:string representing 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 prefix as an xs:NCName. For the default namespace, which has no prefix, it returns the zero-length string.

11 Functions and Operators for anyURI

This section specifies functions that take anyURI as arguments.

Function	Meaning
`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 undefined in 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:base64Binary and xs:hexBinary values. Comparisons take two operands of the same type; that is, both operands must be xs:base64Binary or both operands may be xs:hexBinary. Each returns a boolean value.

Function	Meaning
`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:hexBinary values.

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:base64Binary values.

13 Functions and Operators on NOTATION

13.1 Operators on NOTATION

This section discusses functions that take NOTATION as arguments.

Function	Meaning
`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

Function	Meaning
`fn:name`	Returns the name of the context node or the specified node as an `xs:string`.
`fn:local-name`	Returns the local name of the context node or the specified node as an `xs:NCName`.
`fn:namespace-uri`	Returns the namespace URI as an `xs:string` for the `xs:QName` of the argument node or the context node if the argument is omitted. This may be the zero-length string if the `xs:QName` is in no namespace.
`fn:number`	Returns the value of the context node or the specified item converted to an `xs:double`.
`fn:lang`	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 the argument.
`op:node-equal`	Returns `true` if the two arguments have the same identity.
`op:node-before`	Indicates whether one node appears before another node in document order.
`op:node-after`	Indicates whether one node appears after another node in document order.
`fn:root`	Returns the root of the tree to which the node argument belongs.

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:string that 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-length string 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:string whose 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-name accessor 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-QName is 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-QName to 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:string that 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:string whose 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:name accessor 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 is returned.

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

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

14.1.4.1 Examples

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

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
`fn:zero-or-one`	Returns the input sequence if it contains zero or one items. Raises an error otherwise.
`fn:one-or-more`	Returns the input sequence if it contains one or more items. Raises an error otherwise.
`fn:exactly-one`	Returns the input sequence if it contains exactly one item. Raises an error otherwise.
`fn:boolean`	Casts a sequence to an `xs:boolean`.
`op:concatenate`	Concatenates two sequences.
`fn:item-at`	Returns the item at the given index.
`fn:index-of`	Returns a sequence of `xs:integer`s, each of which is the index of a member of the sequence specified as the first argument that is equal to the atomic value that is the value of the second argument. If no members of the specified sequence are equal to the value of the second argument, the empty sequence is returned.
`fn:empty`	Indicates whether or not the provided sequence is empty.
`fn:exists`	Indicates whether or not the provided sequence is not empty.
`fn:distinct-nodes`	Returns a sequence in which all but one of a set of duplicate nodes, based on node identity, have been deleted. The order in which the distinct nodes are returned is ·implementation dependent·.
`fn:distinct-values`	Returns a sequence in which all but one of a set of duplicate values, based on value equality, have been deleted. The order in which the distinct values are returned is ·implementation dependent·.
`fn:insert-before`	Inserts an item or sequence of items at a specified position in a sequence.
`fn:remove`	Removes an item from a specified position in a sequence.
`fn:subsequence`	Returns the subsequence of a given sequence, identified by location.
`fn:unordered`	Indicates that the given sequence may be returned in any order.

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 $srcval if it contains zero or one items. Otherwise, raises an error ("fn:zero-or-one called with a sequence containing more than one item"). The type of 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 an error ("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 $srcval is 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:boolean value false.
The singleton xs:string value "". (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:double or xs:float value 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 positions within the sequence $seqParam of items that are equal to $srchParam.

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

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

The items in the sequence $seqParam are compared with $srchParam under the rules for the eq operator, using the selected collation when comparing strings. If the type of the items in $seqParam is not xs:string and $collationLiteral is specified, the collation is ignored. If an item compares equal, then the position of that item in the sequence $srchParam is included in the result. If the items are not comparable, then an error is raised ("Items not comparable").

If the value of $seqParam is the empty sequence, or if no item in $seqParam matches $srchParam, then the empty sequence is returned.

The first item in a sequence is at position 1, not position 0.

The result sequence is in ascending numeric order.

15.1.7.1 Examples

fn:index-of ((10, 20, 30, 40), 30) returns 3.
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 sequence of 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 does not have equality defined"). For detailed 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 error is 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:string and $collationLiteral is specified, the collation is 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 is greater 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.

For detailed 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

Function	Meaning
`fn:deep-equal`	Returns `true` if the two arguments have items that compare equal in corresponding positions.
`fn:sequence-node-identical`	Returns `true` if the two arguments have identical nodes in corresponding positions.
`op:union`	Returns the union of the two sequence arguments, eliminating duplicates.
`op:intersect`	Returns the intersection of the two sequence arguments, eliminating duplicates.
`op:except`	Returns the difference of the two sequence arguments, eliminating duplicates.

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 function returns false. Equality of corresponding items is determined based on the eq operator if they are atomic values and based on deep equality of nodes, as defined below, if they are nodes.

Returns true if both of its arguments are the empty sequence. Returns false if one, but not both, of its arguments is the empty sequence.

If equality is not defined for the types of two corresponding values the function returns false.

If $collationLiteral is not in the lexical space of xs:anyURI an error is 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 the items in $parameter1 and $parameter2 is not xs:string and $collationLiteral is specified, the collation is ignored.

15.2.1.1 Deep Equality of Nodes

The following (recursive) tests are applied in order to determine whether two nodes are deep equal.

If the two nodes are of different node-kinds, the result 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 nodes are 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 are identical, that is, they contain the same number of nodes and the nodes in 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 type of the items in the sequence must also support certain operations.

Function	Meaning
`fn:count`	Returns the number of items in the sequence.
`fn:avg`	Returns the average of a sequence of values.
`fn:max`	Returns the member with maximum value from a collection of comparable objects.
`fn:min`	Returns the member with minimum value from a collection of comparable objects.
`fn:sum`	Returns the sum of a sequence of values.

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 if its 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 added and the adjusted normalized value is used in the calculation.

If the above conditions are not met, then an error is raised ("Invalid argument to fn:avg() function").

If $srcval contains xs:float or xs:double values, NaN values are discarded.

For detailed 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 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 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:yearMonthDuration values or must all be xdt:dayTimeDuration values.

If any of these conditions is not met, then an error is raised ("Invalid argument to fn:max() function").

If $srcval contains xs:float or xs:double values, NaN values are discarded.

For xs:dateTime, xs:date or xs:time values with the same (adjusted) normalized value and different timezones, the value returned is ·implementation dependent·.

The value returned by fn:max($srcval) 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
        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 gt operator 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 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 yearMonthDuration values or must all be dayTimeDuration values.

If any of these conditions is not met, then an error is raised ("Invalid argument to fn:min() function").

If $srcval contains xs:float or xs:double values, NaN values are discarded.

For xs:dateTime, xs:date or xs:time values with the same (adjusted) normalized value and different timezones, the value returned is ·implementation dependent·.

The value returned by fn:min($srcval) 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
        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. 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. Duration values must either all be xdt:yearMonthDuration values or must all be xdt:dayTimeDuration values.

If the above conditions are not met, an error is raised ("Invalid argument to fn:sum() function").

If $srcval contains xs:float or xs:double values, NaN values are discarded.

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

Function	Meaning
`op:to`	Returns the sequence containing every `xs:integer` between the values of the operands.
`fn:id`	Returns the sequence of nodes having unique IDs that match the IDREFs represented by the argument sequence.
`fn:idref`	Returns the sequence of nodes with IDREF values matching the items in the argument sequence.
`fn:doc`	Returns a document node retrieved using the specified URI.
`fn:collection`	Returns a sequence of document nodes retrieved using the specifiued 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 there is no context item, or if 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 returns the 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 first such element.

It is also possible in a well-formed but invalid 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 that have IDREF values that reference one or more of the ID values specified in $srcval. Each string in $srcval is parsed as if it were of lexically of type xs:ID, that is, $srcval is treated as a space-separated sequence of tokens, each acting as an ID. These tokens are then included in the list of candidate IDs. After this substitution, the sequence must consist entirely of ID values. If any of the tokens is not a lexically-valid ID (that is, if it is not lexically an xs:NCName), it is ignored.

A node references an ID value if the element or attribute itself is of type xs:IDREF or xs:IDREFS. If the node is of type xs:IDREF then its value must match one of the ID values in $srcval. If it is of type xs:IDREFS then one of the values in the IDREFS sequence must match one of the values in $srcval.

An IDREF value matches a candidate ID if they consist of the same sequence of Unicode code-points. The default collation is not used in the 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 containing 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), then an error is raised ("No context node").

15.4.4 fn:doc

fn:doc($uri as xs:string?) as document?

Retrieves a document using a a URI supplied as an xs:string. If $uri is not in the lexical space of xs:anyURI, an error is raised ("Invalid argument to fn:doc function"). If this is a relative URI, it is resolved relative to the value of the base URI property from the static context.

The URI must not contain a fragment identifier.

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

Note:

If the URI is read from a source document, it is generally appropriate to resolve it relative to the base URI property of the relevant node in the source document. This can be achieved by calling the fn:resolve-uri function, and passing the resulting absolute URI as an argument to this function.

This function is ·stable·. Two calls on this function return the same document node if the same URI (after resolution to an absolute URI) is supplied to both calls. Thus, the following expression (if it does not raise an error) will always be true:

doc("foo.xml") is doc("foo.xml")

If two calls on this function supply different absolute URIs, the same document node may be returned if the implementation can determine that the two URIs refer to the same resource.

The default processing performed by this 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]. If the top-level media type is known and is "text", the content is parsed in the same way as if the media type were text/xml; otherwise, it is parsed in the same way as if the media type were application/xml. If the contents cannot be parsed successfully, an error is raised ("Error parsing contents of resource"). Otherwise, the result of the function is the document node at the root of the resulting tree.

Various aspects of this processing are ·implementation defined·. Implementations may provide external configuration options that allow any aspect of the processing to be controlled by the user. In particular:

The set of URI schemes that the implementation recognizes is implementation-defined. Implementations may allow the mapping of URIs to resources to be configured by the user, using mechanisms such as catalogs or user-written URI handlers.
The handling of non-XML media types is implementation-defined. Implementations may allow instances of the data model to be constructed from non-XML resources, under user control.
It is implementation-defined whether DTD validation and/or schema validation is applied to the source document.
Implementations may provide user-defined error handling options that allow processing to continue following an error in retrieving a resource, or in parsing and validating its content. When errors have been handled in this way, the function may return either an empty sequence, or a fallback document provided by the error handler.

For detailed 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:string as argument and returns a sequence of nodes obtained by casting $srcval to xs:anyURI and resolving it. If $srcval is not in the lexical space of xs:anyURI, an error is raised ("Invalid URI format"). If the xs:anyURI is a relative URI, it is resolved against the value of the base-URI property from the static context. If the xs:anyURI does not resolve to a collection, then an error is raised ("Invalid argument to collection function"). This function is ·stable·.

For detailed 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. This function 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.

Function	Meaning
`fn:context-item`	Returns the context item.
`fn:position`	Returns the position of the context item within the sequence of items currently being processed.
`fn:last`	Returns the number of items in the sequence of items currently being processed.
`fn:current-dateTime`	Returns the current `xs:dateTime`.
`fn:current-date`	Returns the current `xs:date`.
`fn:current-time`	Returns the current `xs: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:integer indicating 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:integer indicating 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 transformation in which fn:current-dateTime() is executed. This function is ·stable·. The precise instant during the query or transformation represented by the value of fn:current-dateTime() is ·implementation dependent·.

The timezone returned by fn:current-dateTime() is the value of the implicit timezone property in 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 transformation in which fn:current-date() is executed. This function is ·stable·. The precise instant during the query or transformation represented by the value of fn:current-date() is ·implementation dependent·.

The timezone returned by fn:current-dateTime() is the value of the implicit timezone property in the evaluation context.

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 transformation in which fn:current-time() is executed. This function is ·stable·. The precise instant during the query or transformation represented by the value of fn:current-time() is ·implementation dependent·.

The timezone returned by fn:current-dateTime() is the value of the implicit timezone property in the evaluation context.

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	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	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 for rules 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:untypedAtomic and xs:anySimpleType

When the supplied value is an instance of 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:anySimpleType and 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].

To cast to xs:anySimpleType or 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, TV is 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 -INF or NAN, then TV is -INF or 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 is xs: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 -INF or NAN, then TV is -INF or 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 is xs: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).
When a value of any simple type is cast to xs:integer, the xs:integer value TV is derived from the source type ST and the source value SV as follows:
- If ST is xs:integer, or a type derived from xs:integer, then TV is SV, converted to an xs:integer value 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 SV is 1 or true and to 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: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 same as 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 value IV of type xs:token and TV is derived from IV using 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 value IV 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 converted to 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: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 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 SYR be 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 SYR be 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 value IV 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 value IV 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 SMO be 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 ) ).
- If ST is 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 ) ); TV is 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 intermediate value 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 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:gDay( fn:concat( '---', SDA, STZ )).
- If ST is date, 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 converted to 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 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:gMonth( fn:concat( '--' , SMO, STZ )).
- If ST is 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 value IV 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 is SV.
If ST is xs:float, xs:double, xs:decimal or xs:integer and 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 or xs:hexBinary and SV is " 1 ", then TV is true; if ST is xs:base64Binary or xs:hexBinary and SV is " 0 ", then TV is false.
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 a valid lexical representation for xs:boolean as specified in [XML Schema Part 2: Datatypes], then an error is raised ("Invalid lexical value").
If IV 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 a subtype 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

In 2.0, id(true()) is a type error, rather than an attempt to find an element with the ID true; and id(42) 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 in the sequence is used as the argument. Not an issue if fallback is enabled.

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

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

name(node-set?) =>
            string

XPath 1.0 function retained for compatibility. See also fn:name()

fn:string() as xs:string

string(object) =>
            string

The string representation of double values is not backwards-compatible. When multiple items are supplied, an error ("type exception") is raised, with fall-back of first node, for XPath 1.0 compatibility.

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

fn:concat() as xs:string

concat(string,
            string, string*) => string

In 2.0, the arguments are optional. 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

In 1.0, returns false if the first argument is an empty node-set. In 2.0, returns ().

`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

In 1.0, returns false if the first argument is an empty node-set. In 2.0, returns ().

`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

In 1.0, returns "" if the first argument is an empty node-set. In 2.0, returns ().

`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

In 1.0, returns "" if the first argument is an empty node-set. In 2.0, returns ().

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

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

substring(string,
            number, number?) => string

In 1.0, returns "" if the first argument is an empty node-set. In 2.0, returns ().

`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:normalize-space() as xs: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:not($srcval as item*) as xs:boolean

not(boolean) =>
            boolean

fn:true() as xs:boolean

true() =>
            boolean

fn:false() as xs:boolean

false() =>
            boolean

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

lang(string) =>
            boolean

In 2.0, If $srcval is a sequence containing more than one item, a type exception error is raised. 1.0 takes the first node in a node-set. In 2.0, if node is untyped, a type exception error is raised ; otherwise, its typed-value is accessed. The value is then converted to xs:boolean. 1.0 Nodes are not typed.

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

2.0 raises an error if sequence contains values that cannot be added together. 1.0 returns NaN.

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

floor(number)=>
            number

In 2.0, if argument is (), the result is (). In 1.0, the result is NaN.

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

ceiling(number)=>
            number

In 2.0, if argument is (), the result is (). 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 the XSL WG on 3/27/2003.

2003-03-24 (AM) Arguments of type xdt:untypedAtomic to the idiv 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 function based on dm:document-uri accessor. As approved in F&O meeting 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/3 By WGs on 3/6. Also added 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. Removed fn: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 By WGs on 3/6.

2003-03-09 (AM) Added special rulae that the div operator returns decimal instead of double for integer operands. Approved in F&O meeting on 3/3 By WGs on 3/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 issue 136. 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 name of fn:sequence-node-equal to fn:sequence-node-identical. Approved in F&O meeting on 3/3 By WGs on 3/6.

2003-03-07 (AM) Changed casting table to prohibit casting from hexBinary to numerics. Approved in F&O meeting on 3/3 By WGs on 3/6.

2003-03-07 (AM) Added constructor for xdt:untypedAtomic. Approved in F&O meeting on 3/3 By WGs on 3/6.

2003-03-07 (AM) Changed second argument of fn:half-round-to-even to integer. Added two simple examples. Approved in F&O meeting on 3/3 By WGs on 3/6.

2003-03-07 (AM) Added sentence that if $pattern in fn:tokenize matches empty string an error is raised. Approved in F&O meeting on 3/3 By WGs on 3/6.

2003-03-07 (AM) Changed collation note as per MHK note http://lists.w3.org/Archives/Member/w3c-query-operators/2003Jan/0029.html. Approved in F&O meeting on 3/3 By WGs on 3/6.

2003-03-07 (AM) Changed casting of double to float to conform with IEEE 754. Approved in F&O meeting on 3/3 By WGs on 3/6.

2003-03-07 (AM) Changed semantics of fn:number() to return NaN instead of error, as approved in F&O meeting on 3/3 By WGs on 3/6.

2003-03-07 (AM) Changed numeric comparison functions to say that comparisons incolving NaN always return false. Approved in F&O meeting on 3/3 By WGs on 3/6.

2003-03-07 (AM) Changed namespace for constructors to the XML Schema namespace to conform with usage in ther documents.

2003-02-21 (AM) Changed return types for fn:count(), fn:position(), fn:last() and fn:indexof() to xs:integer from subtype of 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 by the XQuery WG on 1/22, XSL WG in 2/20.

2003-02-21 (AM) Clarified semantics of QName-equal. As agreed to by the XQuery WG on 1/22, XSL WG in 2/20.

2003-02-21 (AM) Removed regex extensibility para from section 6.5.1. Closed issue 176. As agreed to by the XQuery WG on 2/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. Revised on 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. As per mail from Mike Kay. No objection. Treated as bug fix.

2003-01-01 (AM) Closed issue 186 (preserve-timezone) and implemented MRys proposal for timezone preservation as approved by both WGs 12/18.

2002-12-27 (AM) Created a separate section for string functions that use regex's for pattern matching -- fn:matches(), fn:replace() and fn:tokenize(). Section starts with the common regex syntax. Editorial.

2002-12-24 (AM) Closed issue 173 (disambiguate-multiple-possible-outcomes). Added text saying that the semantic rules describing each function must be followed in the order that they appear.

2002-12-24 (AM) Closed issue 89 (functions-on-anyType-problematic). These functions are now identified typographically and their semantics is spelt out in detail with pointers to the Formal Semantics document where needed. Approved by both WGs 12/18.

2002-12-23 (AM) Closed issue 187 (untyped-values-in-aggregates). Semantics specified. Cast to other types in the sequence. If all untyped, cast to string. Approved by both WGs 12/18.

2002-12-23 (AM) Changed semantics of fn:idref to return the node that contains the ID value instead 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 of precision returned by various functions (operator-returned-precision). Approved by both WGs 12/18.

2002-12-22 (AM) Closed issue 44 on collation names (operator-collation-specification). Approved by 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. By XSL WG 12/19.

2002-12-20 (AM) Closed issue 181 (error-function-semantics) and made suggested editorial changes. Semantics have now been defined in section 3. Approved by both WGs 12/18.

2002-12-20 (AM) Closed issue 73 (operator-compare-between). Originator withdrew 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(). Approved by both WGs 12/18.

2002-12-20 (AM) Added definition for round-half-to-even. Approved by XQuery 11/14. By XSL WG 12/19.

2002-12-20 (AM) Added definition for index-of-node in Appendix C. Approved by XQuery 11/14. By XSL WG 12/19. Closed issue 63 (operator-augment-index-of)

2002-12-19 (AM) Add fn:expanded-QName. Inadvertently dropped. As approved by both WGs on 2002-12-18.

2002-12-19 (AM) Removed fn:unique-id. As approved by both WGs on 2002-12-18.

2002-12-18 (AM) Closed issue 159. Minimum of 3 fractional seconds digits must be supported for date/time types. As approved by both WGs on 2002-12-18.

2002-12-18 (AM) Changed namespace for datatypes defined in this document. Referred to by prefix xdt:. As approved by both WGs on 2002-12-18.

2002-12-05 (AM) Changed definition of base-uri to return the empty sequence (not error) if argument is not a document, element or PI node. This was datamodel issue 87. Approved by 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. Approved by XQuery WG on 11/14, XSL WG on 11/15. Closed issue 142(what-should-floor-ceiling-round-return) and issue 179 (floor-ceiling-round-return-type).

2002-12-05 (AM) Changed definition 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. As per XML Query telcon 2002-11-27.

2002-11-27 (AM) Changed namespace for datatypes defined in this document. Referred to by prefix qt:. As per XML Query telcon 2002-11-27.

2002-11-19 (AM) Editorial fixes 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 Query WG on 11/13 and the XSL WG on 11/14.

2002-11-15 (AM) Added rules for casting to integer as agreed to by the XML Query WG on 11/13 and the XSL WG on 11/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
String 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

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