XQuery 1.0 and XPath 2.0 Functions and Operators

1.3.1 xdt:anyAtomicType

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

1.3.2 xdt:untypedAtomic

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

1.4.1 Examples

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

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

6.2.1 op:numeric-add

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

6.2.2 op:numeric-subtract

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

6.2.3 op:numeric-multiply

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

6.2.4 op:numeric-divide

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

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

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

6.2.5 op:numeric-integer-divide

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

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

6.2.6 op:numeric-mod

Backs up the "mod" operator. Informally, this function returns the remainder resulting from dividing $operand1, the dividend, by $operand2, the divisor. The operation a mod b for operands that are xs:integer or xs:decimal, or types derived from them, produces a result such that (a/b)*b+(a mod b) is equal to a and the magnitude of the result is always less than the magnitude of the divisor. This identity holds even in the special case that the dividend is the negative integer of largest possible magnitude for its type and the divisor is -1 (the remainder is 0). It follows from this rule that the sign of the result is the sign of the dividend. If $operand2 is 0, then an error is raised ("Division by zero").

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

• If either operand is NaN, the result is NaN.

• If the dividend is positive or negative infinity, or the divisor is positive or negative zero (0), or both, the result is NaN.

• If the dividend is finite and the divisor is an infinity, the result equals the dividend.

• If the dividend is positive or negative zero and the divisor is finite, the result is the same as the dividend.

• In the remaining cases, where neither positive or negative infinity, nor positive or negative zero, nor NaN is involved, the result obeys (a/b)*b+(a mod b) = a. Division is truncating division, analogous to integer division, not [IEEE 754-1985] rounding division.

6.2.7 op:numeric-unary-plus

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

6.2.8 op:numeric-unary-minus

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

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

6.3.1 op:numeric-equal

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

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

6.3.2 op:numeric-less-than

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

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

6.3.3 op:numeric-greater-than

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

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

6.4.1 fn:floor

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

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

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

6.4.2 fn:ceiling

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

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

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

6.4.3 fn:round

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

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

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

6.4.4 fn:round-half-to-even

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

Returns a value of the same type as $srcval.

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

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

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

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

7.2.1 fn:codepoints-to-string

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

7.2.2 fn:string-to-codepoints

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

7.3.1 fn:compare

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

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

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

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

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

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

7.4.1 fn:concat

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

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

7.4.2 fn:string-join

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

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

7.4.3 fn:starts-with

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

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

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

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

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

7.4.4 fn:ends-with

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

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

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

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

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

7.4.5 fn:contains

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

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

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

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

7.4.6 fn:substring

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

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

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

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

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

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

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

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

7.4.7 fn:string-length

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

7.4.8 fn:substring-before

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

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

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

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

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

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

7.4.9 fn:substring-after

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

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

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

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

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

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

7.4.10 fn:normalize-space

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

7.4.11 fn:normalize-unicode

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

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

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

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

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

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

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

• If the effective value of $normalizationForm is "W3C", then the value returned by the function is the value of $srcval is the fully normalized form. See [Character Model for the World Wide Web 1.0].

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

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

7.4.12 fn:upper-case

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

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

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

7.4.13 fn:lower-case

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

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

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

7.4.14 fn:translate

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

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

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

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

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

7.4.15 fn:string-pad

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

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

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

7.4.16 fn:escape-uri

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

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

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

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

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

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

7.5.1 Regular Expression Syntax

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

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

• Two modes are defined, string mode and multiline mode.

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

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

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

  is modified to read:

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

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

