XPath and XQuery Functions and Operators 1.1

1.6.1 Namespaces and URIs

This document uses the phrase "namespace URI" to identify the concept identified in [Namespaces in XML] as "namespace name", and the phrase "local name" to identify the concept identified in [Namespaces in XML] as "local part".

It also uses the term "expanded-QName" defined below.

[Definition] An expanded-QName is a pair of values consisting of a namespace URI and a local name. They belong to the value space of the [XML Schema Part 2: Datatypes Second Edition] datatype xs:QName. When this document refers to xs:QName we always mean the value space, i.e. a namespace URI, local name pair (and not the lexical space referring to constructs of the form prefix:local-name).

The term URI is used as follows:

[Definition] Within this specification, the term URI refers to Universal Resource Identifiers as defined in [RFC 3986] and extended in [RFC 3987] with a new name IRI. The term URI Reference, unless otherwise stated, refers to a string in the lexical space of the xs:anyURI datatype as defined in [XML Schema Part 2: Datatypes Second Edition].

1.6.2 Conformance terminology

[Definition] for compatibility

A feature of this specification included to ensure that implementations that use this feature remain compatible with [XML Path Language (XPath) Version 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 either non-conformant or else in error.

[Definition] implementation-defined

Possibly differing between implementations, but specified and documented 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.

1.6.3 Properties of functions

This section is concerned with the question of whether two calls on a function, with the same arguments, may produce different results.

[Definition] Two function calls are said to be within the same execution scope if the host environment defines them as such. In XSLT, any two calls executed during the same transformation are in the same execution scope. In XQuery, any two calls executed during the evaluation of a top-level expression are in the same execution scope. In other contexts, the execution scope is specified by the host environment that invokes the function library.

The following definition explains more precisely what it means for two function calls to return the same result:

[Definition] Two values are defined to be identical if they contain the same number of items and the items are pairwise identical. Two items are identical if and only if one of the following conditions applies:

• Both items are atomic values, of precisely the same type, and the values are equal as defined using the eq operator, using the Unicode codepoint collation when comparing strings

• Both items are nodes, and represent the same node

• Both items are function items, and have the same name (or absence of a name), arity, function signature, and closure

Some functions produce results that depend not only on their explicit arguments, but also on the static and dynamic context.

[Definition] A function may have the property of being contextual: the result of such a function depends on the values of properties in the static and dynamic evaluation context as well as on the actual supplied arguments (if any).

Contextual functions fall into a number of categories:

1. The functions fn:current-date, fn:current-dateTime, fn:current-time, fn:implicit-timezone, fn:adjust-date-to-timezone, fn:adjust-dateTime-to-timezone, and fn:adjust-time-to-timezone depend on properties of the dynamic context that are fixed within the ·execution scope·. The same applies to a number of functions in the op: namespace that manipulate dates and times and that make use of the implicit timezone. These functions will return the same result if called repeatedly during a single ·execution scope·.

2. The functions fn:position, fn:last, fn:id, fn:idref, fn:element-with-id, fn:lang, fn:local-name, fn:name, fn:namespace-uri, fn:normalize-space, fn:number, fn:root, fn:string, and fn:string-length depend on the focus. These functions will in general return different results on different calls if the focus is different.

3. The function fn:default-collation and many string-handling operators and functions depend on the default collation and the in-scope collations, which are both properties of the static context. If a particular call of one of these functions is evaluated twice with the same arguments then it will return the same result each time (because the static context, by definition, does not change at run time). However, two distinct calls (that is, two calls on the function appearing in different places in the source code) may produce different results even if the explicit arguments are the same.

4. Functions such as fn:static-base-uri, fn:doc, and fn:collection depend on other aspects of the static context. As with functions that depend on collations, a single call will produce the same results on each call if the explicit arguments are the same, but two calls appearing in different places in the source code may produce different results.

[Definition] For a ·contextual· function, the parts of the context on which it depends are referred to as implicit arguments.

[Definition] A function that is guaranteed to produce ·identical· results from repeated calls if the explicit and implicit arguments are identical is referred to as stable.

All functions defined in this specification are ·stable· unless otherwise stated. Exceptions include the following:

• Some functions (such as fn:distinct-values and fn:unordered) produce results in an ·implementation-defined· or ·implementation-dependent·order. In such cases there is no guarantee that the order of results from different calls will be the same. These functions are said to be ordering-unstable.

• The function fn:analyze-string constructs an element node to represent its results. There is no guarantee that repeated calls with the same arguments will return the same identical node (in the sense of the is operator). Such a function is said to be identity-unstable.

• Some functions (such as fn:doc and fn:collection) create new nodes by reading external documents. Such functions are guaranteed to be ·stable· with the exception that an implementation is allowed to make them unstable as a user option.

Where the results of a function are described as being (to a greater or lesser extent) ·implementation-defined· or ·implementation-dependent·, this does not by itself remove the requirement that the results should be stable: that is, that repeated calls with the same explicit and implicit arguments must return identical results.

3.1.1 fn:error

Summary

Calling the fn:error function raises an application-defined error.

Signatures

fn:error() as none

fn:error($code as xs:QName) as none

fn:error($code as xs:QName?, $description as xs:string) as none

fn:error(	$code	as xs:QName?,
	$description	as xs:string,
	$error-object	as item()*) as none

Rules

This function never returns a value. Instead it always raises an error. The effect of the error is identical to the effect of dynamic errors raised implicitly, for example when an incorrect argument is supplied to a function.

The parameters to the fn:error function supply information that is associated with the error condition and that is made available to a caller that asks for information about the error. The error may be caught either by the host language (using a try/catch construct in XSLT or XQuery, for example), or by the calling application or external processing environment. The way in which error information is returned to the external processing environment is ·implementation dependent·

If fn:error is called with no arguments, then its behavior is the same as the function call:

 fn:error(fn:QName('https://www.w3.org/2005/xqt-errors', 'err:FOER0000')) 

If $code is the empty sequence then the effective value is the xs:QName constructed by:

 fn:QName('https://www.w3.org/2005/xqt-errors', 'err:FOER0000')

There are three pieces of information that may be associated with an error:

• The $code is an error code that distinguishes this error from others. It is an xs:QName; the namespace URI conventionally identifies the component, subsystem, or authority responsible for defining the meaning of the error code, while the local part identifies the specific error condition. The namespace URI https://www.w3.org/2005/xqt-errors is used for errors defined in this specification; other namespace URIs may be used for errors defined by the application.

  If the external processing environment expects the error code to be returned as a URI or a string rather than as an xs:QName, then an error code with namespace URI NS and local part LP will be returned in the form NS#LP. The namespace URI part of the error code should therefore not include a fragment identifier.

• The $description is a natural-language description of the error condition.

• The $error-object is an arbitrary value used to convey additional information about the error, and may be used in any way the application chooses.

Error Conditions

This function always raises an error.

Notes

The value of the $description parameter may need to be localized.

The type "none" is a special type defined in [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.

Examples

fn:error() returns https://www.w3.org/2005/xqt-errors#FOER0000 (or the corresponding xs:QName) to the external processing environment, unless the error is caught using a try/catch construct in the host language.

fn:error(fn:QName('https://www.example.com/HR', 'myerr:toohighsal'), 'Does not apply because salary is too high') returns https://www.example.com/HR#toohighsal and the xs:string "Does not apply because salary is too high" (or the corresponding xs:QName) to the external processing environment, unless the error is caught using a try/catch construct in the host language.

3.2.1 fn:trace

Summary

Provides an execution trace intended to be used in debugging queries.

Signature

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

Rules

The function returns the value of $value, unchanged.

In addition, the values of $value, converted to an xs:string, and $label may be directed to a trace data set. The destination of the trace output is ·implementation-defined·. The format of the trace output is ·implementation dependent·. The ordering of output from calls of the fn:trace function is ·implementation dependent·.

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 dependent order.

4.2.1 op:numeric-add

Summary

Returns the arithmetic sum of its operands: ($arg1 + $arg2).

Operator Mapping

Defines the semantics of the "+" operator applied to numeric values

Signature

op:numeric-add($arg1 as numeric, $arg2 as numeric) as numeric

Rules

General rules: see 4.2 Arithmetic Operators on Numeric Values.

Notes

For xs:float or xs:double values, if one of the operands is a zero or a finite number and the other is INF or -INF, INF or -INF is returned. If both operands are INF, INF is returned. If both operands are -INF, -INF is returned. If one of the operands is INF and the other is -INF, NaN is returned.

4.2.2 op:numeric-subtract

Summary

Returns the arithmetic difference of its operands: ($arg1 - $arg2).

Operator Mapping

Defines the semantics of the "-" operator applied to numeric values.

Signature

op:numeric-subtract($arg1 as numeric, $arg2 as numeric) as numeric

Rules

General rules: see 4.2 Arithmetic Operators on Numeric Values.

Notes

For xs:float or xs:double values, if one of the operands is a zero or a finite number and the other is INF or -INF, an infinity of the appropriate sign is returned. If both operands are INF or -INF, NaN is returned. If one of the operands is INF and the other is -INF, an infinity of the appropriate sign is returned.

4.2.3 op:numeric-multiply

Summary

Returns the arithmetic product of its operands: ($arg1 * $arg2).

Operator Mapping

Defines the semantics of the "*" operator applied to numeric values.

Signature

op:numeric-multiply($arg1 as numeric, $arg2 as numeric) as numeric

Rules

General rules: see 4.2 Arithmetic Operators on Numeric Values.

Notes

For xs:float or xs:double values, if one of the operands is a zero and the other is an infinity, NaN is returned. If one of the operands is a non-zero number and the other is an infinity, an infinity with the appropriate sign is returned.

4.2.4 op:numeric-divide

Summary

Returns the arithmetic quotient of its operands: ($arg1 div $arg2).

Operator Mapping

Defines the semantics of the "div" operator applied to numeric values.

Signature

op:numeric-divide($arg1 as numeric, $arg2 as numeric) as numeric

Rules

General rules: see 4.2 Arithmetic Operators on Numeric Values.

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

Error Conditions

For xs:decimal and xs:integer operands, if the divisor is (positive or negative) zero, an error is raised [err:FOAR0001].

Notes

For xs:float and xs:double operands, floating point division is performed as specified in [IEEE 754-1985]. A positive number divided by positive zero returns INF. A negative number divided by positive zero returns -INF. Division by negative zero returns -INF and INF, respectively. Positive or negative zero divided by positive or negative zero returns NaN. Also, INF or -INF divided by INF or -INF returns NaN.

4.2.5 op:numeric-integer-divide

Summary

Performs an integer division.

Operator Mapping

Defines the semantics of the "idiv" operator applied to numeric values.

Signature

op:numeric-integer-divide($arg1 as numeric, $arg2 as numeric) as xs:integer

Rules

General rules: see 4.2 Arithmetic Operators on Numeric Values.

If $arg2 is INF or -INF, and $arg1 is not INF or -INF, then the result is zero.

Otherwise, subject to limits of precision and overflow/underflow conditions, the result is the largest (furthest from zero) xs:integer value $N such that fn:abs($N * $arg2) le fn:abs($arg1) and fn:compare($N * $arg2, 0) eq fn:compare($arg1, 0).

Note:

The second term in this condition ensures that the result has the correct sign.

The implementation may adopt a different algorithm provided that it is equivalent to this formulation in all cases where ·implementation-dependent· or ·implementation-defined· behavior does not affect the outcome, for example, the implementation-defined precision of the result of xs:decimal division.

Error Conditions

If the divisor is (positive or negative) zero, then an error is raised [err:FOAR0001].

If either operand is NaN or if $arg1 is INF or -INF then an error is raised [err:FOAR0002].

Notes

Except in situations involving errors, loss of precision, or overflow/underflow, the result of $a idiv $b is the same as ($a div $b) cast as xs:integer.

The semantics of this function are different from integer division as defined in programming languages such as Java and C++.

Examples

The expression op:numeric-integer-divide(10,3) returns 3.

The expression op:numeric-integer-divide(3,-2) returns -1.

The expression op:numeric-integer-divide(-3,2) returns -1.

The expression op:numeric-integer-divide(-3,-2) returns 1.

The expression op:numeric-integer-divide(9.0,3) returns 3.

The expression op:numeric-integer-divide(-3.5,3) returns -1.

The expression op:numeric-integer-divide(3.0,4) returns 0.

The expression op:numeric-integer-divide(3.1E1,6) returns 5.

The expression op:numeric-integer-divide(3.1E1,7) returns 4.

4.2.6 op:numeric-mod

Summary

Returns the remainder resulting from dividing $arg1, the dividend, by $arg2, the divisor.

Operator Mapping

Defines the semantics of the "mod" operator applied to numeric values.

Signature

op:numeric-mod($arg1 as numeric, $arg2 as numeric) as numeric

Rules

General rules: see 4.2 Arithmetic Operators on Numeric Values.

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 idiv b)*b+(a mod b) is equal to a and the magnitude of the result is always less than the magnitude of b. 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.

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 idiv b)*b+(a mod b) = a. Division is truncating division, analogous to integer division, not [IEEE 754-1985] rounding division i.e. additional digits are truncated, not rounded to the required precision.

