XQuery 1.0 and XPath 2.0 Functions and Operators (Second Edition)

5.2.1 Examples

• fn:dateTime(xs:date("1999-12-31"), xs:time("12:00:00")) returns xs:dateTime("1999-12-31T12:00:00").

• fn:dateTime(xs:date("1999-12-31"), xs:time("24:00:00")) returns xs:dateTime("1999-12-31T00:00:00") because "24:00:00" is an alternate lexical form for "00:00:00".

6.2.1 op:numeric-add

Summary: Backs up the "+" operator and returns the arithmetic sum of its operands: ($arg1 + $arg2).

6.2.2 op:numeric-subtract

Summary: Backs up the "-" operator and returns the arithmetic difference of its operands: ($arg1 - $arg2).

6.2.3 op:numeric-multiply

Summary: Backs up the "*" operator and returns the arithmetic product of its operands: ($arg1 * $arg2).

6.2.4 op:numeric-divide

Summary: Backs up the "div" operator and returns the arithmetic quotient of its operands: ($arg1 div $arg2).

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

6.2.5 op:numeric-integer-divide

Summary: This function backs up the "idiv" operator by performing an integer division.

If $arg2 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]. If $arg2 is INF or -INF (and $arg1 is not) 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).

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.

6.2.6 op:numeric-mod