• In string mode, the metacharacter . matches any character whatsoever. In multiline mode, the metacharacter . matches any character except a newline (#x0A) character.

• Reluctant quantifiers are supported. Specifically:

  • X?? matches X, once or not at all

  • X*? matches X, zero or more times

  • X+? matches X, one or more times

  • X{n}? matches X, exactly n times

  • X(n,}? matches X, at least n times

  • X{n,m}? matches X, at least n times, but not more than m times

  The effect of these quantifiers is that the regular expression matches the shortest possible substring consistent with the match as a whole succeeding. In the absence of these quantifiers, the regular expression matches the longest possible substring.

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

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

  is changed to:

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

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

7.5.2 fn:matches

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

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

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

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

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

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

<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.5.3 fn:replace

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.

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

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

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

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

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

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

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

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

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

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

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

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

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

7.5.4 fn:tokenize

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.

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

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

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

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

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

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

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

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

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

8.1.1 fn:true

Returns the xs:boolean value true.

8.1.2 fn:false

Returns the xs:boolean value false.

8.2.1 op:boolean-equal

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

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

8.2.2 op:boolean-less-than

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

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

8.2.3 op:boolean-greater-than

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

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

8.3.1 fn:not

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

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

9.1.1 CONFORMANCE NOTE

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

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

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

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

9.2.1 xdt:yearMonthDuration

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

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

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

9.2.2 xdt:dayTimeDuration

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

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

9.3.1 op:yearMonthDuration-equal

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

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

9.3.2 op:yearMonthDuration-less-than

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

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

9.3.3 op:yearMonthDuration-greater-than

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

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

9.3.4 op:dayTimeDuration-equal

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

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

9.3.5 op:dayTimeDuration-less-than

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

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

9.3.6 op:dayTimeDuration-greater-than

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

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

9.3.7 op:dateTime-equal

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

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

9.3.8 op:dateTime-less-than

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

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

9.3.9 op:dateTime-greater-than

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

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

9.3.10 op:date-equal

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

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

9.3.11 op:date-less-than

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

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

9.3.12 op:date-greater-than

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

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

9.3.13 op:time-equal

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

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

9.3.14 op:time-less-than

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

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

9.3.15 op:time-greater-than

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

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

9.3.16 op:gYearMonth-equal

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

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

9.3.17 op:gYear-equal

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

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

9.3.18 op:gMonthDay-equal

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

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

9.3.19 op:gMonth-equal

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

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

9.3.20 op:gDay-equal

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

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

9.4.1 fn:get-years-from-yearMonthDuration

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

9.4.2 fn:get-months-from-yearMonthDuration

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

9.4.3 fn:get-days-from-dayTimeDuration

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

9.4.4 fn:get-hours-from-dayTimeDuration

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

9.4.5 fn:get-minutes-from-dayTimeDuration

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

9.4.6 fn:get-seconds-from-dayTimeDuration

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

9.4.7 fn:get-year-from-dateTime

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

9.4.8 fn:get-month-from-dateTime

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

9.4.9 fn:get-day-from-dateTime

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

9.4.10 fn:get-hours-from-dateTime

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

9.4.11 fn:get-minutes-from-dateTime

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

9.4.12 fn:get-seconds-from-dateTime

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

9.4.13 fn:get-timezone-from-dateTime

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

9.4.14 fn:get-year-from-date

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

9.4.15 fn:get-month-from-date

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

9.4.16 fn:get-day-from-date

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

9.4.17 fn:get-timezone-from-date

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

9.4.18 fn:get-hours-from-time

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

9.4.19 fn:get-minutes-from-time

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

9.4.20 fn:get-seconds-from-time

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

9.4.21 fn:get-timezone-from-time

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

9.5.1 op:add-yearMonthDurations

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

9.5.2 op:subtract-yearMonthDurations

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

9.5.3 op:multiply-yearMonthDuration

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

Backs up the "*" operator on xdt:yearMonthDuration values.

9.5.4 op:divide-yearMonthDuration

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

Backs up the "div" operator on xdt:yearMonthDuration values.

9.5.5 op:add-dayTimeDurations

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

9.5.6 op:subtract-dayTimeDurations

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

9.5.7 op:multiply-dayTimeDuration

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

9.5.8 op:divide-dayTimeDuration

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

9.6.1 fn:adjust-dateTime-to-timezone

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

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

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

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

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

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

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

If $srcval has a timezone component and $timezone is not the empty sequence, then the result is an xs:dateTime value with a timezone component of $timezone that is equal to $srcval.

9.6.2 fn:adjust-date-to-timezone

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

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

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

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

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

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

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

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

9.6.3 fn:adjust-time-to-timezone

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

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

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

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

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

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

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

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

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

• Let $r be the result of evaluating

  fn:adjust-dateTime-to-timezone($srcdt, $timezone)

• The result of this function will be a time value that has time and timezone components that are the same as the time and timezone components of $r.

9.7.1 fn:subtract-dateTimes-yielding-yearMonthDuration

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

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

9.7.2 fn:subtract-dateTimes-yielding-dayTimeDuration

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

9.7.3 op:subtract-dates

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

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

9.7.4 op:subtract-times

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

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

9.7.5 op:add-yearMonthDuration-to-dateTime

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

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

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

9.7.6 op:add-dayTimeDuration-to-dateTime

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

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

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

9.7.7 op:subtract-yearMonthDuration-from-dateTime

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

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

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

9.7.8 op:subtract-dayTimeDuration-from-dateTime

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

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

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

9.7.9 op:add-yearMonthDuration-to-date

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

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

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

9.7.10 op:add-dayTimeDuration-to-date

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

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

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

9.7.11 op:subtract-yearMonthDuration-from-date

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

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

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

9.7.12 op:subtract-dayTimeDuration-from-date

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

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

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

9.7.13 op:add-dayTimeDuration-to-time

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

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

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

9.7.14 op:subtract-dayTimeDuration-from-time

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

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

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

10.1.1 fn:resolve-QName

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

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

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

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

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

10.1.2 fn:expanded-QName

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

10.2.1 op:QName-equal

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

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

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

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

10.2.3 fn:get-namespace-from-QName

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

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

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

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

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

10.2.5 fn:get-in-scope-namespaces

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

11.2.1 Examples

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