Error Conditions

For xs:integer and xs:decimal operands, if $arg2 is zero, then an error is raised [err:FOAR0001].

Examples

The expression op:numeric-mod(10,3) returns 1.

The expression op:numeric-mod(6,-2) returns 0.

The expression op:numeric-mod(4.5,1.2) returns 0.9.

The expression op:numeric-mod(1.23E2, 0.6E1) returns 3.0E0.

4.2.7 op:numeric-unary-plus

Summary

Returns its operand with the sign unchanged: (+ $arg).

Operator Mapping

Defines the semantics of the unary "+" operator applied to numeric values.

Signature

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

Rules

General rules: see 4.2 Arithmetic Operators on Numeric Values.

The returned value is equal to $arg, and is an instance of xs:integer, xs:decimal, xs:double, or xs:float depending on the type of $arg.

4.2.8 op:numeric-unary-minus

Summary

Returns its operand with the sign reversed: (- $arg).

Operator Mapping

Defines the semantics of the unary "-" operator applied to numeric values.

Signature

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

Rules

General rules: see 4.2 Arithmetic Operators on Numeric Values.

The returned value is an instance of xs:integer, xs:decimal, xs:double, or xs:float depending on the type of $arg.

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 returns -INF. -INF returns INF.

4.3.1 op:numeric-equal

Summary

Returns true if and only if the value of $arg1 is equal to the value of $arg2.

Operator Mapping

Defines the semantics of the "eq" operator on numeric values, and is also used in defining the semantics of "ne", "le" and "ge".

Signature

op:numeric-equal($arg1 as numeric, $arg2 as numeric) as xs:boolean

Rules

General rules: see 4.2 Arithmetic Operators on Numeric Values and 4.3 Comparison Operators on Numeric Values.

For xs:float and xs:double values, positive zero and negative zero compare equal. INF equals INF, and -INF equals -INF. NaN does not equal itself.

4.3.2 op:numeric-less-than

Summary

Returns true if and only if $arg1 is numerically less than $arg2.

Operator Mapping

Defines the semantics of the "lt" operator on numeric values, and is also used in defining the semantics of "le".

Signature

op:numeric-less-than($arg1 as numeric, $arg2 as numeric) as xs:boolean

Rules

General rules: see 4.2 Arithmetic Operators on Numeric Values and 4.3 Comparison Operators on Numeric Values.

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 $arg1 or $arg2 is NaN, the function returns false.

4.3.3 op:numeric-greater-than

Summary

Returns true if and only if $arg1 is numerically greater than $arg2.

Operator Mapping

Defines the semantics of the "gt" operator on numeric values, and is also used in defining the semantics of "ge".

Signature

op:numeric-greater-than($arg1 as numeric, $arg2 as numeric) as xs:boolean

Rules

The function call op:numeric-greater-than($A, $B) is defined to return the same result as op:numeric-less-than($B, $A)

4.4.1 fn:abs

Summary

Returns the absolute value of $arg.

Signature

fn:abs($arg as numeric?) as numeric?

Rules

General rules: see 4.4 Functions on Numeric Values.

If $arg is negative the function returns -$arg, otherwise it returns $arg.

If the type of $arg is one of the four numeric types xs:float, xs:double, xs:decimal or xs:integer the type of the result is the same as the type of $arg. If the type of $arg is a type derived from one of the numeric types, the result is an instance of the base numeric type.

For xs:float and xs:double arguments, if the argument is positive zero or negative zero, then positive zero is returned. If the argument is positive or negative infinity, positive infinity is returned.

For detailed type semantics, see Section 7.2.3 The fn:abs, fn:ceiling, fn:floor, fn:round, and fn:round-half-to-even functions^FS

Examples

The expression fn:abs(10.5) returns 10.5.

The expression fn:abs(-10.5) returns 10.5.

4.4.2 fn:ceiling

Summary

Rounds $arg upwards to a whole number.

Signature

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

Rules

General rules: see 4.4 Functions on Numeric Values.

The function returns the smallest (closest to negative infinity) number with no fractional part that is not less than the value of $arg.

If the type of $arg is one of the four numeric types xs:float, xs:double, xs:decimal or xs:integer the type of the result is the same as the type of $arg. If the type of $arg is a type derived from one of the numeric types, the result is an instance of the base numeric type.

For xs:float and xs:double arguments, if the argument is positive zero, then positive zero is returned. If the argument is negative zero, then negative zero is returned. If the argument is less than zero and greater than -1, negative zero is returned.

For detailed type semantics, see Section 7.2.3 The fn:abs, fn:ceiling, fn:floor, fn:round, and fn:round-half-to-even functions^FS

Examples

The expression fn:ceiling(10.5) returns 11.

The expression fn:ceiling(-10.5) returns -10.

4.4.3 fn:floor

Summary

Rounds $arg downwards to a whole number.

Signature

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

Rules

General rules: see 4.4 Functions on Numeric Values.

The function returns the largest (closest to positive infinity) number with no fractional part that is not greater than the value of $arg.

If the type of $arg is one of the four numeric types xs:float, xs:double, xs:decimal or xs:integer the type of the result is the same as the type of $arg. If the type of $arg is a type derived from one of the numeric types, the result is an instance of the base numeric type.

For xs:float and xs:double arguments, if the argument is positive zero, then positive zero is returned. If the argument is negative zero, then negative zero is returned.

For detailed type semantics, see Section 7.2.3 The fn:abs, fn:ceiling, fn:floor, fn:round, and fn:round-half-to-even functions^FS

Examples

The expression fn:floor(10.5) returns 10.

The expression fn:floor(-10.5) returns -11.

4.4.4 fn:round

Summary

Rounds a value to a specified number of decimal places, rounding upwards if two such values are equally near.

Signatures

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

fn:round($arg as numeric?, $precision as xs:integer) as numeric?

Rules

General rules: see 4.4 Functions on Numeric Values.

The function returns the nearest (that is, numerically closest) value to $arg that is a multiple of ten to the power of minus $precision. If two such values are equally near (for example, if the fractional part in $arg is exactly .5), the function returns the one that is closest to positive infinity.

If the type of $arg is one of the four numeric types xs:float, xs:double, xs:decimal or xs:integer the type of the result is the same as the type of $arg. If the type of $arg is a type derived from one of the numeric types, the result is an instance of the base numeric type.

The single-argument version of this function produces the same result as the two-argument version with $precision=0 (that is, it rounds to a whole number).

When $arg is of type xs:float and xs:double:

1. If $arg is NaN, positive or negative zero, or positive or negative infinity, then the result is the same as the argument.

2. For other values, the argument is cast to xs:decimal using an implementation of xs:decimal that imposes no limits on the number of digits that can be represented. The function is applied to this xs:decimal value, and the resulting xs:decimal is cast back to xs:float or xs:double as appropriate to form the function result. If the resulting xs:decimal value is zero, then positive or negative zero is returned according to the sign of $arg.

For detailed type semantics, see Section 7.2.3 The fn:abs, fn:ceiling, fn:floor, fn:round, and fn:round-half-to-even functions^FS

Notes

This function is typically used with a non-zero $precision in financial applications where the argument is of type xs:decimal. For arguments of type xs:float and xs:double the results may be counter-intuitive. For example, consider round(35.425e0, 2). The result is not 35.43, as might be expected, but 35.42. This is because the conversion of 35.425e0 to xs:decimal produces the decimal value 35.42499999999..., which is closer to 35.42 than to 35.43.

Examples

The expression fn:round(2.5) returns 3.0.

The expression fn:round(2.4999) returns 2.0.

The expression fn:round(-2.5) returns -2.0. (Not the possible alternative, -3).

The expression fn:round(1.125, 2) returns 1.13.

The expression fn:round(8452, -2) returns 8500.

The expression fn:round(3.1415e0, 2) returns 3.14e0.

4.4.5 fn:round-half-to-even

Summary

Rounds a value to a specified number of decimal places, rounding to make the last digit even if two such values are equally near.

Signatures

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

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

Rules

General rules: see 4.4 Functions on Numeric Values.

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

If the type of $arg is one of the four numeric types xs:float, xs:double, xs:decimal or xs:integer the type of the result is the same as the type of $arg. If the type of $arg is a type derived from one of the numeric types, the result is an instance of the base numeric type.

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

For arguments of type xs:float and xs:double:

1. If the argument is NaN, positive or negative zero, or positive or negative infinity, then the result is the same as the argument.

2. In all other cases, the argument is cast to xs:decimal using an implementation of xs:decimal that imposes no limits on the number of digits that can be represented. The function is applied to this xs:decimal value, and the resulting xs:decimal is cast back to xs:float or xs:double as appropriate to form the function result. If the resulting xs:decimal value is zero, then positive or negative zero is returned according to the sign of the original argument.

For detailed type semantics, see Section 7.2.3 The fn:abs, fn:ceiling, fn:floor, fn:round, and fn:round-half-to-even functions^FS

Notes

This function is typically used in financial applications where the argument is of type xs:decimal. For arguments of type xs:float and xs:double the results may be counter-intuitive. For example, consider round-half-to-even(xs:float(150.015), 2). The result is not 150.02 as might be expected, but 150.01. This is because the conversion of the xs:float value represented by the literal 150.015 to an xs:decimal produces the xs:decimal value 150.014999389..., which is closer to 150.01 than to 150.02.