Summary: Backs up the "mod" operator. Informally, this function returns the remainder resulting from dividing $arg1, the dividend, by $arg2, the divisor. The operation a mod b for operands that are xs:integer or xs:decimal, or types derived from them, produces a result such that (a 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:integer and xs:decimal operands, if $arg2 is zero, then an error is raised [err:FOAR0001].

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.

6.2.7 op:numeric-unary-plus

Summary: Backs up the unary "+" operator and returns its operand with the sign unchanged: (+ $arg).

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.

6.2.8 op:numeric-unary-minus

Summary: Backs up the unary "-" operator and returns its operand with the sign reversed: (- $arg).

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.

6.3.1 op:numeric-equal

Summary: Returns true if and only if the value of $arg1 is equal to the value of $arg2. 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.

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

6.3.2 op:numeric-less-than

Summary: Returns true if and only if $arg1 is less than $arg2. 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.

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

6.3.3 op:numeric-greater-than

Summary: Returns true if and only if $arg1 is greater than $arg2. 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.

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

6.4.1 fn:abs

Summary: Returns the absolute value of $arg. If $arg is negative returns -$arg otherwise returns $arg. If 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

6.4.2 fn:ceiling

Summary: Returns the smallest (closest to negative infinity) number with no fractional part that is not less than the value of $arg. If 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

6.4.3 fn:floor

Summary: Returns the largest (closest to positive infinity) number with no fractional part that is not greater than the value of $arg. If 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 float and 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

6.4.4 fn:round

Summary: Returns the number with no fractional part that is closest to the argument. If there are two such numbers, then the one that is closest to positive infinity is returned. If 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 infinity, then positive infinity is returned. If the argument is negative infinity, then negative infinity is returned. 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, but greater than or equal to -0.5, then negative zero is returned. In the cases where positive zero or negative zero is returned, negative zero or positive zero may be returned as [XML Schema Part 2: Datatypes Second Edition] does not distinguish between the values positive zero and negative zero.

For the last two cases, note that the result is not the same as fn:floor(x+0.5).

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

6.4.5 fn:round-half-to-even

Summary: The value returned is 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, if the argument is NaN, positive or negative zero, or positive or negative infinity, then the result is the same as the argument. In all other cases, the argument is cast to xs:decimal, 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.

Note that the process of casting to xs:decimal may result in an error [err:FOCA0001].

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

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

7.2.1 fn:codepoints-to-string

Summary: Creates an xs:string from a sequence of [The Unicode Standard] code points. Returns the zero-length string if $arg is the empty sequence. If any of the code points in $arg is not a legal XML character, an error is raised [err:FOCH0001].

7.2.2 fn:string-to-codepoints

Summary: Returns the sequence of [The Unicode Standard] code points that constitute an xs:string. If $arg is a zero-length string or the empty sequence, the empty sequence is returned.

7.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 code point 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 code points are, in fact, equal for comparison purposes (e.g., "v" and "w" are considered equivalent in Swedish). 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. A specific collation with a distinguished name, http://www.w3.org/2005/xpath-functions/collation/codepoint, provides the ability to compare strings based on code point values. Every implementation of XQuery/XPath must support the collation based on code point values.

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 invocations 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 " http://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 " http://www.example.com/collations/French1 " and " http://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 code point collation (http://www.w3.org/2005/xpath-functions/collation/codepoint).

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

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

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

   • Otherwise, an error is raised [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].

7.3.2 fn:compare

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

The collation used by the invocation of this function is determined according to the rules in 7.3.1 Collations.

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

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

7.3.3 fn:codepoint-equal

Summary: Returns true or false depending on whether the value of $comparand1 is equal to the value of $comparand2, according to the Unicode code point collation (http://www.w3.org/2005/xpath-functions/collation/codepoint).

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

7.4.1 fn:concat

Summary: Accepts two or more xs:anyAtomicType arguments and casts them to xs:string. Returns the xs:string that is the concatenation of the values of its arguments after conversion. If any of the arguments is the empty sequence, the 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].

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

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

7.4.2 fn:string-join

Summary: Returns a xs:string created by concatenating the members of the $arg1 sequence using $arg2 as a separator. If the value of $arg2 is the zero-length string, then the members of $arg1 are concatenated without a separator.

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

7.4.3 fn:substring

Summary: Returns the portion of the value of $sourceString beginning at the position indicated by the value of $startingLoc and continuing for the number of characters indicated by the value of $length. The characters returned do not extend beyond $sourceString. If $startingLoc 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 obeys:

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

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

fn:round($startingLoc) <= $p < fn:round(INF)

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

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

7.4.4 fn:string-length

Summary: Returns an xs:integer equal to the length in characters of the value of $arg.

If the value of $arg is the empty sequence, the xs:integer 0 is returned.

If no argument is supplied, $arg defaults to the string value (calculated using fn:string()) of the context item (.). If no argument is supplied and the context item is undefined an error is raised: [err:XPDY0002]^XP.

7.4.5 fn:normalize-space

Summary: Returns the value of $arg with whitespace normalized by stripping leading and trailing whitespace and replacing sequences of one or more than one whitespace character with a single space, #x20.

The whitespace characters are defined in the metasymbol S (Production 3) of [Extensible Markup Language (XML) 1.0 Recommendation (Third Edition)].

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

If no argument is supplied, then $arg defaults to the string value (calculated using fn:string()) of the context item (.). If no argument is supplied and the context item is undefined an error is raised: [err:XPDY0002]^XP.

7.4.6 fn:normalize-unicode

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

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

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

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

• If the effective value of $normalizationForm is "NFC", then the value returned by the function is the value of $arg in Unicode Normalization Form C (NFC).

• If the effective value of $normalizationForm is "NFD", then the value returned by the function is the value of $arg in Unicode Normalization Form D (NFD).

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

• If the effective value of $normalizationForm is "NFKD", then the value returned by the function is the value of $arg in Unicode Normalization Form KD (NFKD).

• If the effective value of $normalizationForm is "FULLY-NORMALIZED", then the value returned by the function is the value of $arg in the 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", "FULLY-NORMALIZED". They ·may· also support other normalization forms with ·implementation-defined· semantics. If the effective value of the $normalizationForm is other than one of the values supported by the implementation, then an error is raised [err:FOCH0003].

7.4.7 fn:upper-case

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

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

7.4.8 fn:lower-case

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

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

7.4.9 fn:translate

Summary: Returns the value of $arg modified so that every character in the value of $arg that occurs at some position N in the value of $mapString has been replaced by the character that occurs at position N in the value of $transString.

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

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

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

If a character occurs more than once in $mapString, then the first occurrence determines the replacement character. If $transString is longer than $mapString, the excess characters are ignored.

7.4.10 fn:encode-for-uri

Summary: This function encodes reserved characters in an xs:string that is intended to be used in the path segment of a URI. It is invertible but not idempotent. This function applies the URI escaping rules defined in section 2 of [RFC 3986] to the xs:string supplied as $uri-part. The effect of the function is to escape reserved characters. Each such character in the string is replaced with its percent-encoded form as described in [RFC 3986].

If $uri-part is the empty sequence, returns the zero-length string.

All characters are escaped except those identified as "unreserved" by [RFC 3986], that is the upper- and lower-case letters A-Z, the digits 0-9, HYPHEN-MINUS ("-"), LOW LINE ("_"), FULL STOP ".", and TILDE "~".

Note that this function escapes URI delimiters and therefore cannot be used indiscriminately to encode "invalid" characters in a path segment.

Since [RFC 3986] recommends that, for consistency, URI producers and normalizers should use uppercase hexadecimal digits for all percent-encodings, this function must always generate hexadecimal values using the upper-case letters A-F.

7.4.11 fn:iri-to-uri

Summary: This function converts an xs:string containing an IRI into a URI according to the rules spelled out in Section 3.1 of [RFC 3987]. It is idempotent but not invertible.

If $iri contains a character that is invalid in an IRI, such as the space character (see note below), the invalid character is replaced by its percent-encoded form as described in [RFC 3986] before the conversion is performed.

If $iri is the empty sequence, returns the zero-length string.

Since [RFC 3986] recommends that, for consistency, URI producers and normalizers should use uppercase hexadecimal digits for all percent-encodings, this function must always generate hexadecimal values using the upper-case letters A-F.

7.4.12 fn:escape-html-uri

Summary: This function escapes all characters except printable characters of the US-ASCII coded character set, specifically the octets ranging from 32 to 126 (decimal). The effect of the function is to escape a URI in the manner html user agents handle attribute values that expect URIs. Each character in $uri to be escaped is replaced by an escape sequence, which is formed by encoding the character as a sequence of octets in UTF-8, and then representing each of these octets in the form %HH, where HH is the hexadecimal representation of the octet. This function must always generate hexadecimal values using the upper-case letters A-F.

If $uri is the empty sequence, returns the zero-length string.

7.5.1 fn:contains

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

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 the invocation of this function is determined according to the rules in 7.3.1 Collations. If the specified collation does not support collation units an error ·may· be raised [err:FOCH0004].

7.5.2 fn:starts-with

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

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 the invocation of this function is determined according to the rules in 7.3.1 Collations. If the specified collation does not support collation units an error ·may· be raised [err:FOCH0004].

7.5.3 fn:ends-with

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

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 the invocation of this function is determined according to the rules in 7.3.1 Collations. If the specified collation does not support collation units an error ·may· be raised [err:FOCH0004].

7.5.4 fn:substring-before

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

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 the invocation of this function is determined according to the rules in 7.3.1 Collations If the specified collation does not support collation units an error ·may· be raised [err:FOCH0004].

7.5.5 fn:substring-after

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

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 the invocation of this function is determined according to the rules in 7.3.1 Collations If the specified collation does not support collation units an error ·may· be raised [err:FOCH0004].

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

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

7.6.2 fn:matches

Summary: The function returns true if $input matches the regular expression supplied as $pattern as influenced by the value of $flags, if present; otherwise, it returns false.

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 7.6.1.1 Flags.

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

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

An error is raised [err:FORX0002] if the value of $pattern is invalid according to the rules described in section 7.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 7.6.1 Regular Expression Syntax.

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

7.6.3 fn:replace

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

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

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

Within the $replacement string, 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".

A literal "$" symbol must be written as "\$".

A literal "\" symbol 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"

An error is raised [err:FORX0002] if the value of $pattern is invalid according to the rules described in section 7.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 7.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.

7.6.4 fn:tokenize

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

The 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 7.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 result is the empty sequence.

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

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

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

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

An error is raised [err:FORX0002] if the value of $pattern is invalid according to the rules described in section 7.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 7.6.1 Regular Expression Syntax.

9.1.1 fn:true

Summary: Returns the xs:boolean value true. Equivalent to xs:boolean("1").

9.1.2 fn:false

Summary: Returns the xs:boolean value false. Equivalent to xs:boolean("0").

9.2.1 op:boolean-equal

Summary: Returns true if both arguments are true or if both arguments are false. Returns false if one of the arguments is true and the other argument is false.

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

9.2.2 op:boolean-less-than

Summary: Returns true if $arg1 is false and $arg2 is true. Otherwise, returns false.

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

9.2.3 op:boolean-greater-than

Summary: Returns true if $arg1 is true and $arg2 is false. Otherwise, returns false.

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

9.3.1 fn:not

Summary: $arg is first reduced to an effective boolean value by applying the fn:boolean() function. Returns true if the effective boolean value is false, and false if the effective boolean value is true.

10.1.1 Limits and Precision

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

All minimally conforming processors ·must· support positive year values with a minimum of 4 digits (i.e., YYYY) and a minimum fractional second precision of 1 millisecond or three digits (i.e., s.sss). However, conforming processors ·may· set larger ·implementation-defined· limits on the maximum number of digits they support in these two situations. Processors ·may· also choose to support the year 0000 and years with negative values. The results of operations on dates that cross the year 0000 are ·implementation-defined·.

A processor that limits the number of digits in date and time datatype representations may encounter overflow and underflow conditions when it tries to execute the functions in 10.8 Arithmetic Operators on Durations, Dates and Times. In these situations, the processor ·must· return P0M or PT0S in case of duration underflow and 00:00:00 in case of time underflow. It ·must· raise an error [err:FODT0001] in case of overflow.

The value spaces of the two totally ordered subtypes of xs:duration described in 10.3 Two Totally Ordered Subtypes of Duration are xs:integer months for xs:yearMonthDuration and xs:decimal seconds for xs:dayTimeDuration. If a processor limits the number of digits allowed in the representation of xs:integer and xs:decimal then overflow and underflow situations can arise when it tries to execute the functions in 10.6 Arithmetic Operators on Durations. In these situations the processor ·must· return zero in case of numeric underflow and P0M or PT0S in case of duration underflow. It ·must· raise an error [err:FODT0002] in case of overflow.

10.2.1 Examples

• An xs:dateTime with lexical representation 1999-05-31T05:00:00 is represented in the datamodel by {1999, 5, 31, 5, 0, 0.0, ()}.

• An xs:dateTime with lexical representation 1999-05-31T13:20:00-05:00 is represented by {1999, 5, 31, 13, 20, 0.0, -PT5H}.

• An xs:dateTime with lexical representation 1999-12-31T24:00:00 is represented by {2000, 1, 1, 0, 0, 0.0, ()}.

• An xs:date with lexical representation 2005-02-28+8:00 is represented by {2005, 2, 28, (), (), (), PT8H}.

• An xs:time with lexical representation 24:00:00 is represented by {(), (), (), 0, 0, 0, ()}.

10.3.1 xs:yearMonthDuration

[Definition] xs:yearMonthDuration is derived from xs:duration by restricting its lexical representation to contain only the year and month components. The value space of xs:yearMonthDuration is the set of xs:integer month values. The year and month components of xs:yearMonthDuration correspond to the Gregorian year and month components defined in section 5.5.3.2 of [ISO 8601], respectively.

10.3.2 xs:dayTimeDuration

[Definition] xs:dayTimeDuration is derived from xs:duration by restricting its lexical representation to contain only the days, hours, minutes and seconds components. The value space of xs:dayTimeDuration is the set of fractional second values. The components of xs:dayTimeDuration correspond to the day, hour, minute and second components defined in Section 5.5.3.2 of [ISO 8601], respectively.

10.4.1 op:yearMonthDuration-less-than

Summary: Returns true if and only if $arg1 is less than $arg2. Returns false otherwise.

This function backs up the "lt" and "le" operators on xs:yearMonthDuration values.

10.4.2 op:yearMonthDuration-greater-than

Summary: Returns true if and only if $arg1 is greater than $arg2. Returns false otherwise.

This function backs up the "gt" and "ge" operators on xs:yearMonthDuration values.

10.4.3 op:dayTimeDuration-less-than

Summary: Returns true if and only if $arg1 is less than $arg2. Returns false otherwise.

This function backs up the "lt" and "le" operators on xs:dayTimeDuration values.

10.4.4 op:dayTimeDuration-greater-than

Summary: Returns true if and only if $arg1 is greater than $arg2. Returns false otherwise.

This function backs up the "gt" and "ge" operators on xs:dayTimeDuration values.

10.4.5 op:duration-equal

Summary: Returns true if and only if the xs:yearMonthDuration and the xs:dayTimeDuration components of $arg1 and $arg2 compare equal respectively. Returns false otherwise.

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

Note that this function, like any other, may be applied to arguments that are derived from the types given in the function signature, including the two subtypes xs:dayTimeDuration and xs:yearMonthDuration. With the exception of the zero-length duration, no instance of xs:dayTimeDuration can ever be equal to an instance of xs:yearMonthDuration.

The semantics of this function are:

xs:yearMonthDuration($arg1) div xs:yearMonthDuration('P1M')  eq
xs:yearMonthDuration($arg2) div xs:yearMonthDuration('P1M')
    and
xs:dayTimeDuration($arg1) div xs:dayTimeDuration('PT1S')  eq
xs:dayTimeDuration($arg2) div xs:dayTimeDuration('PT1S')

that is, the function returns true if the months and seconds values of the two durations are equal.

10.4.6 op:dateTime-equal

Summary: Returns true if and only if the value of $arg1 is equal to the value of $arg2 according to the algorithm defined in section 3.2.7.4 of [XML Schema Part 2: Datatypes Second Edition] "Order relation on dateTime" for xs:dateTime values with timezones. Returns false otherwise.

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

10.4.7 op:dateTime-less-than

Summary: Returns true if and only if the value of $arg1 is less than the value of $arg2 according to the algorithm defined in section 3.2.7.4 of [XML Schema Part 2: Datatypes Second Edition] "Order relation on dateTime" for xs:dateTime values with timezones. Returns false otherwise.

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

10.4.8 op:dateTime-greater-than

Summary: Returns true if and only if the value of $arg1 is greater than the value of $arg2 according to the algorithm defined in section 3.2.7.4 of [XML Schema Part 2: Datatypes Second Edition] "Order relation on dateTime" for xs:dateTime values with timezones. Returns false otherwise.

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

10.4.9 op:date-equal

Summary: Returns true if and only if the starting instant of $arg1 is equal to starting instant of $arg2. Returns false otherwise.

The starting instant of an xs:date is the xs:dateTime at time 00:00:00 on that date.

The two starting instants are compared using op:dateTime-equal.

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

10.4.10 op:date-less-than

Summary: Returns true if and only if the starting instant of $arg1 is less than the starting instant of $arg2. Returns false otherwise.

The starting instant of an xs:date is the xs:dateTime at time 00:00:00 on that date.

The two starting instants are compared using op:dateTime-less-than.

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

10.4.11 op:date-greater-than

Summary: Returns true if and only if the starting instant of $arg1 is greater than the starting instant of $arg2. Returns false otherwise.

The starting instant of an xs:date is the xs:dateTime at time 00:00:00 on that date.

The two starting instants are compared using op:dateTime-greater-than.

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

10.4.12 op:time-equal

Summary: Returns true if and only if the value of $arg1 converted to an xs:dateTime using the date components from the reference xs:dateTime is equal to the value of $arg2 converted to an xs:dateTime using the date components from the same reference xs:dateTime. Returns false otherwise.

The two xs:dateTime values are compared using op:dateTime-equal.

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

10.4.13 op:time-less-than

Summary: Returns true if and only if the value of $arg1 converted to an xs:dateTime using the date components from the reference xs:dateTime is less than the normalized value of $arg2 converted to an xs:dateTime using the date components from the same reference xs:dateTime. Returns false otherwise.

The two xs:dateTime values are compared using op:dateTime-less-than.

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

10.4.14 op:time-greater-than

Summary: Returns true if and only if the value of $arg1 converted to an xs:dateTime using the date components from the reference xs:dateTime is greater than the value of $arg2 converted to an xs:dateTime using the date components from the same reference xs:dateTime. Returns false otherwise.

The two xs:dateTime values are compared using op:dateTime-greater-than.

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

10.4.15 op:gYearMonth-equal

Summary: Returns true if and only if the xs:dateTimes representing the starting instants of $arg1 and $arg2 compare equal. The starting instants of $arg1 and $arg2 are calculated by adding the missing components of $arg1 and $arg2 from the xs:dateTime template xxxx-xx-ddT00:00:00 where dd represents the last day of the month component in $arg1 or $arg2. Returns false otherwise.

The two xs:dateTime values representing the starting instants of $arg1 and $arg2 are compared using op:dateTime-equal.

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

10.4.16 op:gYear-equal

Summary: Returns true if and only if the xs:dateTimes representing the starting instants of $arg1 and $arg2 compare equal. The starting instants of $arg1 and $arg2 are calculated by adding the missing components of $arg1 and $arg2 from a xs:dateTime template such as xxxx-01-01T00:00:00. Returns false otherwise.

The two xs:dateTime values representing the starting instants of $arg1 and $arg2 are compared using op:dateTime-equal.

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

10.4.17 op:gMonthDay-equal

Summary: Returns true if and only if the xs:dateTimes representing the starting instants of equivalent occurrences of $arg1 and $arg2 compare equal. The starting instants of equivalent occurrences of $arg1 and $arg2 are calculated by adding the missing components of $arg1 and $arg2 from an xs:dateTime template such as 1972-xx-xxT00:00:00. Returns false otherwise.

The two xs:dateTime values representing the starting instants of equivalent occurrences of $arg1 and $arg2 are compared using op:dateTime-equal.

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

10.4.18 op:gMonth-equal

Summary: Returns true if and only if the xs:dateTimes representing the starting instants of equivalent occurrences of $arg1 and $arg2 compare equal. The starting instants of equivalent occurrences of $arg1 and $arg2 are calculated by adding the missing components of $arg1 and $arg2 from an xs:dateTime template such as 1972-xx-ddT00:00:00 where dd represents the last day of the month component in $arg1 or $arg2. Returns false otherwise.

The two xs:dateTime values representing the starting instants of equivalent occurrences of $arg1 and $arg2 are compared using op:dateTime-equal.

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

10.4.19 op:gDay-equal

Summary: Returns true if and only if the xs:dateTimes representing the starting instants of equivalent occurrences of $arg1 and $arg2 compare equal. The starting instants of equivalent occurrences of $arg1 and $arg2 are calculated by adding the missing components of $arg1 and $arg2 from an xs:dateTime template such as 1972-12-xxT00:00:00. Returns false otherwise.

The two xs:dateTime values representing the starting instants of equivalent occurrences of $arg1 and $arg2 are compared using op:dateTime-equal.

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

10.5.1 fn:years-from-duration

Summary: Returns an xs:integer representing the years component in the value of $arg. The result is obtained by casting $arg to an xs:yearMonthDuration (see 17.1.4 Casting to duration types) and then computing the years component as described in 10.3.1.3 Canonical representation.

The result may be negative.

If $arg is an xs:dayTimeDuration returns 0.

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

10.5.2 fn:months-from-duration

Summary: Returns an xs:integer representing the months component in the value of $arg. The result is obtained by casting $arg to an xs:yearMonthDuration (see 17.1.4 Casting to duration types) and then computing the months component as described in 10.3.1.3 Canonical representation.

The result may be negative.

If $arg is an xs:dayTimeDuration returns 0.

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

10.5.3 fn:days-from-duration

Summary: Returns an xs:integer representing the days component in the value of $arg. The result is obtained by casting $arg to an xs:dayTimeDuration (see 17.1.4 Casting to duration types) and then computing the days component as described in 10.3.2.3 Canonical representation.

The result may be negative.

If $arg is an xs:yearMonthDuration returns 0.

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

10.5.4 fn:hours-from-duration

Summary: Returns an xs:integer representing the hours component in the value of $arg. The result is obtained by casting $arg to an xs:dayTimeDuration (see 17.1.4 Casting to duration types) and then computing the hours component as described in 10.3.2.3 Canonical representation.

The result may be negative.

If $arg is an xs:yearMonthDuration returns 0.

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

10.5.5 fn:minutes-from-duration

Summary: Returns an xs:integer representing the minutes component in the value of $arg. The result is obtained by casting $arg to an xs:dayTimeDuration (see 17.1.4 Casting to duration types) and then computing the minutes component as described in 10.3.2.3 Canonical representation.

The result may be negative.

If $arg is an xs:yearMonthDuration returns 0.

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

10.5.6 fn:seconds-from-duration

Summary: Returns an xs:decimal representing the seconds component in the value of $arg. The result is obtained by casting $arg to an xs:dayTimeDuration (see 17.1.4 Casting to duration types) and then computing the seconds component as described in 10.3.2.3 Canonical representation.

The result may be negative.

If $arg is an xs:yearMonthDuration returns 0.

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

10.5.7 fn:year-from-dateTime

Summary: Returns an xs:integer representing the year component in the localized value of $arg. The result may be negative.

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

10.5.8 fn:month-from-dateTime

Summary: Returns an xs:integer between 1 and 12, both inclusive, representing the month component in the localized value of $arg.

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

10.5.9 fn:day-from-dateTime

Summary: Returns an xs:integer between 1 and 31, both inclusive, representing the day component in the localized value of $arg.

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

10.5.10 fn:hours-from-dateTime

Summary: Returns an xs:integer between 0 and 23, both inclusive, representing the hours component in the localized value of $arg.

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

10.5.11 fn:minutes-from-dateTime

Summary: Returns an xs:integer value between 0 and 59, both inclusive, representing the minute component in the localized value of $arg.

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

10.5.12 fn:seconds-from-dateTime