Examples

The expression fn:round-half-to-even(0.5) returns 0.0.

The expression fn:round-half-to-even(1.5) returns 2.0.

The expression fn:round-half-to-even(2.5) returns 2.0.

The expression fn:round-half-to-even(3.567812e+3, 2) returns 3567.81e0.

The expression fn:round-half-to-even(4.7564e-3, 2) returns 0.0e0.

The expression fn:round-half-to-even(35612.25, -2) returns 35600.

4.5.1 fn:format-integer

Summary

formats an integer according to a given picture string, using the conventions of a given natural language if specified.

Signatures

fn:format-integer($value as xs:integer?, $picture as xs:string) as xs:string

fn:format-integer(	$value	as xs:integer?,
	$picture	as xs:string,
	$language	as xs:language) as xs:string

Rules

Editorial note
This function is created to extract that subset of the functionality of the xsl:number instruction in XSLT which is needed to support format-dateTime, thus avoiding any dependency on the XSLT specification, while also making this functionality available in XPath and XQuery in contexts other than date formatting.

If $value is an empty sequence, the function returns a zero-length string.

In all other cases, the $picture argument describes the format in which $value is output.

The rules that follow describe how non-negative numbers are output. If the value of $value is negative, the rules below are applied to the absolute value of $value, and the result is prepended with a minus sign.

A picture consists of a primary format token, followed by an optional format modifier.

The primary format token is one of the following:

• Any sequence of Unicode digits drawn from the same digit family, where a digit family is a sequence of ten consecutive Unicode characters in category Nd, having digit values 0 through 9. The corresponding output format is a decimal number, using this digit family, with at least as many digits as there are in the format token. Thus, a format token 1 generates the sequence 0 1 2 ... 10 11 12 ..., and a format token 01 (or equivalently, 00 or 99) generates the sequence 00 01 02 ... 09 10 11 12 ... 99 100 101. A format token of ١ (Arabic-Indic digit one) generates the sequence ١ then ٢ then ٣ ...

• Any sequence of Unicode digits drawn from the same digit family, interspersed by grouping separators. The digits are handled as above, and the grouping separators are handled as follows. A character is recognized as a grouping separator if it is non-alphanumeric, that is, if its Unicode character category is other than Nd, Nl, No, Lu, Ll, Lt, Lm or Lo. The position of grouping separators within the format token, counting backwards from the last digit, indicates the position of grouping separators to appear within the formatted number, and the character used as the grouping separator within the format token indicates the character to be used as the corresponding grouping separator in the formatted number. If grouping separators appear at regular intervals within the format token, that is if the same grouping separator appears at positions forming a sequence N, 2N, 3N, ... for some integer value N (including the case where there is only one number in the list), then the sequence is extrapolated to the left, so grouping separators will be used in the formatted number at every multiple of N. For example, if the format token is 0'000 then the number one million will be formatted as 1'000'000.

• A format token A generates the sequence A B C ... Z AA AB AC....

• A format token a generates the sequence a b c ... z aa ab ac....

• A format token i generates the sequence i ii iii iv v vi vii viii ix x ....

• A format token I generates the sequence I II III IV V VI VII VIII IX X ....

• A format token w generates numbers written as lower-case words, for example in English, one two three four ...

• A format token W generates numbers written as upper-case words, for example in English, ONE TWO THREE FOUR ...

• A format token Ww generates numbers written as title-case words, for example in English, One Two Three Four ...

• Any other format token indicates a numbering sequence in which that token represents the number 1 (one) (but see the note below). It is ·implementation-defined· which numbering sequences, additional to those listed above, are supported. If an implementation does not support a numbering sequence represented by the given token, it must use a format token of 1.

  Note:

  In some traditional numbering sequences additional signs are added to denote that the letters should be interpreted as numbers; these are not included in the format token. An example, see also the example below, is classical Greek where a dexia keraia and sometimes an aristeri keraia is added.

For all format tokens other than the first kind above (one that consists of decimal digits), there may be ·implementation-defined· lower and upper bounds on the range of numbers that can be formatted using this format token; indeed, for some numbering sequences there may be intrinsic limits. For example, the format token ① (circled digit one, ①) has a range of 1 to 20 imposed by the Unicode character repertoire. For the numbering sequences described above any upper bound imposed by the implementation must not be less than 1000 (one thousand) and any lower bound must not be greater than 1. Numbers that fall outside this range must be formatted using the format token 1.

The above expansions of numbering sequences for format tokens such as a and i are indicative but not prescriptive. There are various conventions in use for how alphabetic sequences continue when the alphabet is exhausted, and differing conventions for how roman numerals are written (for example, IV versus IIII as the representation of the number 4). Sometimes alphabetic sequences are used that omit letters such as i and o. This specification does not prescribe the detail of any sequence other than those sequences consisting entirely of decimal digits.

Many numbering sequences are language-sensitive. This applies especially to the sequence selected by the tokens w, W and Ww. It also applies to other sequences, for example different languages using the Cyrillic alphabet use different sequences of characters, each starting with the letter #x410 (Cyrillic capital letter A). In such cases, the $language argument specifies which language's conventions are to be used; it has the same range of values as xml:lang (see [REC-xml]). If no $language argument is specified, the language that is used is ·implementation-defined·. The set of languages for which numbering is supported is ·implementation-defined·. If a language is requested that is not supported, the processor uses the language that it would use if the $language argument were omitted.

The format modifier, if present, is one of:

• o, optionally followed by a sequence of characters enclosed between parentheses, to indicate ordinal numbering

• t to indicate traditional numbering

If the o modifier is present, this indicates a request to output ordinal numbers rather than cardinal numbers. For example, in English, when used with the format token 1, this outputs the sequence 1st 2nd 3rd 4th ..., and when used with the format token w outputs the sequence first second third fourth ....

In some languages, ordinal numbers vary depending on the grammatical context, for example they may have different genders and may decline with the noun that they qualify. In such cases the string appearing in parentheses after the letter o may be used to indicate the variation of the ordinal number required. The way in which the variation is indicated will depend on the conventions of the language. For inflected languages that vary the ending of the word, the preferred approach is to indicate the required ending, preceded by a hyphen: for example in German, appropriate values are o(-e), o(-er), o(-es), o(-en).

It is ·implementation-defined· what combinations of values of the format token, the language, and the ordinal attribute are supported. If ordinal numbering is not supported for the combination of the format token, the language, and the string appearing in parentheses, the request is ignored and cardinal numbers are generated instead.

Example: Ordinal Numbering in Italian

The specification "1o(-º)" with $language equal to it, if supported, should produce the sequence:

1º 2º 3º 4º ...

The specification "Wwo" with $language equal to it, if supported, should produce the sequence:

Primo Secondo Terzo Quarto Quinto ...

The t modifier disambiguates between numbering sequences that use letters. In many languages there are two commonly used numbering sequences that use letters. One numbering sequence assigns numeric values to letters in alphabetic sequence, and the other assigns numeric values to each letter in some other manner traditional in that language. In English, these would correspond to the numbering sequences specified by the format tokens a and i. In some languages, the first member of each sequence is the same, and so the format token alone would be ambiguous. By default the alphabetic sequence is used; the t modifier requests the other sequence.

Examples

The expression format-integer(123, '0000') returns "0123".

format-integer(123, 'w') might return "one hundred and twenty-three"

The expression format-integer(21, '1o', 'en') returns "21st".

format-integer(14, 'Wwo(-e)', 'de') might return "Vierzehnte"

The expression format-integer(7, 'a') returns "g".

The expression format-integer(57, 'I') returns "LVII".

4.6.1 Defining a Decimal Format

Decimal formats are defined in the static context, and the way they are defined is therefore outside the scope of this specification. XSLT and XQuery both provide custom syntax for creating a decimal format.

The static context provides a set of decimal formats. One of the decimal formats is unnamed, the others (if any) are identified by a QName. There is always an unnamed decimal format available, but its contents are implementation-defined.

Each decimal format provides a set of named variables, described in the following table:

[Definition] The decimal digit family of a decimal format is the sequence of ten digits with consecutive Unicode codepoints starting with the mandatory-digit-sign.

It is a constraint that, for any named or unnamed decimal format, the variables representing characters used in a ·picture string· must have distinct values. These variables are decimal-separator-sign, grouping-separator-sign, percent-sign, per-mille-sign, optional-digit-sign, and pattern-separator-sign. Furthermore, none of these variables may be equal to any character in the ·decimal digit family·.

4.6.2 fn:format-number

Summary

Returns a string containing a number formatted according to a given picture string, taking account of decimal formats specified in the static context.

Signatures

fn:format-number($value as numeric?, $picture as xs:string) as xs:string

fn:format-number(	$value	as numeric?,
	$picture	as xs:string,
	$decimal-format-name	as xs:string) as xs:string

Rules

The function formats $value as a string using the ·picture string· specified by the $picture argument and the decimal-format named by the $decimal-format-name argument, or the default decimal-format, if there is no $decimal-format-name argument. The syntax of the picture string is described in 4.6.3 Syntax of the Picture String.

The $value argument may be of any numeric data type (xs:double, xs:float, xs:decimal, or their subtypes including xs:integer). Note that if an xs:decimal is supplied, it is not automatically promoted to an xs:double, as such promotion can involve a loss of precision.

If the supplied value of the $value argument is an empty sequence, the function behaves as if the supplied value were the xs:double value NaN.

The value of $decimal-format-name must be a lexical QName, which is expanded using the in-scope namespaces from the static context. The default namespace is not used (no prefix means no namespace).

The evaluation of the format-number function takes place in two phases, an analysis phase described in 4.6.4 Analysing the Picture String and a formatting phase described in 4.6.5 Formatting the Number.

The analysis phase takes as its inputs the ·picture string· and the variables derived from the relevant decimal format in the static context, and produces as its output a number of variables with defined values. The formatting phase takes as its inputs the number to be formatted and the variables produced by the analysis phase, and produces as its output a string containing a formatted representation of the number.

The result of the function is the formatted string representation of the supplied number.

Error Conditions

An error is raised [err:FODF1280] if the name specified as the $decimal-format-name argument is not a valid lexical QName, or if its prefix has not been declared in an in-scope namespace declaration, or if the static context does not contain a declaration of a decimal-format with a matching expanded QName. If the processor is able to detect the error statically (for example, when the argument is supplied as a string literal), then the processor may optionally signal this as a static error.

Notes

Numbers will always be formatted with the most significant digit on the left.

4.6.3 Syntax of the Picture String

[Definition] The formatting of a number is controlled by a picture string. The picture string is a sequence of characters, in which the characters assigned to the variables decimal-separator-sign, grouping-sign, decimal-digit-family, optional-digit-sign and pattern-separator-sign are classified as active characters, and all other characters (including the percent-sign and per-mille-sign) are classified as passive characters.

The integer part of the sub-picture is defined as the part that appears to the left of the decimal-separator-sign if there is one, or the entire sub-picture otherwise. The fractional part of the sub-picture is defined as the part that appears to the right of the decimal-separator-sign if there is one; it is a zero-length string otherwise.

An error is raised [err:FODF1310] if the ·picture string· does not conform to the following rules. Note that in these rules the words "preceded" and "followed" refer to characters anywhere in the string, they are not to be read as "immediately preceded" and "immediately followed".

• A picture-string consists either of a sub-picture, or of two sub-pictures separated by a pattern-separator-sign. A picture-string must not contain more than one pattern-separator-sign. If the picture-string contains two sub-pictures, the first is used for positive values and the second for negative values.

• A sub-picture must not contain more than one decimal-separator-sign.

• A sub-picture must not contain more than one percent-sign or per-mille-sign, and it must not contain one of each.

• A sub-picture must contain at least one character that is an optional-digit-sign or a member of the decimal-digit-family.

• A sub-picture must not contain a passive character that is preceded by an active character and that is followed by another active character.

• A sub-picture must not contain a grouping-separator-sign adjacent to a decimal-separator-sign.

• The integer part of a sub-picture must not contain a member of the decimal-digit-family that is followed by an optional-digit-sign. The fractional part of a sub-picture must not contain an optional-digit-sign that is followed by a member of the decimal-digit-family.

4.6.4 Analysing the Picture String

This phase of the algorithm analyses the ·picture string· and the variables from the selected decimal format in the static context, and it has the effect of setting the values of various variables, which are used in the subsequent formatting phase. These variables are listed below. Each is shown with its initial setting and its data type.

Several variables are associated with each sub-picture. If there are two sub-pictures, then these rules are applied to one sub-picture to obtain the values that apply to positive numbers, and to the other to obtain the values that apply to negative numbers. If there is only one sub-picture, then the values for both cases are derived from this sub-picture.

The variables are as follows:

• The integer-part-grouping-positions is a sequence of integers representing the positions of grouping separators within the integer part of the sub-picture. For each grouping-separator-sign that appears within the integer part of the sub-picture, this sequence contains an integer that is equal to the total number of optional-digit-sign and decimal-digit-family characters that appear within the integer part of the sub-picture and to the right of the grouping-separator-sign. In addition, if these integer-part-grouping-positions are at regular intervals (that is, if they form a sequence N, 2N, 3N, ... for some integer value N, including the case where there is only one number in the list), then the sequence contains all integer multiples of N as far as necessary to accommodate the largest possible number.

• The minimum-integer-part-size is an integer indicating the minimum number of digits that will appear to the left of the decimal-separator-sign. It is normally set to the number of decimal-digit-family characters found in the integer part of the sub-picture. But if the sub-picture contains no decimal-digit-family character and no decimal-separator-sign, it is set to one.

  Note:

  There is no maximum integer part size. All significant digits in the integer part of the number will be displayed, even if this exceeds the number of optional-digit-sign and decimal-digit-family characters in the subpicture.

• The prefix is set to contain all passive characters in the sub-picture to the left of the leftmost active character. If the picture string contains only one sub-picture, the prefix for the negative sub-picture is set by concatenating the minus-sign character and the prefix for the positive sub-picture (if any), in that order.

• The fractional-part-grouping-positions is a sequence of integers representing the positions of grouping separators within the fractional part of the sub-picture. For each grouping-separator-sign that appears within the fractional part of the sub-picture, this sequence contains an integer that is equal to the total number of optional-digit-sign and decimal-digit-family characters that appear within the fractional part of the sub-picture and to the left of the grouping-separator-sign.

• The minimum-fractional-part-size is set to the number of decimal-digit-family characters found in the fractional part of the sub-picture.

• The maximum-fractional-part-size is set to the total number of optional-digit-sign and decimal-digit-family characters found in the fractional part of the sub-picture.

• The suffix is set to contain all passive characters to the right of the rightmost active character in the fractional part of the sub-picture.

4.6.5 Formatting the Number

This section describes the second phase of processing of the format-number function. This phase takes as input a number to be formatted (referred to as the input number), and the variables set up by analysing the decimal format in the static context and the ·picture string·, as described above. The result of this phase is a string, which forms the return value of the format-number function.

The algorithm for this second stage of processing is as follows:

1. If the input number is NaN (not a number), the result is the specified NaN-symbol (with no prefix or suffix).

2. In the rules below, the positive sub-picture and its associated variables are used if the input number is positive, and the negative sub-picture and its associated variables are used otherwise. Negative zero is taken as negative, positive zero as positive.

3. If the input number is positive or negative infinity, the result is the concatenation of the appropriate prefix, the infinity-symbol, and the appropriate suffix.

4. If the sub-picture contains a percent-sign, the number is multiplied by 100. If the sub-picture contains a per-mille-sign, the number is multiplied by 1000. The resulting number is referred to below as the adjusted number.

5. The adjusted number is converted (if necessary) to an xs:decimal value, using an implementation of xs:decimal that imposes no limits on the totalDigits or fractionDigits facets. If there are several such values that are numerically equal to the adjusted number (bearing in mind that if the adjusted number is an xs:double or xs:float, the comparison will be done by converting the decimal value back to an xs:double or xs:float), the one that is chosen should be one with the smallest possible number of digits not counting leading or trailing zeroes (whether significant or insignificant). For example, 1.0 is preferred to 0.9999999999, and 100000000 is preferred to 100000001. This value is then rounded so that it uses no more than maximum-fractional-part-size digits in its fractional part. The rounded number is defined to be the result of converting the adjusted number to an xs:decimal value, as described above, and then calling the function fn:round-half-to-even with this converted number as the first argument and the maximum-fractional-part-size as the second argument, again with no limits on the totalDigits or fractionDigits in the result.

6. The absolute value of the rounded number is converted to a string in decimal notation, with no insignificant leading or trailing zeroes, using the digits in the decimal-digit-family to represent the ten decimal digits, and the decimal-separator-sign to separate the integer part and the fractional part. (The value zero will at this stage be represented by a decimal-separator-sign on its own.)

7. If the number of digits to the left of the decimal-separator-sign is less than minimum-integer-part-size, leading zero-digit-sign characters are added to pad out to that size.

8. If the number of digits to the right of the decimal-separator-sign is less than minimum-fractional-part-size, trailing zero-digit-sign characters are added to pad out to that size.

9. For each integer N in the integer-part-grouping-positions list, a grouping-separator-sign character is inserted into the string immediately after that digit that appears in the integer part of the number and has N digits between it and the decimal-separator-sign, if there is such a digit.

10. For each integer N in the fractional-part-grouping-positions list, a grouping-separator-sign character is inserted into the string immediately before that digit that appears in the fractional part of the number and has N digits between it and the decimal-separator-sign, if there is such a digit.

11. If there is no decimal-separator-sign in the sub-picture, or if there are no digits to the right of the decimal-separator-sign character in the string, then the decimal-separator-sign character is removed from the string (it will be the rightmost character in the string).

12. The result of the function is the concatenation of the appropriate prefix, the string conversion of the number as obtained above, and the appropriate suffix.

4.7.1 math:pi

Summary

Returns the value of the mathematical constant π.

Signature

math:pi() as xs:double

Rules

This function returns the xs:double value whose lexical representation is 3.141592653589793e0

Examples

The expression 2*math:pi() returns 6.283185307179586e0.

The expression 60 * (math:pi() div 180) converts an angle of 60 degrees to radians.

4.7.2 math:sqrt

Summary

Returns the square root of the argument.

Signature

math:sqrt($arg as xs:double?) as xs:double?

Rules

If $arg is the empty sequence, the function returns the empty sequence.

If $arg is less than zero, the result is NaN.

If $arg is positive or negative zero, positive infinity, or NaN, then the result is $arg.

Otherwise the result is the xs:double value ·either side of· the mathematical square root of $arg.

4.7.3 math:sin

Summary

Returns the sine of the argument, expressed in radians.

Signature

math:sin($θ as xs:double?) as xs:double?

Rules

If $θ is the empty sequence, the function returns the empty sequence.

If $θ is positive or negative zero, the result is $θ.

If $θ is positive or negative infinity, or NaN, then the result is NaN.

Otherwise the result is the sine of $θ, treated as an angle in radians. If $θ is in the range -2π to +2π then the result is the xs:double value ·either side of· the mathematical sine of the angle; if it is outside this range, then the precision of the result is ·implementation-dependent·.

4.7.4 math:cos

Summary

Returns the cosine of the argument, expressed in radians.

Signature

math:cos($θ as xs:double?) as xs:double?

Rules

If $θ is the empty sequence, the function returns the empty sequence.

If $θ is positive or negative infinity, or NaN, then the result is NaN.

Otherwise the result is the cosine of $θ, treated as an angle in radians. If $θ is in the range -2π to +2π then the result is the xs:double value ·either side of· the mathematical cosine of the angle; if it is outside this range, then the precision of the result is ·implementation-dependent·.

4.7.5 math:tan

Summary

Returns the tangent of the argument, expressed in radians.

Signature

math:tan($θ as xs:double?) as xs:double?

Rules

If $θ is the empty sequence, the function returns the empty sequence.

If $θ is positive or negative infinity, or NaN, then the result is NaN.

Otherwise the result is the tangent of $θ, treated as an angle in radians. If $θ is in the range -2π to +2π then the result is the xs:double value ·either side of· the mathematical tangent of the angle; if it is outside this range, then the precision of the result is ·implementation-dependent·.

4.7.6 math:asin

Summary

Returns the arc sine of the argument, the result being in the range -π/2 to +π/2 radians.

Signature

math:asin($arg as xs:double?) as xs:double?

Rules

If $arg is the empty sequence, the function returns the empty sequence.

If $arg is positive or negative zero, the result is $arg.

If $arg is NaN, or if its absolute value is greater than one, then the result is NaN.

Otherwise the result is the arc sine of $arg, returned as an angle in radians in the range -π/2 to +π/2. The result is the xs:double value ·either side of· the mathematical arc sine of the argument.

4.7.7 math:acos

Summary

Returns the arc cosine of the argument, the result being in the range zero to +π radians.

Signature

math:acos($arg as xs:double?) as xs:double?

Rules

If $arg is the empty sequence, the function returns the empty sequence.

If $arg is NaN, or if its absolute value is greater than one, then the result is NaN.

Otherwise the result is the arc cosine of $arg, returned as an angle in radians in the range 0 to +π. The result is the xs:double value ·either side of· the mathematical arc cosine of the argument.

4.7.8 math:atan

Summary

Returns the arc tangent of the argument, the result being in the range -π/2 to +π/2 radians.

Signature

math:atan($arg as xs:double?) as xs:double?

Rules

If $arg is the empty sequence, the function returns the empty sequence.

If $arg is positive or negative zero, the result is $arg.

If $arg is NaN then the result is NaN.

Otherwise the result is the arc tangent of $arg, returned as an angle in radians in the range -π/2 to +π/2. The result is the xs:double value ·either side of· the mathematical arc tangent of the argument.

Editorial note
Need to add rules for the infinities?

5.2.1 fn:codepoints-to-string

Summary

Creates an xs:string from a sequence of [The Unicode Standard] codepoints.

Signature

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

Rules

The function returns the string made up from the characters whose Unicode codepoints are supplied in $arg. This will be the zero-length string if $arg is the empty sequence.

Error Conditions

If any of the codepoints in $arg is not a legal XML character, an error is raised [err:FOCH0001].

Examples

The expression fn:codepoints-to-string((2309, 2358, 2378, 2325)) returns "अशॊक".

5.2.2 fn:string-to-codepoints

Summary

Returns the sequence of [The Unicode Standard] codepoints that constitute an xs:string value.

Signature

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

Rules

The function returns a sequence of integers, each integer being the Unicode codepoint of the corresponding character in $arg.

If $arg is a zero-length string or the empty sequence, the function returns the empty sequence.

Examples

The expression fn:string-to-codepoints("Thérèse") returns (84, 104, 233, 114, 232, 115, 101).

5.3.1 Collations

A collation is a specification of the manner in which character strings are compared and, by extension, ordered. 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 codepoint values). The [Character Model for the World Wide Web 1.0: Fundamentals] 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 two different codepoints are, in fact, equal for comparison purposes (e.g., "v" and "w" are considered equivalent in some Swedish collations). Strings can be compared codepoint-by-codepoint or in a linguistically appropriate 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, nor does it provide a mechanism to perform tailoring. Instead, it assumes that the collation argument to the various functions below is a tailored and named collation.

The ·Unicode codepoint collation· is a collation available in every implementation, which sorts based on codepoint values. For further details see 5.3.2 The Unicode Codepoint Collation

In the ideal case, a collation should treat two strings as equal if the two strings are identical after Unicode normalization. Thus, the [Character Model for the World Wide Web 1.0: Normalization] recommends that all strings be subjected to early Unicode normalization and some collations will raise runtime errors if they encounter strings that are not properly normalized. However, 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 interoperability of operations on XML documents in general, there may be collations that operate on unnormalized strings and other collations that implicitly normalize strings before comparing them. Applications may choose the kind of collation best suited for their needs. Note that collations based on the Unicode collation algorithm implicitly normalize strings before comparison and 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 form must conform to an 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 calls of functions that use a collation but allow it to be omitted.

This specification does not define whether or not the collation URI is dereferenced. The collation URI may be an abstract identifier, or it may refer to an actual resource describing the collation. If it refers to a resource, this specification does not define the nature of that resource. One possible candidate is that the resource is a locale description expressed using the Locale Data Markup Language: see [Locale Data Markup Language].

Functions such as fn:compare and fn:max that compare xs:string values use a single collation URI to identify all aspects of the collation rules. This means that any parameters such as the strength of the collation must be specified as part of the collation URI. For example, suppose there is a collation " https://www.example.com/collations/French " that refers to a French collation that compares on the basis of base characters. Collations that use the same basic rules, but with higher strengths, for example, base characters and accents, or base characters, accents and case, would need to be given different names, say " https://www.example.com/collations/French1 " and " https://www.example.com/collations/French2 ". Note that some specifications use the term collation to refer to an algorithm that can be parameterized, but in this specification, each possible parameterization is considered to be a distinct collation.

The XQuery/XPath static context includes a provision for a default collation that can be used for string comparisons and ordering operations. See the description of the static context in Section 2.1.1 Static Context^XP. If the default collation is not specified by the user or the system, the default collation is the ·Unicode codepoint collation·.

5.3.2 The Unicode Codepoint Collation

[Definition] The collation URI https://www.w3.org/2005/xpath-functions/collation/codepoint identifies a collation which must be recognized by every implementation: it is referred to as the Unicode codepoint collation (not to be confused with the Unicode collation algorithm).

The Unicode codepoint collation does not perform any normalization on the supplied strings.

The collation is defined as follows. Each of the two strings is converted to a sequence of integers using the fn:string-to-codepoints function. These two sequences $A and $B are then compared as follows:

• If both sequences are empty, the strings are equal

• If one sequence is empty and the other is not, then the string corresponding to the empty sequence is less than the other string.

• If the first integer in $A is less than the first integer in $B, then the string corresponding to $A is less than the string corresponding to $B.

• If the first integer in $A is greater than the first integer in $B, then the string corresponding to $A is greater than the string corresponding to $B.

• Otherwise (the first pair of integers are equal), the result is obtained by applying the same rules recursively to fn:subsequence($A, 2) and fn:subsequence($B, 2)

5.3.3 Choosing a Collation

Many functions have two signatures, where one signature includes a $collation argument and the other omits this argument.

The collation to use for these functions is determined by the following rules:

1. If the function specifies an explicit collation, CollationA (e.g., if the optional collation argument is specified in a call of the fn:compare function), then:

   • If CollationA is supported by the implementation, then CollationA is used.

   • Otherwise, an error is raised [err:FOCH0002].

2. If no collation is explicitly specified for the function and the default collation in the XQuery/XPath static context is CollationB, then:

   • If CollationB is supported by the implementation, then CollationB is used.

   • Otherwise, an error is raised [err:FOCH0002].

5.3.4 fn:compare

Summary

Returns -1, 0, or 1, depending on whether $comparand1 collates before, equal to, or after $comparand2 according to the rules of a selected collation.

Signatures

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

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

Rules

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 this function is determined according to the rules in 5.3.3 Choosing a Collation.

If either $comparand1 or $comparand2 is the empty sequence, the function returns the empty sequence.

This function, called with the first signature, defines the semantics of the "eq", "ne", "gt", "lt", "le" and "ge" operators on xs:string values.

Examples

The expression fn:compare('abc', 'abc') returns 0.

The expression fn:compare('Strasse', 'Straße') returns 0. (Assuming 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.).

The expression fn:compare('Strasse', 'Straße', 'https://example.com/deutsch') returns 0. (Assuming the collation identified by the URI https://example.com/deutsch includes provisions that equate "ss" and the (German) character "ß" ("sharp-s"). Otherwise, the returned value depends on the semantics of that collation.).

The expression fn:compare('Strassen', 'Straße') returns 1. (Assuming the default collation includes provisions that treat differences between "ss" and the (German) character "ß" ("sharp-s") with less strength than the differences between the base characters, such as the final "n". ).

5.3.5 fn:codepoint-equal

Summary

Returns true if two strings are equal, considered codepoint-by-codepoint.

Signature

fn:codepoint-equal(	$comparand1	as xs:string?,
	$comparand2	as xs:string?) as xs:boolean?

Rules

If either argument is the empty sequence, the function returns the empty sequence.

Otherwise, the function returns true or false depending on whether the value of $comparand1 is equal to the value of $comparand2, according to the Unicode codepoint collation (https://www.w3.org/2005/xpath-functions/collation/codepoint).

Notes

This function allows xs:anyURI values to be compared without having to specify the Unicode codepoint collation.

5.4.1 fn:concat

Summary

Returns the concatenation of the string values of the arguments.

Signature

fn:concat(	$arg1	as xs:anyAtomicType?,
	$arg2	as xs:anyAtomicType?,
	...	) as xs:string

Rules

This function accepts two or more xs:anyAtomicType arguments and casts each one to xs:string. The function returns the xs:string that is the concatenation of the values of its arguments after conversion. If any argument is the empty sequence, that argument is treated as the zero-length string.

The fn:concat function is specified to allow two or more arguments, which are concatenated together. This is the only function specified in this document that allows a variable number of arguments. This capability is retained for compatibility with [XML Path Language (XPath) Version 1.0].

Notes

As mentioned in 5.1 String Types Unicode normalization is not automatically applied to the result of fn:concat. If a normalized result is required, fn:normalize-unicode can be applied to the xs:string returned by fn:concat. The following XQuery:

let $v1 := "I plan to go to Mu"
let $v2 := "?nchen in September"
return concat($v1, $v2)

where the "?" represents either the actual Unicode character COMBINING DIARESIS (Unicode codepoint U+0308) or "̈", will return:

"I plan to go to Mu?nchen in September"

where the "?" represents either the actual Unicode character COMBINING DIARESIS (Unicode codepoint U+0308) or "̈". It is worth noting that the returned value is not normalized in NFC; however, it is normalized in NFD. .

However, the following XQuery:

let $v1 := "I plan to go to Mu"
let $v2 := "?nchen in September"
return normalize-unicode(concat($v1, $v2))

where the "?" represents either the actual Unicode character COMBINING DIARESIS (Unicode codepoint U+0308) or "̈", will return:

"I plan to go to München in September"

This returned result is normalized in NFC.

Examples

The expression fn:concat('un', 'grateful') returns "ungrateful".

The expression fn:concat('Thy ', (), 'old ', "groans", "", ' ring', ' yet', ' in', ' my', ' ancient',' ears.') returns "Thy old groans ring yet in my ancient ears.".

The expression fn:concat('Ciao!',()) returns "Ciao!".

The expression fn:concat('Ingratitude, ', 'thou ', 'marble-hearted', ' fiend!') returns "Ingratitude, thou marble-hearted fiend!".

5.4.2 fn:string-join

Summary

Returns a string created by concatenating the items in a sequence, with a defined separator between adjacent items.

Signatures

fn:string-join($arg1 as xs:string*) as xs:string

fn:string-join($arg1 as xs:string*, $arg2 as xs:string) as xs:string

Rules

The effect of calling the single-argument version of this function is the same as calling the two-argument version with $arg2 set to a zero-length string.

The function returns an xs:string created by concatenating the items in the sequence $arg1, in order, using the value of $arg2 as a separator between adjacent items. If the value of $arg2 is the zero-length string, then the members of $arg1 are concatenated without a separator.

Notes

If the value of $arg1 is the empty sequence, the function returns the zero-length string.

Examples

The expression fn:string-join(('Now', 'is', 'the', 'time', '...'), ' ') returns "Now is the time ...".

The expression fn:string-join(('Blow, ', 'blow, ', 'thou ', 'winter ', 'wind!'), '') returns "Blow, blow, thou winter wind!".

The expression fn:string-join((), 'separator') returns "".

Assume a document:

<doc>
  <chap>
    <section/>
  </chap>
</doc>

with the <section> element as the context node, the [XML Path Language (XPath) 2.0] expression:

fn:string-join(ancestor-or-self::*/name(), '/')

returns "doc/chap/section"

5.4.3 fn:substring

Summary

Returns the portion of the value of $sourceString beginning at the position indicated by the value of $start and continuing for the number of characters indicated by the value of $length.

Signatures

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

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

Rules

If the value of $sourceString is the empty sequence, the function returns the zero-length string.

Otherwise, the function returns a string comprising those characters of $sourceString whose index position (counting from one) is greater than or equal to the value of $start (rounded to an integer), and (if $length is specified) less than the sum of $start and $length (both rounded to integers).

The characters returned do not extend beyond $sourceString. If $start is zero or negative, only those characters in positions greater than zero are returned.

More specifically, the three argument version of the function returns the characters in $sourceString whose position $p satisfies:

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

The two argument version of the function assumes that $length is infinite and thus returns the characters in $sourceString whose position $p satisfies:

fn:round($start) <= $p

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

Notes

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

Examples

The expression fn:substring("motor car", 6) returns " car". (Characters starting at position 6 to the end of $sourceString are selected.).

The expression fn:substring("metadata", 4, 3) returns "ada". (Characters at positions greater than or equal to 4 and less than 7 are selected.).

The expression fn:substring("12345", 1.5, 2.6) returns "234". (Characters at positions greater than or equal to 2 and less than 5 are selected.).

The expression fn:substring("12345", 0, 3) returns "12". (Characters at positions greater than or equal to 0 and less than 3 are selected. Since the first position is 1, these are the characters at positions 1 and 2.).

The expression fn:substring("12345", 5, -3) returns "". (Characters at positions greater than or equal to 5 and less than 2 are selected.).

The expression fn:substring("12345", -3, 5) returns "1". (Characters at positions greater than or equal to -3 and less than 2 are selected. Since the first position is 1, this is the character at position 1.).

The expression fn:substring("12345", 0 div 0E0, 3) returns "". (Since 0 div 0E0 returns NaN, and NaN compared to any other number returns false, no characters are selected.).

The expression fn:substring("12345", 1, 0 div 0E0) returns "". (As above.).

The expression fn:substring((), 1, 3) returns "".

The expression fn:substring("12345", -42, 1 div 0E0) returns "12345". (Characters at positions greater than or equal to -42 and less than INF are selected.).

The expression fn:substring("12345", -1 div 0E0, 1 div 0E0) returns "". (Since the value of -INF + INF is NaN, no characters are selected.).

5.4.4 fn:string-length

Summary

Returns the number of characters in a string.

Signatures

fn:string-length() as xs:integer

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

Rules

The function returns an xs:integer equal to the length in characters of the value of $arg.

Calling the zero-argument version of the function is equivalent to calling fn:string-length(fn:string(.)).

If the value of $arg is the empty sequence, the function returns the xs:integer value zero (0).

Error Conditions

If $arg is not specified and the context item is undefined, an error is raised: [err:XPDY0002]^XP.

Notes

Unlike some programming languages, a codepoint greater than 65535 counts as one character, not two.

Examples

The expression fn:string-length("Harp not on that string, madam; that is past.") returns 45.

The expression fn:string-length(()) returns 0.

5.4.5 fn:normalize-space

Summary

Returns the value of $arg with leading and trailing whitespace removed, and sequences of internal whitespace reduced to a single space character.

Signatures

fn:normalize-space() as xs:string

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

Rules

If the value of $arg is the empty sequence, the function returns the zero-length string.

The function returns a string constructed by stripping leading and trailing whitespace from the value of $arg, and replacing sequences of one or more adjacent whitespace characters with a single space, #x20.

The whitespace characters are defined in the metasymbol S (Production 3) of [REC-xml].

If no argument is supplied, then $arg defaults to the string value (calculated using fn:string) of the context item (.).

Error Conditions

If no argument is supplied and the context item is undefined then an error is raised: [err:XPDY0002]^XP.

Notes

The definition of whitespace is unchanged in [Extensible Markup Language (XML) 1.1 Recommendation].

Examples

The expression fn:normalize-space(" The    wealthy curled darlings                                         of    our    nation. ") returns "The wealthy curled darlings of our nation.".

The expression fn:normalize-space(()) returns "".

5.4.6 fn:normalize-unicode

Summary

Returns the value of $arg after applying Unicode normalization.

Signatures

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

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

Rules

If the value of $arg is the empty sequence, the function returns the zero-length string.

If the single-argument version of the function is used, the result is the same as calling the two-argument version with $normalizationForm set to the string "NFC".

Otherwise, the function returns the value of $arg normalized according to the rules of the normalization form identified by the value of $normalizationForm.

The effective value of $normalizationForm is the value of the expression fn:upper-case(fn:normalize-space($normalizationForm)).

See [Character Model for the World Wide Web 1.0: Normalization] for a description of the normalization forms.

• If the effective value of $normalizationForm is "NFC", then the function returns the value of $arg converted to Unicode Normalization Form C (NFC).

• If the effective value of $normalizationForm is "NFD", then the function returns the value of $arg converted to Unicode Normalization Form D (NFD).

• If the effective value of $normalizationForm is "NFKC", then the function returns the value of $arg in Unicode Normalization Form KC (NFKC).

• If the effective value of $normalizationForm is "NFKD", then the function returns the value of $arg converted to Unicode Normalization Form KD (NFKD).

• If the effective value of $normalizationForm is "FULLY-NORMALIZED", then the function returns the value of $arg converted to fully normalized form.

• If the effective value of $normalizationForm is the zero-length string, no normalization is performed and $arg is returned.

Conforming implementations ·must· support normalization form "NFC" and ·may· support normalization forms "NFD", "NFKC", "NFKD", and "FULLY-NORMALIZED". They ·may· also support other normalization forms with ·implementation-defined· semantics.

Error Conditions

If the effective value of the $normalizationForm argument is not one of the values supported by the implementation, then an error is raised [err:FOCH0003].

5.4.7 fn:upper-case

Summary

Converts a string to upper case.

Signature

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

Rules

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

Otherwise, the function returns the value of $arg after translating every character to its upper-case correspondent as defined in the appropriate case mappings section in the Unicode standard [The Unicode Standard]. For versions of Unicode beginning with the 2.1.8 update, only locale-insensitive case mappings should be applied. Beginning with version 3.2.0 (and likely future versions) of Unicode, precise mappings are described in default case operations, which are full case mappings in the absence of tailoring for particular languages and environments. Every lower-case character that does not have an upper-case correspondent, as well as every upper-case character, is included in the returned value in its original form.

Notes

Case mappings may change the length of a string. In general, the fn:upper-case and fn:lower-case functions are not inverses of each other: fn:lower-case(fn:upper-case($arg)) is not guaranteed to return $arg, nor is fn:upper-case(fn:lower-case($arg)). The Latin small letter dotless i (as used in Turkish) is perhaps the most prominent lower-case letter which will not round-trip. The Latin capital letter i with dot above is the most prominent upper-case letter which will not round trip; there are others, such as Latin capital letter Sharp S (#1E9E) which is introduced in Unicode 5.1.

These functions may not always be linguistically appropriate (e.g. Turkish i without dot) or appropriate for the application (e.g. titlecase). In cases such as Turkish, a simple translation should be used first.

Because the function is not sensitive to locale, results will not always match user expectations. In Quebec, for example, the standard uppercase equivalent of "è" is "È", while in metropolitan France it is more commonly "E"; only one of these is supported by the functions as defined.

Many characters of class Ll lack uppercase equivalents in the Unicode case mapping tables; many characters of class Lu lack lowercase equivalents.

Examples

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

5.4.8 fn:lower-case

Summary

Converts a string to lower case.

Signature

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

Rules

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

Otherwise, the function returns the value of $arg after translating every character to its lower-case correspondent as defined in the appropriate case mappings section in the Unicode standard [The Unicode Standard]. For versions of Unicode beginning with the 2.1.8 update, only locale-insensitive case mappings should be applied. Beginning with version 3.2.0 (and likely future versions) of Unicode, precise mappings are described in default case operations, which are full case mappings in the absence of tailoring for particular languages and environments. Every upper-case character that does not have a lower-case correspondent, as well as every lower-case character, is included in the returned value in its original form.

Notes

Case mappings may change the length of a string. In general, the fn:upper-case and fn:lower-case functions are not inverses of each other: fn:lower-case(fn:upper-case($arg)) is not guaranteed to return $arg, nor is fn:upper-case(fn:lower-case($arg)). The Latin small letter dotless i (as used in Turkish) is perhaps the most prominent lower-case letter which will not round-trip. The Latin capital letter i with dot above is the most prominent upper-case letter which will not round trip; there are others, such as Latin capital letter Sharp S (#1E9E) which is introduced in Unicode 5.1.

These functions may not always be linguistically appropriate (e.g. Turkish i without dot) or appropriate for the application (e.g. titlecase). In cases such as Turkish, a simple translation should be used first.

Because the function is not sensitive to locale, results will not always match user expectations. In Quebec, for example, the standard uppercase equivalent of "è" is "È", while in metropolitan France it is more commonly "E"; only one of these is supported by the functions as defined.

Many characters of class Ll lack uppercase equivalents in the Unicode case mapping tables; many characters of class Lu lack lowercase equivalents.

Examples

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

5.4.9 fn:translate

Summary

Returns the value of $arg modified by replacing or removing individual characters.

Signature

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

Rules

If the value of $arg is the empty sequence, the function returns the zero-length string.

Otherwise, the function returns a result string constructed by processing each character in the value of $arg, in order, according to the following rules:

1. If the character does not appear in the value of $mapString then it is added to the result string unchanged.

2. If the character first appears in the value of $mapString at some position M, where the value of $transString is M or more characters in length, then the character at position M in $transString is added to the result string.

3. If the character first appears in the value of $mapString at some position M, where the value of $transString is less than M characters in length, then the character is omitted from the result string.

Notes

If $mapString is the zero-length string then the function returns $arg unchanged.

If a character occurs more than once in $mapString, then the first occurrence determines the action taken.

If $transString is longer than $mapString, the excess characters are ignored.

Examples

The expression fn:translate("bar","abc","ABC") returns "BAr".

The expression fn:translate("--aaa--","abc-","ABC") returns "AAA".

The expression fn:translate("abcdabc", "abc", "AB") returns "ABdAB".

5.5.1 fn:contains

Summary

Returns true if the string $arg1 contains $arg2 as a substring, taking collations into account.

Signatures

fn:contains($arg1 as xs:string?, $arg2 as xs:string?) as xs:boolean

fn:contains(	$arg1	as xs:string?,
	$arg2	as xs:string?,
	$collation	as xs:string) as xs:boolean

Rules

If the value of $arg1 or $arg2 is the empty sequence, or contains only ignorable collation units, it is interpreted as the zero-length string.

If the value of $arg2 is the zero-length string, then the function returns true.

If the value of $arg1 is the zero-length string, the function returns false.

The collation used by this function is determined according to the rules in 5.3.3 Choosing a Collation.

The function returns an xs:boolean indicating whether or not the value of $arg1 contains (at the beginning, at the end, or anywhere within) at least one sequence of collation units that provides a minimal match to the collation units in the value of $arg2, according to the collation that is used.

Note:

Minimal match is defined in [Unicode Collation Algorithm].

Error Conditions

If the specified collation does not support collation units an error ·may· be raised [err:FOCH0004].

Examples

The collation used in these examples, https://example.com/CollationA is a collation in which both "-" and "*" are ignorable collation units.

"Ignorable collation unit" is equivalent to "ignorable collation element" in [Unicode Collation Algorithm].

The expression fn:contains ( "tattoo", "t") returns true().

The expression fn:contains ( "tattoo", "ttt") returns false().

The expression fn:contains ( "", ()) returns true(). (The first rule is applied, followed by the second rule.).

The expression fn:contains ( "abcdefghi", "-d-e-f-", "https://example.com/CollationA") returns true().

The expression fn:contains ( "a*b*c*d*e*f*g*h*i*", "d-ef-", "https://example.com/CollationA") returns true().

The expression fn:contains ( "abcd***e---f*--*ghi", "def", "https://example.com/CollationA") returns true().

The expression fn:contains ( (), "--***-*---", "https://example.com/CollationA") returns true(). (The second argument contains only ignorable collation units and is equivalent to the zero-length string.).

5.5.2 fn:starts-with

Summary

Returns true if the string $arg1 contains $arg2 as a leading substring, taking collations into account.

Signatures

fn:starts-with($arg1 as xs:string?, $arg2 as xs:string?) as xs:boolean

fn:starts-with(	$arg1	as xs:string?,
	$arg2	as xs:string?,
	$collation	as xs:string) as xs:boolean

Rules

If the value of $arg1 or $arg2 is the empty sequence, or contains only ignorable collation units, it is interpreted as the zero-length string.

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

The collation used by this function is determined according to the rules in 5.3.3 Choosing a Collation.

The function returns an xs:boolean indicating whether or not the value of $arg1 starts with a sequence of collation units that provides a match to the collation units of $arg2 according to the collation that is used.

Note:

Match is defined in [Unicode Collation Algorithm].

Error Conditions

If the specified collation does not support collation units an error ·may· be raised [err:FOCH0004].

Examples

The collation used in these examples, https://example.com/CollationA is a collation in which both "-" and "*" are ignorable collation units.

"Ignorable collation unit" is equivalent to "ignorable collation element" in [Unicode Collation Algorithm].

The expression fn:starts-with("tattoo", "tat") returns true().

The expression fn:starts-with ( "tattoo", "att") returns false().

The expression fn:starts-with ((), ()) returns true().

The expression fn:starts-with ( "abcdefghi", "-a-b-c-", "https://example.com/CollationA") returns true().

The expression fn:starts-with ( "a*b*c*d*e*f*g*h*i*", "a-bc-", "https://example.com/CollationA") returns true().

The expression fn:starts-with ( "abcd***e---f*--*ghi", "abcdef", "https://example.com/CollationA") returns true().

The expression fn:starts-with ( (), "--***-*---", "https://example.com/CollationA") returns true(). (The second argument contains only ignorable collation units and is equivalent to the zero-length string.).

The expression fn:starts-with ( "-abcdefghi", "-abc", "https://example.com/CollationA") returns true().

5.5.3 fn:ends-with

Summary

Returns true if the string $arg1 contains $arg2 as a trailing substring, taking collations into account.

Signatures

fn:ends-with($arg1 as xs:string?, $arg2 as xs:string?) as xs:boolean

fn:ends-with(	$arg1	as xs:string?,
	$arg2	as xs:string?,
	$collation	as xs:string) as xs:boolean

Rules

If the value of $arg1 or $arg2 is the empty sequence, or contains only ignorable collation units, it is interpreted as the zero-length string.

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

The collation used by this function is determined according to the rules in 5.3.3 Choosing a Collation.

The function returns an xs:boolean indicating whether or not the value of $arg1 starts with a sequence of collation units that provides a match to the collation units of $arg2 according to the collation that is used.

Note:

Match is defined in [Unicode Collation Algorithm].

Error Conditions

If the specified collation does not support collation units an error ·may· be raised [err:FOCH0004].

Examples

The collation used in these examples, https://example.com/CollationA is a collation in which both "-" and "*" are ignorable collation units.

"Ignorable collation unit" is equivalent to "ignorable collation element" in [Unicode Collation Algorithm].

The expression fn:ends-with ( "tattoo", "tattoo") returns true().

The expression fn:ends-with ( "tattoo", "atto") returns false().

The expression fn:ends-with ((), ()) returns true().

The expression fn:ends-with ( "abcdefghi", "-g-h-i-", "https://example.com/CollationA") returns true().

The expression fn:ends-with ( "abcd***e---f*--*ghi", "defghi", "https://example.com/CollationA") returns true().

The expression fn:ends-with ( "abcd***e---f*--*ghi", "defghi", "https://example.com/CollationA") returns true().

The expression fn:ends-with ( (), "--***-*---", "https://example.com/CollationA") returns true(). (The second argument contains only ignorable collation units and is equivalent to the zero-length string.).

The expression fn:ends-with ( "abcdefghi", "ghi-", "https://example.com/CollationA") returns true().

5.5.4 fn:substring-before

Summary

Returns the part of $arg1 that precedes the first occurrence of $arg2, taking collations into account.

Signatures

fn:substring-before($arg1 as xs:string?, $arg2 as xs:string?) as xs:string

fn:substring-before(	$arg1	as xs:string?,
	$arg2	as xs:string?,
	$collation	as xs:string) as xs:string

Rules

If the value of $arg1 or $arg2 is the empty sequence, or contains only ignorable collation units, it is interpreted as the zero-length string.

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

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

The collation used by this function is determined according to the rules in 5.3.3 Choosing a Collation.

The function returns the substring of the value of $arg1 that precedes in the value of $arg1 the first occurrence of a sequence of collation units that provides a minimal match to the collation units of $arg2 according to the collation that is used.

Note:

Minimal match is defined in [Unicode Collation Algorithm].

Error Conditions

If the specified collation does not support collation units an error ·may· be raised [err:FOCH0004].

Examples

The collation used in these examples, https://example.com/CollationA is a collation in which both "-" and "*" are ignorable collation units.

"Ignorable collation unit" is equivalent to "ignorable collation element" in [Unicode Collation Algorithm].

The expression fn:substring-before ( "tattoo", "attoo") returns "t".

The expression fn:substring-before ( "tattoo", "tatto") returns "".

The expression fn:substring-before ((), ()) returns "".

The expression fn:substring-before ( "abcdefghi", "--d-e-", "https://example.com/CollationA") returns "abc".

The expression fn:substring-before ( "abc--d-e-fghi", "--d-e-", "https://example.com/CollationA") returns "abc--".

The expression fn:substring-before ( "a*b*c*d*e*f*g*h*i*", "***cde", "https://example.com/CollationA") returns "a*b*".

The expression fn:substring-before ( "Eureka!", "--***-*---", "https://example.com/CollationA") returns "". (The second argument contains only ignorable collation units and is equivalent to the zero-length string.).

5.5.5 fn:substring-after

Summary

Returns the part of $arg1 that follows the first occurrence of $arg2, taking collations into account.

Signatures

fn:substring-after($arg1 as xs:string?, $arg2 as xs:string?) as xs:string

fn:substring-after(	$arg1	as xs:string?,
	$arg2	as xs:string?,
	$collation	as xs:string) as xs:string

Rules

If the value of $arg1 or $arg2 is the empty sequence, or contains only ignorable collation units, it is interpreted as the zero-length string.

If the value of $arg2 is the zero-length string, then the function returns the value of $arg1.

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

The collation used by this function is determined according to the rules in 5.3.3 Choosing a Collation.

The function returns the substring of the value of $arg1 that follows in the value of $arg1 the first occurrence of a sequence of collation units that provides a minimal match to the collation units of $arg2 according to the collation that is used.

Note:

Minimal match is defined in [Unicode Collation Algorithm].

Error Conditions

If the specified collation does not support collation units an error ·may· be raised [err:FOCH0004].

Examples

The collation used in these examples, https://example.com/CollationA is a collation in which both "-" and "*" are ignorable collation units.

"Ignorable collation unit" is equivalent to "ignorable collation element" in [Unicode Collation Algorithm].

The expression fn:substring-after("tattoo", "tat") returns "too".

The expression fn:substring-after("tattoo", "tattoo") returns "".

The expression fn:substring-after((), ()) returns "".

The expression fn:substring-after("abcdefghi", "--d-e-", "https://example.com/CollationA") returns "fghi".

The expression fn:substring-after("abc--d-e-fghi", "--d-e-", "https://example.com/CollationA") returns "-fghi".

The expression fn:substring-after ( "a*b*c*d*e*f*g*h*i*", "***cde***", "https://example.com/CollationA") returns "*f*g*h*i*".

The expression fn:substring-after ( "Eureka!", "--***-*---", "https://example.com/CollationA") returns "Eureka!". (The second argument contains only ignorable collation units and is equivalent to the zero-length string.).

5.6.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 Second Edition]), 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 are identical to those defined in [XML Schema Part 2: Datatypes Second Edition] with the following additions:

• Two meta-characters, ^ and $ are added. By default, the meta-character ^ matches the start of the entire string, while $ matches the end of the entire string. In multi-line 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 Second Edition]:

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

  is modified to read:

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

  The characters #x5B and #x5D correspond to "[" and "]" respectively.

  Note:

  The definition of Char (production [10]) in [XML Schema Part 2: Datatypes Second Edition] has a known error in which it omits the left brace ("{") and right brace ("}"). That error is corrected here.

  The following production:

  [11] charClass ::= charClassEsc | charClassExpr | WildCardEsc

  is modified to read:

  [11] charClass ::= charClassEsc | charClassExpr | WildCardEsc | "^" | "$"

• Reluctant quantifiers are supported. They are indicated by a " ? " following a quantifier. 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. Without the " ? ", the regular expression matches the longest possible substring.

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

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

  is changed to:

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

  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.

• Sub-expressions (groups) within the regular expression are recognized. The regular expression syntax defined by [XML Schema Part 2: Datatypes Second Edition] 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. 0 identifies the substring captured by the entire regular expression. 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.

  Non-capturing groups are also recognized. These are indicated by the syntax (?:xxxx). Specifically, the production rule for atom in [XML Schema Part 2: Datatypes Second Edition] is changed from:

  [9] atom ::= Char | charClass | ( '(' regExp ')' )

  to:

  [9] atom ::= Char | charClass | ( '(' '?:'? regExp ')' )

  The presence of the optional ?: has no effect on the set of strings that match the regular expression, but causes the left parenthesis not to be counted by operations that number the groups within a regular expression, for example the fn:replace function.

• Back-references are allowed outside a character class expression. A back-reference is an additional kind of atom. The construct \N where N is a single digit is always recognized as a back-reference; if this is followed by further digits, these digits are taken to be part of the back-reference if and only if the resulting number NN is such that the back-reference is preceded by NN or more unescaped opening parentheses. The regular expression is invalid if a back-reference refers to a subexpression that does not exist or whose closing right parenthesis occurs after the back-reference.

  A back-reference matches the string that was matched by the Nth capturing subexpression within the regular expression, that is, the parenthesized subexpression whose opening left parenthesis is the Nth unescaped left parenthesis within the regular expression. For example, the regular expression ('|").*\1 matches a sequence of characters delimited either by an apostrophe at the start and end, or by a quotation mark at the start and end.

  If no string is matched by the Nth capturing subexpression, the back-reference is interpreted as matching a zero-length string.

  Back-references change the following production:

  [9] atom ::= Char | charClass | ( '(' regExp ')' )

  to

  [9] atom ::= Char | charClass | ( '(' regExp ')' ) | backReference

  [9a] backReference ::= "\" [1-9][0-9]*

  Note:

  Within a character class expression, \ followed by a digit is invalid. Some other regular expression languages interpret this as an octal character reference.

• Single character escapes are extended to allow the $ character to be escaped. The following production is changed:

  [24]SingleCharEsc ::= '\' [nrt\|.?*+(){}#x2D#x5B#x5D#x5E]

  to

  [24]SingleCharEsc ::= '\' [nrt\|.?*+(){}$#x2D#x5B#x5D#x5E]

5.6.2 fn:matches

Summary

Returns true if the supplied string matches a given regular expression.

Signatures

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

Rules

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. Flags are defined in 5.6.1.1 Flags.

If $input is the empty sequence, it is interpreted as the zero-length string.

The function returns true if $input or some substring of $input matches the regular expression supplied as $pattern. Otherwise, the function returns false. The matching rules are influenced by the value of $flags if present.

Error Conditions

An error is raised [err:FORX0002] if the value of $pattern is invalid according to the rules described in 5.6.1 Regular Expression Syntax.

An error is raised [err:FORX0001] if the value of $flags is invalid according to the rules described in 5.6.1.1 Flags.

Notes

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

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

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

Examples

The expression fn:matches("abracadabra", "bra") returns true().

The expression fn:matches("abracadabra", "^a.*a$") returns true().

The expression fn:matches("abracadabra", "^bra") returns false().

Given the source document:

let $poem :=

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

The expression fn:matches($poem, "Kaum.*krähen") returns false().

The expression fn:matches($poem, "Kaum.*krähen", "s") returns true().

The expression fn:matches($poem, "^Kaum.*gesehen,$", "m") returns true().

The expression fn:matches($poem, "^Kaum.*gesehen,$") returns false().

The expression fn:matches($poem, "kiki", "i") returns true().

5.6.3 fn:replace

Summary

Returns a string produced from the input string by replacing any substrings that match a given regular expression with a supplied replacement string.

Signatures

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

Rules

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. Flags are defined in 5.6.1.1 Flags.

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

If $input is the empty sequence, it is interpreted as the zero-length string.

The function returns the xs:string that is obtained by replacing each non-overlapping substring of $input that matches 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.

If the q flag is present, the replacement string is used as is.

Otherwise, within the $replacement string, a variable $N may be used to refer to the substring captured by the Nth parenthesized sub-expression in the regular expression. For each match of the pattern, these variables are assigned the value of the content matched by the relevant sub-expression, and the modified replacement string is then substituted for the characters in $input that matched the pattern. $0 refers to the substring captured by the regular expression as a whole.

More specifically, the rules are as follows, where S is the number of parenthesized sub-expressions in the regular expression, and N is the decimal number formed by taking all the digits that consecutively follow the $ character:

1. If N=0, then the variable is replaced by the substring matched by the regular expression as a whole.

2. If 1<=N<=S, then the variable is replaced by the substring captured by the Nth parenthesized sub-expression. If the Nth parenthesized sub-expression was not matched, then the variable is replaced by the zero-length string.

3. If S<N<=9, then the variable is replaced by the zero-length string.

4. Otherwise (if N>S and N>9), the last digit of N is taken to be a literal character to be included "as is" in the replacement string, and the rules are reapplied using the number N formed by stripping off this last digit.

For example, if the replacement string is " $23 " and there are 5 substrings, the result contains the value of the substring that matches the second sub-expression, followed by the digit " 3 ".

Unless the q flag is used, a literal $ character within the replacement string must be written as \$, and a literal \ character must be written as \\.

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"

Error Conditions

An error is raised [err:FORX0002] if the value of $pattern is invalid according to the rules described in section 5.6.1 Regular Expression Syntax.

An error is raised [err:FORX0001] if the value of $flags is invalid according to the rules described in section 5.6.1 Regular Expression Syntax.

An error is raised [err:FORX0003] if the pattern matches a zero-length string, that is, if the expression fn:matches("", $pattern, $flags) returns true. It is not an error, however, if a captured substring is zero-length.

An error is raised [err:FORX0004] if the value of $replacement contains a "$" character that is not immediately followed by a digit 0-9 and not immediately preceded by a "\".

An error is raised [err:FORX0004] if the value of $replacement contains a "\" character that is not part of a "\\" pair, unless it is immediately followed by a "$" character.

Examples

The expression replace("abracadabra", "bra", "*") returns "a*cada*".

The expression replace("abracadabra", "a.*a", "*") returns "*".

The expression replace("abracadabra", "a.*?a", "*") returns "*c*bra".

The expression replace("abracadabra", "a", "") returns "brcdbr".

The expression replace("abracadabra", "a(.)", "a$1$1") returns "abbraccaddabbra".

The expression replace("abracadabra", ".*?", "$1") raises an error, because the pattern matches the zero-length string

The expression replace("AAAA", "A+", "b") returns "b".

The expression replace("AAAA", "A+?", "b") returns "bbbb".

The expression replace("darted", "^(.*?)d(.*)$", "$1c$2") returns "carted". (The first d is replaced.).

5.6.4 fn:tokenize

Summary

Returns a sequence of strings constructed by splitting the input wherever a separator is found; the separator is any substring that matches a given regular expression.

Signatures

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*

Rules

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. Flags are defined in 5.6.1.1 Flags.

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

If $input is the empty sequence, or if $input is the zero-length string, the function returns the empty sequence.

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

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", "")

Error Conditions

An error is raised [err:FORX0002] if the value of $pattern is invalid according to the rules described in section 5.6.1 Regular Expression Syntax.

An error is raised [err:FORX0001] if the value of $flags is invalid according to the rules described in section 5.6.1 Regular Expression Syntax.

If the supplied $pattern matches a zero-length string, that is, if fn:matches("", $pattern, $flags) returns true, then an error is raised: [err:FORX0003].

Examples

The expression fn:tokenize("The cat sat on the mat", "\s+") returns ("The", "cat", "sat", "on", "the", "mat").

The expression fn:tokenize("1, 15, 24, 50", ",\s*") returns ("1", "15", "24", "50").

The expression fn:tokenize("1,15,,24,50,", ",") returns ("1", "15", "", "24", "50", "").

fn:tokenize("abba", ".?") raises the error [err:FORX0003].

The expression fn:tokenize("Some unparsed <br> HTML <BR> text", "\s*<br>\s*", "i") returns ("Some unparsed", "HTML", "text").

5.6.5 fn:analyze-string

Summary

Analyzes a string using a regular expression, returning an XML structure that identifies which parts of the input string matched or failed to match the regular expression, and in the case of matched substrings, which substrings matched each capturing group in the regular expression.

Signatures

fn:analyze-string(	$input	as xs:string?,
	$pattern	as xs:string) as element(fn:analyze-string-result)

fn:analyze-string(	$input	as xs:string?,
	$pattern	as xs:string,
	$flags	as xs:string) as element(fn:analyze-string-result)

Rules

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. Flags are defined in 5.6.1.1 Flags.

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

If $input is the empty sequence the function behaves as if $input were the zero-length string. In this situation the result will be an element node with no children.

The function returns an element node whose local name is analyze-string-result. This element and all its descendant elements have the namespace URI https://www.w3.org/2005/xpath-functions. The namespace prefix is ·implementation dependent·. The children of this element are a sequence of fn:match and fn:non-match elements. This sequence is formed by breaking the $input string into a sequence of strings, returning any substring that matches $pattern as the content of a match element, and any intervening substring as the content of a non-match element.

More specifically, the function starts at the beginning of the input string and attempts to find the first substring that matches the regular expression. If there are several matches, the first match is defined to be the one whose starting position comes first in the string. If several alternatives within the regular expression both match at the same position in the input string, then the match that is chosen is the first alternative that matches. For example, if the input string is The quick brown fox jumps and the regular expression is jump|jumps, then the match that is chosen is jump.

Having found the first match, the instruction proceeds to find the second and subsequent matches by repeating the search, starting at the first character that was not included in the previous match.

The input string is thus partitioned into a sequence of substrings, some of which match the regular expression, others which do not match it. Each substring will contain at least one character. This sequence is represented in the result by the sequence of fn:match and fn:non-match children of the returned element node; the string value of the fn:match or fn:non-match element will be the corresponding substring of $input, and the string value of the returned element node will therefore be the same as $input.

The content of an fn:non-match element is always a single text node.

The content of a fn:match element, however, is in general a sequence of text nodes and fn:group element children. An fn:group element with a nr attribute having the integer value N identifies the substring captured by the Nth parenthesized sub-expression in the regular expression. For each capturing subexpression there will be at most one corresponding fn:group element in each fn:match element in the result.

If the function is called twice with the same arguments, it is ·implementation dependent· whether the two calls return the same element node or distinct (but deep equal) element nodes.

A schema is defined for the structure of the returned element, containing the definitions below. The returned element and its descendants will have type annotations obtained by validating the returned element against this schema, unless the function is used in an environment where type annotations are not supported (for example, a Basic XSLT Processor), in which case the elements will all be annotated as xs:untyped and the attributes as xs:untypedAtomic.

<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="https://www.w3.org/2001/XMLSchema"
    targetNamespace="https://www.w3.org/2005/xpath-functions"
    xmlns:fn="https://www.w3.org/2005/xpath-functions"
    elementFormDefault="qualified"> 
    <xs:element name="analyze-string-result" type="fn:analyze-string-result-type"/>
    <xs:element name="match" type="fn:match-type"/>
    <xs:element name="non-match" type="xs:string"/>
    <xs:element name="group" type="fn:group-type"/>
    
    <xs:complexType name="analyze-string-result-type" mixed="true">
        <xs:choice minOccurs="0" maxOccurs="unbounded">
            <xs:element ref="fn:match"/>
            <xs:element ref="fn:non-match"/>
        </xs:choice>
    </xs:complexType>
        
    <xs:complexType name="match-type" mixed="true">
        <xs:sequence>
            <xs:element ref="fn:group" minOccurs="0" maxOccurs="unbounded"/>
        </xs:sequence>
    </xs:complexType>
    
    <xs:complexType name="group-type" mixed="true">
        <xs:sequence>
            <xs:element ref="fn:group" minOccurs="0" maxOccurs="unbounded"/>
        </xs:sequence>
        <xs:attribute name="nr" type="xs:positiveInteger"/>
    </xs:complexType>    
 
</xs:schema>

Error Conditions

An error is raised [err:FORX0002] if the value of $pattern is invalid according to the rules described in section 5.6.1 Regular Expression Syntax.

An error is raised [err:FORX0001] if the value of $flags is invalid according to the rules described in section 5.6.1 Regular Expression Syntax.

If the supplied $pattern matches a zero-length string, that is, if fn:matches("", $pattern, $flags) returns true, then an error is raised: [err:FORX0003].

Examples

In the following examples, the result document is shown in serialized form, with whitespace between the element nodes. This whitespace is not actually present in the result.

The expression fn:analyze-string("The cat sat on the mat.", "\w+") returns <analyze-string-result xmlns="https://www.w3.org/2005/xpath-functions"> <match>The</match> <non-match> </non-match> <match>cat</match> <non-match> </non-match> <match>sat</match> <non-match> </non-match> <match>on</match> <non-match> </non-match> <match>the</match> <non-match> </non-match> <match>mat</match> <non-match>.</non-match> </analyze-string-result>.

The expression fn:analyze-string("2008-12-03", "^(\d+)\-(\d+)\-(\d+)$") returns <analyze-string-result xmlns="https://www.w3.org/2005/xpath-functions"> <match><group nr="1">2008</group>-<group nr="2">12</group>-<group nr="3">03</group></match> </analyze-string-result>.

The expression fn:analyze-string("A1,C15,,D24, X50,", "([A-Z])([0-9]+)") returns <analyze-string-result xmlns="https://www.w3.org/2005/xpath-functions"> <match><group nr="1">A</group><group nr="2">1</group></match> <non-match>,</non-match> <match><group nr="1">C</group><group nr="2">15</group></match> <non-match>,,</non-match> <match><group nr="1">D</group><group nr="2">24</group></match> <non-match>, </non-match> <match><group nr="1">X</group><group nr="2">50</group></match> <non-match>,</non-match> </analyze-string-result>.