Returns the name of a node, as an xs:QName.
If the argument is omitted, it defaults to the context item (.). The
behavior of the function if the argument is omitted is exactly the same as if the
context item had been passed as the argument.
If $arg is the empty sequence, the empty sequence is returned.
Otherwise, the function returns the result of the dm:node-name accessor as
defined in
The following errors may be raised when $arg is omitted:
If the context item is
If the context item is not a node, type error
For element and attribute nodes, the name of the node is returned as an
xs:QName, retaining the prefix, namespace URI, and local part.
For processing instructions, the name of the node is returned as an
xs:QName in which the prefix and namespace URI are
For a namespace node, the function returns an empty sequence if the node represents the
default namespace; otherwise it returns an xs:QName in which prefix and
namespace URI are
For all other kinds of node, the function returns the empty sequence.
Returns true for an element that is
If the argument is omitted, it defaults to the context item (.). The
behavior of the function if the argument is omitted is exactly the same as if the
context item had been passed as the argument.
If $arg is the empty sequence, the function returns the empty sequence.
Otherwise the function returns the result of the dm:nilled accessor as
defined in
The following errors may be raised when $arg is omitted:
If the context item is
If the context item is not a node, type error
If $arg is not an element node, the function returns the empty
sequence.
If $arg is an untyped element node, the function returns false.
In practice, the function returns true only for an element node that has
the attribute xsi:nil="true" and that is successfully validated against a
schema that defines the element to be nillable; the detailed rules, however, are defined
in
Returns the value of $arg represented as an xs:string.
In the zero-argument version of the function, $arg defaults to the context
item. That is, calling fn:string() is equivalent to calling
fn:string(.).
If $arg is the empty sequence, the function returns the zero-length
string.
If $arg is a node, the function returns the string value of the node, as obtained using the
dm:string-value accessor defined in
If $arg is an atomic value, the function returns the result of the expression $arg cast
as xs:string (see
In all other cases, a dynamic error occurs (see below).
A dynamic error is raised
A type error is raised $arg is a function item (this includes maps and arrays).
Every node has a string value, even an element with element-only content (which has no typed value). Moreover, casting an atomic value to a string always succeeds. Functions, maps, and arrays have no string value, so these are the only arguments that satisfy the type signature but cause failure.
Returns the result of atomizing a sequence. This process flattens arrays, and replaces nodes by their typed values.
If the argument is omitted, it defaults to the context item (.). The
behavior of the function if the argument is omitted is exactly the same as if the
context item had been passed as the argument.
The result of fn:data is the sequence of atomic values produced by
applying the following rules to each item in $arg:
If the item is an atomic value, it is appended to the result sequence.
If the item is a node, the typed value of the node is appended to the result
sequence. The typed value is a sequence of zero or more atomic values:
specifically, the result of the dm:typed-value accessor as defined in
If the item is an array, the result of applying fn:data to
each member of the array, in order, is appended to the result sequence.
A type error is raised $arg is a node that does not have a typed value.
A type error is raised $arg is a function item
A dynamic error is raised if $arg is omitted and the context item is
The process of applying the fn:data function to a sequence is referred to
as atomization. In many cases an explicit call on fn:data is
not required, because atomization is invoked implicitly when a node or sequence of nodes
is supplied in a context where an atomic value or sequence of atomic values is
required.
The result of atomizing an empty sequence is an empty sequence.
The result of atomizing an empty array is an empty sequence.
Returns the base URI of a node.
The zero-argument version of the function returns the base URI of the context node: it
is equivalent to calling fn:base-uri(.).
The single-argument version of the function behaves as follows:
$arg is the empty sequence, the function returns the empty
sequence.dm:base-uri accessor
applied to the node $arg. This accessor is defined, for each kind of
node, in the XDM specification (See See also fn:static-base-uri.
The following errors may be raised when $arg is omitted:
If the context item is
If the context item is not a node, type error
Returns the URI of a resource where a document can be found, if available.
If the argument is omitted, it defaults to the context item (.). The
behavior of the function if the argument is omitted is exactly the same as if the
context item had been passed as the argument.
If $arg is the empty sequence, the function returns the empty sequence.
If $arg is not a document node, the function returns the empty
sequence.
Otherwise, the function returns the value of the document-uri accessor
applied to $arg, as defined in
The following errors may be raised when $arg is omitted:
If the context item is
If the context item is not a node, type error
In the case of a document node $D returned by the fn:doc
function, or a document node at the root of a tree containing a node returned by the
fn:collection function, it will always be true that either
fn:document-uri($D) returns the empty sequence, or that the following
expression is true: fn:doc(fn:document-uri($D)) is $D. It is
Calling the fn:error function raises an application-defined error.
This function never returns a value. Instead it always raises an error. The effect of the error is identical to the effect of dynamic errors raised implicitly, for example when an incorrect argument is supplied to a function.
The parameters to the fn:error function supply information that is
associated with the error condition and that is made available to a caller that asks for
information about the error. The error may be caught either by the host language (using
a try/catch construct in XSLT or XQuery, for example), or by the calling application or
external processing environment. The way in which error information is returned to the
external processing environment is
There are three pieces of information that may be associated with an error:
The $code is an error code that distinguishes this error from others.
It is an xs:QName; the namespace URI conventionally identifies the
component, subsystem, or authority responsible for defining the meaning of the
error code, while the local part identifies the specific error condition. The
namespace URI http://www.w3.org/2005/xqt-errors is used for errors
defined in this specification; other namespace URIs may be used for errors defined
by the application.
If the external processing environment expects the error code to be returned as a
URI or a string rather than as an xs:QName, then an error code with
namespace URI NS and local part LP will be returned in
the form NS#LP. The namespace URI part of the error code should
therefore not include a fragment identifier.
If no value is supplied for the $code argument (that is,
if the function is called with no arguments or if the first argument is an empty sequence),
the effective value of the error code is fn:QName('http://www.w3.org/2005/xqt-errors', 'err:FOER0000').
The $description is a natural-language description of the error
condition.
If no value is supplied for the $description
argument (that is, if the function is called with less than two arguments), then the
effective value of the description is
The $error-object is an arbitrary value used to convey additional
information about the error, and may be used in any way the application
chooses.
If no value is supplied for the $error-object
argument (that is, if the function is called with less than three arguments), then the
effective value of the error object is
This function always raises a dynamic error. By default, it raises
The value of the $description parameter may need to be localized.
The type none
is a special type defined in
Any QName may be used as an error code; there are no reserved names or namespaces. The error is always classified as a dynamic error, even if the error code used is one that is normally used for static errors or type errors.
http://www.w3.org/2005/xqt-errors#FOER0000 (or the corresponding
xs:QName) to the external processing environment, unless the error
is caught using a try/catch construct in the host language.http://www.example.com/HR#toohighsal and the
xs:string
"Does not apply because salary is too high" (or the corresponding
xs:QName) to the external processing environment, unless the error
is caught using a try/catch construct in the host language.Provides an execution trace intended to be used in debugging queries.
The function returns the value of $value, unchanged.
In addition, the values of $value, converted to an xs:string,
and $label fn:trace function is
Sometimes there is a need to output trace information unrelated to a specific value.
In such cases it can be useful to set $value to an empty string or an empty
sequence, and to compute the value of the $label argument:
fn:trace((), "Processing item " || $i).
Consider a situation in which a user wants to investigate the actual value passed to
a function. Assume that in a particular execution, $v is an
xs:decimal with value 124.84. Writing fn:trace($v,
'the value of $v is:') will put the strings "124.84" and
"the value of $v is:" in the trace data set in implementation
dependent order.
Returns the arithmetic sum of its operands: ($arg1 + $arg2).
General rules: see
For xs:float or xs:double values, if one of the operands is a
zero or a finite number and the other is INF or -INF,
INF or -INF is returned. If both operands are
INF, INF is returned. If both operands are
-INF, -INF is returned. If one of the operands is
INF and the other is -INF, NaN is
returned.
Returns the arithmetic difference of its operands: ($arg1 - $arg2).
General rules: see
For xs:float or xs:double values, if one of the operands is a
zero or a finite number and the other is INF or -INF, an
infinity of the appropriate sign is returned. If both operands are INF or
-INF, NaN is returned. If one of the operands is
INF and the other is -INF, an infinity of the appropriate
sign is returned.
Returns the arithmetic product of its operands: ($arg1 * $arg2).
General rules: see
For xs:float or xs:double values, if one of the operands is a
zero and the other is an infinity, NaN is returned. If one of the operands
is a non-zero number and the other is an infinity, an infinity with the appropriate sign
is returned.
Returns the arithmetic quotient of its operands: ($arg1 div $arg2).
General rules: see
As a special case, if the types of both $arg1 and $arg2 are
xs:integer, then the return type is xs:decimal.
A dynamic error is raised xs:decimal
and xs:integer operands, if the divisor is (positive or negative) zero.
For xs:float and xs:double operands, floating point division
is performed as specified in INF. A negative number divided by positive zero
returns -INF. Division by negative zero returns -INF and
INF, respectively. Positive or negative zero divided by positive or
negative zero returns NaN. Also, INF or -INF
divided by INF or -INF returns NaN.
Performs an integer division.
General rules: see
If $arg2 is INF or -INF, and $arg1
is not INF or -INF, then the result is zero.
Otherwise, subject to limits of precision and overflow/underflow conditions, the result
is the largest (furthest from zero) xs:integer value $N such
that the following expression is true:
The second term in this condition ensures that the result has the correct sign.
The implementation may adopt a different algorithm provided that it is equivalent to
this formulation in all cases where xs:decimal
division.
A dynamic error is raised
A dynamic error is raised NaN or if $arg1 is INF or
-INF.
Except in situations involving errors, loss of precision, or overflow/underflow, the
result of $a idiv $b is the same as ($a div $b) cast as
xs:integer.
The semantics of this function are different from integer division as defined in programming languages such as Java and C++.
Returns the remainder resulting from dividing $arg1, the dividend, by
$arg2, the divisor.
General rules: see
The operation a mod b for operands that are xs:integer or
xs:decimal, or types derived from them, produces a result such that
(a idiv b)*b+(a mod b) is equal to a and the magnitude of
the result is always less than the magnitude of b. This identity holds even
in the special case that the dividend is the negative integer of largest possible
magnitude for its type and the divisor is -1 (the remainder is 0). It follows from this
rule that the sign of the result is the sign of the dividend.
For xs:float and xs:double operands the following rules
apply:
If either operand is NaN, the result is NaN.
If the dividend is positive or negative infinity, or the divisor is positive or
negative zero (0), or both, the result is NaN.
If the dividend is finite and the divisor is an infinity, the result equals the dividend.
If the dividend is positive or negative zero and the divisor is finite, the result is the same as the dividend.
In the remaining cases, where neither positive or negative infinity, nor positive
or negative zero, nor NaN is involved, the result obeys (a idiv
b)*b+(a mod b) = a.
Division is truncating division, analogous to integer division, not
A dynamic error is raised xs:integer
and xs:decimal operands, if $arg2 is zero.
Returns its operand with the sign unchanged: (+ $arg).
General rules: see
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.
Because function conversion rules are applied in the normal way, the unary
+ operator can be used to force conversion of an untyped node to a
number: the result of +@price is the same as xs:double(@price)
if the type of @price is xs:untypedAtomic.
Returns its operand with the sign reversed: (- $arg).
General rules: see
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.
Returns true if and only if the value of $arg1 is equal to the value of
$arg2.
General rules: see
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.
Returns true if and only if $arg1 is numerically less than
$arg2.
General rules: see
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.
Returns true if and only if $arg1 is numerically greater than
$arg2.
The function call op:numeric-greater-than($A, $B) is defined to return the
same result as op:numeric-less-than($B, $A)
Returns the absolute value of $arg.
General rules: see
If $arg is negative the function returns -$arg, otherwise it
returns $arg.
For the four types xs:float,
xs:double, xs:decimal and xs:integer, it is
guaranteed that if the type of $arg is an instance of type T then
the result will also be an instance of T. The result $arg is an instance of xs:positiveInteger then the value of
$arg
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.
Rounds $arg upwards to a whole number.
General rules: see
The function returns the smallest (closest to negative infinity) number with no
fractional part that is not less than the value of $arg.
For the four types xs:float,
xs:double, xs:decimal and xs:integer, it is
guaranteed that if the type of $arg is an instance of type T then
the result will also be an instance of T. The result $arg is an instance of xs:decimal then the result xs:integer.
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.
Rounds $arg downwards to a whole number.
General rules: see
The function returns the largest (closest to positive infinity) number with no
fractional part that is not greater than the value of $arg.
For the four types xs:float,
xs:double, xs:decimal and xs:integer, it is
guaranteed that if the type of $arg is an instance of type T then
the result will also be an instance of T. The result $arg is an instance of xs:decimal then the result xs:integer.
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.
Rounds a value to a specified number of decimal places, rounding upwards if two such values are equally near.
General rules: see
The function returns the nearest (that is, numerically closest) value to
$arg that is a multiple of ten to the power of minus
$precision. If two such values are equally near (for example, if the
fractional part in $arg is exactly .5), the function returns the one that
is closest to positive infinity.
For the four types xs:float,
xs:double, xs:decimal and xs:integer, it is
guaranteed that if the type of $arg is an instance of type T then
the result will also be an instance of T. The result $arg is an instance of xs:decimal and $precision is less than one,
then the result xs:integer.
The single-argument version of this function produces the same result as the
two-argument version with $precision=0 (that is, it rounds to a whole
number).
When $arg is of type xs:float and xs:double:
If $arg is NaN, positive or negative zero, or positive or negative
infinity, then the result is the same as the argument.
For other values, the argument is cast to xs:decimal using an
implementation of xs:decimal that imposes no limits on the number of
digits that can be represented. The function is applied to this
xs:decimal value, and the resulting xs:decimal is
cast back to xs:float or xs:double as appropriate to
form the function result. If the resulting xs:decimal value is zero,
then positive or negative zero is returned according to the sign of
$arg.
This function is typically used with a non-zero $precision in financial
applications where the argument is of type xs:decimal. For arguments of
type xs:float and xs:double the results may be
counter-intuitive. For example, consider round(35.425e0, 2). The result is
not 35.43, as might be expected, but 35.42. This is because the xs:double
written as 35.425e0 has an exact value equal to 35.42499999999..., which is closer to
35.42 than to 35.43.
-3Rounds a value to a specified number of decimal places, rounding to make the last digit even if two such values are equally near.
General rules: see
The function returns the nearest (that is, numerically closest) value to
$arg that is a multiple of ten to the power of minus
$precision. If two such values are equally near (e.g. if the fractional
part in $arg is exactly .500...), the function returns the one whose least
significant digit is even.
For the four types xs:float,
xs:double, xs:decimal and xs:integer, it is
guaranteed that if the type of $arg is an instance of type T then
the result will also be an instance of T. The result $arg is an instance of xs:decimal and $precision
is less than one, then the result xs:integer.
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 using an
implementation of xs:decimal that imposes no limits on the number of digits that
can be represented. The function is applied to this xs:decimal value,
and the resulting xs:decimal is cast back to xs:float or
xs:double as appropriate to form the function result. If the
resulting xs:decimal value is zero, then positive or negative zero is
returned according to the sign of the original argument.
This function is typically used in financial applications where the argument is of type
xs:decimal. For arguments of type xs:float and
xs:double the results may be counter-intuitive. For example, consider
round-half-to-even(xs:float(150.015), 2). The result is not 150.02 as
might be expected, but 150.01. This is because the conversion of the
xs:float value represented by the literal 150.015 to an
xs:decimal produces the xs:decimal value 150.014999389...,
which is closer to 150.01 than to 150.02.
Formats an integer according to a given picture string, using the conventions of a given natural language if specified.
If $value is an empty sequence, the function returns a zero-length
string.
In all other cases, the $picture argument describes the format in which
$value is output.
The rules that follow describe how non-negative numbers are output. If the value of
$value is negative, the rules below are applied to the absolute value of
$value, and a minus sign is prepended to the result.
The value of $picture consists of a primary format token, optionally
followed by a format modifier. The primary format token is always present and
The primary format token is classified as one of the following:
A decimal-digit-pattern made up of optional-digit-signs, mandatory-digit-signs, and grouping-separator-signs.
The optional-digit-sign is the character "#".
A mandatory-digit-sign is a 000, 001, or 999.
a grouping-separator-sign is a non-alphanumeric character, that
is a
If the primary format token contains at least one Unicode digit then it is taken
as a decimal digit pattern, and in this case it ^((\p{Nd}|#|[^\p{N}\p{L}])+?)$. If it contains a
digit but does not match this pattern, a dynamic error is raised
If a semicolon is to be used as a grouping separator, then the primary format token as a whole must be followed by another semicolon, to ensure that the grouping separator is not mistaken as a separator between the primary format token and the format modifier.
There
The corresponding output format is a decimal number, using this digit family, with
at least as many digits as there are mandatory-digit-signs in the
format token. Thus, a format token 1 generates the sequence 0 1
2 ... 10 11 12 ..., and a format token 01 (or equivalently,
00 or 99) generates the sequence 00 01 02 ...
09 10 11 12 ... 99 100 101. A format token of ١
(Arabic-Indic digit one) generates the sequence Ù¡ then Ù¢
then Ù£ ...
The grouping-separator-signs are handled as follows:
The position of grouping separators within the format token, counting backwards from the last digit, indicates the position of grouping separators to appear within the formatted number, and the character used as the grouping-separator-sign within the format token indicates the character to be used as the corresponding grouping separator in the formatted number.
More specifically, the
Grouping separators are defined to be
There is at least one grouping separator.
Every grouping separator is the same character (call it C).
There is a positive integer G (the grouping size) such that:
The position of every grouping separator is an integer multiple of G, and
Every positive integer multiple of G that is less than the number of optional-digit-signs and mandatory-digit-signs in the primary format token is the position of a grouping separator.
The
If grouping separators are regular, then the grouping separator template contains one pair of the form (n×G, C)
for every positive integer n where G is the grouping size and C is the grouping character.
Otherwise (when grouping separators are not regular), the grouping separator template contains one pair of the form
(P, C) for every grouping separator found in the primary formatting token, where C is the grouping
separator character and P is its position.
If there are no grouping separators, then the grouping separator template is an empty set.
The number is formatted as follows:
Let S/1 be the result of formatting the supplied number in decimal notation as if by casting
it to xs:string.
Let S/2 be the result of padding S/1 on the left with as many leading zeroes as are needed to ensure that it contains at least as many digits as the number of mandatory-digit-signs in the primary format token.
Let S/3 be the result of replacing all decimal digits (0-9) in S/2 with the corresponding digits from the selected digit family.
Let S/4 be the result of inserting grouping separators into S/3: for every (position P, character C) pair in the grouping separator template where P is less than the number of digits in S/3, insert character C into S/3 at position P, counting from the right-hand end.
Let S/5 be the result of converting S/4 into ordinal form, if an ordinal modifier is present, as described below.
The result of the function is then S/5.
The format token A, which generates the sequence A B C ... Z AA
AB AC....
The format token a, which generates the sequence a b c ... z aa
ab ac....
The format token i, which generates the sequence i ii iii iv v
vi vii viii ix x ....
The format token I, which generates the sequence I II III IV V
VI VII VIII IX X ....
The format token w, which generates numbers written as lower-case
words, for example in English, one two three four ...
The format token W, which generates numbers written as upper-case
words, for example in English, ONE TWO THREE FOUR ...
The format token Ww, which generates numbers written as title-case
words, for example in English, One Two Three Four ...
Any other format token, which indicates a numbering sequence in which that token
represents the number 1 (one) (but see the note below).
It is 1.
In some traditional numbering sequences additional signs are added to denote
that the letters should be interpreted as numbers; these are not included in
the format token. An example (see also the example below) is classical Greek
where a
For all format tokens other than a decimal-digit-pattern, there
① (circled
digit one, â‘ ) has a range imposed by the Unicode character repertoire — 1.
The above expansions of numbering sequences for format tokens such as a and
i are indicative but not prescriptive. There are various conventions in
use for how alphabetic sequences continue when the alphabet is exhausted, and differing
conventions for how roman numerals are written (for example, IV versus
IIII as the representation of the number 4). Sometimes alphabetic
sequences are used that omit letters such as i and o. This
specification does not prescribe the detail of any sequence other than those sequences
consisting entirely of decimal digits.
Many numbering sequences are language-sensitive. This applies especially to the sequence
selected by the tokens w, W and Ww. It also
applies to other sequences, for example different languages using the Cyrillic alphabet
use different sequences of characters, each starting with the letter #x410 (Cyrillic
capital letter A). In such cases, the $lang argument specifies which
language's conventions are to be used. If the argument is specified, the value
xml:lang attribute (see
The set of languages for which numbering is supported is $lang argument is absent, or is
set to an empty sequence, or is invalid, or is not a language supported by the
implementation, then the number is formatted using the default language from the dynamic
context.
The format modifier ^([co](\(.+\))?)?[at]?$. That is, if it is present it must
consist of one or more of the following, in order:
either c or o, optionally followed by a sequence of
characters enclosed between parentheses, to indicate cardinal or ordinal numbering
respectively, the default being cardinal numbering
either a or t, to indicate alphabetic or traditional
numbering respectively, the default being
If the o modifier is present, this indicates a request to output ordinal
numbers rather than cardinal numbers. For example, in English, when used with the format
token 1, this outputs the sequence 1st 2nd 3rd 4th ..., and
when used with the format token w outputs the sequence first second
third fourth ....
The string of characters between the parentheses, if present, is used to select between
other possible variations of cardinal or ordinal numbering sequences. The interpretation
of this string is
It is
The use of the a or t modifier disambiguates between numbering
sequences that use letters. In many languages there are two commonly used numbering
sequences that use letters. One numbering sequence assigns numeric values to letters in
alphabetic sequence, and the other assigns numeric values to each letter in some other
manner traditional in that language. In English, these would correspond to the numbering
sequences specified by the format tokens a and i. In some
languages, the first member of each sequence is the same, and so the format token alone
would be ambiguous. In the absence of the a or t modifier, the
default is
A dynamic error is raised
Note the careful distinction between conditions that are errors and conditions where fallback occurs. The principle is that an error in the syntax of the format picture will be reported by all processors, while a construct that is recognized by some implementations but not others will never result in an error, but will instead cause a fallback representation of the integer to be used.
The following notes apply when a decimal-digit-pattern is used:
If grouping-separator-signs
appear at regular intervals within the format token, then the sequence is extrapolated to
the left, so grouping separators will be used in the formatted number at every
multiple of N. For example, if the format token is 0'000
then the number one million will be formatted as 1'000'000, while the
number fifteen will be formatted as 0'015.
The only purpose of optional-digit-signs is to mark the position of
grouping-separator-signs. For example, if the format token is
#'##0 then the number one million will be formatted as
1'000'000, while the number fifteen will be formatted as
15. A grouping separator is included in the formatted number only
if there is a digit to its left, which will only be the case if either (a) the
number is large enough to require that digit, or (b) the number of
mandatory-digit-signs in the format token requires insignificant
leading zeros to be present.
Grouping separators are (365)123-9876. In general they are not
suitable for such purposes because (a) only single characters are allowed, and (b) they
cannot appear at the beginning or end of the number.
Numbers will never be truncated. Given the decimal-digit-pattern
01, the number three hundred will be output as 300,
despite the absence of any optional-digit-sign.
The following notes apply when ordinal numbering is selected using the o modifier.
In some languages, the form of numbers (especially ordinal numbers) varies depending
on the grammatical context: they may have different genders and may decline with the
noun that they qualify. In such cases the string appearing in parentheses after the
letter c or o may be used to indicate the variation of the
cardinal or ordinal number required.
The way in which the variation is indicated will depend on the conventions of the language.
For inflected languages that vary the ending of the word, the approach recommended
in the previous version of this specification was to indicate the required ending,
preceded by a hyphen: for example in German, appropriate values might be
o(-e), o(-er), o(-es), o(-en).
Another approach, which might usefully be adopted by an implementation based on the
open-source ICU localization library o(%spellout-ordinal-masculine), or c(%spellout-cardinal-year).
format-integer(123, 'w') might return "one hundred and
twenty-three"
Ordinal numbering in Italian: The specification "1;o(-º)" with $lang equal to
it, if supported, should produce the sequence:
The specification "Ww;o" with $lang equal to
it, if supported, should produce the sequence:
format-integer(14, 'Ww;o(-e)', 'de') might return
"Vierzehnte"
Returns a string containing a number formatted according to a given picture string, taking account of decimal formats specified in the static context.
The effect of the two-argument form of the function is equivalent to calling the three-argument form with an empty sequence as the value of the third argument.
The function formats $value as a string using the $picture argument and the decimal-format named by the
$decimal-format-name argument, or the unnamed decimal-format, if there
is no $decimal-format-name argument. The syntax of the picture string is
described in
The $value argument may be of any numeric data type
(xs:double, xs:float, xs:decimal, or their
subtypes including xs:integer). Note that if an xs:decimal is
supplied, it is not automatically promoted to an xs:double, as such
promotion can involve a loss of precision.
If the supplied value of the $value argument is an empty sequence, the
function behaves as if the supplied value were the xs:double value
NaN.
The value of $decimal-format-name, if present and non-empty,
EQName as defined in the XPath 3.0
grammar, that is one of the following:
A lexical QName, which is expanded using the statically known namespaces. The default namespace is not used (no prefix means no namespace).
A URIQualifiedName using the syntax Q{uri}local, where
the URI can be zero-length to indicate a name in no namespace.
The decimal format that is used is the decimal format in the static context whose name
matches $decimal-format-name if supplied, or the unnamed decimal format in
the static context otherwise.
The evaluation of the fn:format-number function takes place in two
phases, an analysis phase described in
The analysis phase takes as its inputs the
The result of the function is the formatted string representation of the supplied number.
A dynamic error is raised $decimal-format-name argument is neither a valid lexical QName nor a
valid URIQualifiedName, or if it uses a prefix that is not found in the
statically known namespaces, or if the static context does not contain a declaration of
a decimal-format with a matching expanded QName. If the processor is able to detect the
error statically (for example, when the argument is supplied as a string literal), then
the processor
A string is an ordered sequence of characters, and this specification uses terms such as "left" and "right", "preceding" and "following" in relation to this ordering, irrespective of the position of the characters when visually rendered on some output medium. Both in the picture string and in the result string, digits with higher significance (that is, representing higher powers of ten) always precede digits with lower significance, even when the rendered text flow is from right to left.
The following examples assume a default decimal format in which the chosen digits are the ASCII digits 0-9, the decimal separator is ".", the grouping separator is ",", the minus-sign is "-", and the percent-sign is "%".
The following example assumes the existence of a decimal format named 'ch' in which
the grouping separator is ʹ and the decimal separator is
·:
The following examples assume that the exponent separator is in decimal format 'fortran' is 'E':
Returns an approximation to the mathematical constant π.
This function returns the xs:double value whose lexical representation is
3.141592653589793e0
The expression 60 * (math:pi() div 180) converts an angle of 60 degrees
to radians.
Returns the value of ex.
If $arg is the empty sequence, the function returns the empty sequence.
Otherwise the result is the mathematical constant e raised to the power of
$arg, as defined in the exp function applied to 64-bit binary floating point values.
The treatment of overflow and underflow is defined in
Returns the value of 10x.
If $arg is the empty sequence, the function returns the empty sequence.
Otherwise the result is ten raised to the power of $arg, as defined in the
exp10 function applied
to 64-bit binary floating point values.
The treatment of overflow and underflow is defined in
Returns the natural logarithm of the argument.
If $arg is the empty sequence, the function returns the empty sequence.
Otherwise the result is the natural logarithm of $arg, as defined in the
log function applied
to 64-bit binary floating point values.
The treatment of divideByZero and invalidOperation exceptions
is defined in -INF, and if it is negative, the result is NaN
Returns the base-ten logarithm of the argument.
If $arg is the empty sequence, the function returns the empty sequence.
Otherwise the result is the base-10 logarithm of $arg, as defined in the
log10 function applied
to 64-bit binary floating point values.
The treatment of divideByZero and invalidOperation exceptions
is defined in -INF, and if it is negative, the result is NaN
Returns the non-negative square root of the argument.
If $arg is the empty sequence, the function returns the empty sequence.
Otherwise the result is the mathematical non-negative square root of $arg
as defined in the squareRoot function applied to 64-bit binary floating point values.
The treatment of the invalidOperation exception is defined in NaN.
If $arg is positive or negative zero, positive infinity, or
NaN, then the result is $arg. (Negative zero is the only
case where the result can have negative sign)
Returns the result of raising the first argument to the power of the second.
If $x is the empty sequence, the function returns the empty sequence.
If $y is an instance of xs:integer, the result is
$x raised to the power of $y as defined in the pown function applied to a
64-bit binary floating point value and an integer.
Otherwise $y is converted to an xs:double by numeric
promotion, and the result is the value of $x raised to the power of
$y as defined in the pow function applied to two 64-bit binary floating point values.
The treatment of the divideByZero and invalidOperation
exceptions is defined in
Returns the sine of the argument. The argument is an angle in radians.
If $θ is the empty sequence, the function returns the empty
sequence.
Otherwise the result is the sine of $θ (which is treated as an angle in
radians) as defined in the sin function applied to 64-bit binary floating point values.
The treatment of the invalidOperation and underflow exceptions
is defined in
If $θ is positive or negative zero, the result is
$θ.
If $θ is positive or negative infinity, or NaN,
then the result is NaN.
Otherwise the result is always in the range -1.0e0 to +1.0e0
Returns the cosine of the argument. The argument is an angle in radians.
If $θ is the empty sequence, the function returns the empty
sequence.
If $θ is positive or negative infinity, or NaN,
then the result is NaN.
Otherwise the result is the cosine of $θ (which is treated as an angle in
radians) as defined in the cos function applied to 64-bit binary floating point values.
The treatment of the invalidOperation exception is defined in
If $θ is positive or negative zero, the result is
$θ.
If $θ is positive or negative infinity, or NaN,
then the result is NaN.
Otherwise the result is always in the range -1.0e0 to +1.0e0
Returns the tangent of the argument. The argument is an angle in radians.
If $θ is the empty sequence, the function returns the empty
sequence.
Otherwise the result is the tangent of $θ (which is treated as an angle
in radians) as defined in the tan function applied to 64-bit binary floating point values.
The treatment of the invalidOperation and underflow exceptions
is defined in
If $θ is positive or negative infinity, or NaN,
then the result is NaN.
math:pi() div 2
returns an approximation, the result of math:tan(math:pi() div 2) will be a large
but finite number.-math:pi() div 2
returns an approximation, the result of math:tan(-math:pi() div 2) will be a large
but finite negative number.Returns the arc sine of the argument.
If $arg is the empty sequence, the function returns the empty sequence.
Otherwise the result is the arc sine of $arg as defined in the asin function applied to 64-bit binary floating point values.
The result is in the range -Ï€/2 to +Ï€/2 radians.
The treatment of the invalidOperation and underflow exceptions
is defined in
If $arg is positive or negative zero, the result is $arg.
If $arg is NaN, or if its absolute value is greater than one,
then the result is NaN.
In other cases the result is an xs:double value representing an angle
θ in radians in the range -π/2 <=
θ <= +π/2.
Returns the arc cosine of the argument.
If $arg is the empty sequence, the function returns the empty sequence.
Otherwise the result is the arc cosine of $arg, as defined in the acos function applied to 64-bit binary floating point values.
The result is in the range zero to +Ï€ radians.
The treatment of the invalidOperation exception is defined in
If $arg is NaN, or if its absolute value is greater than one,
then the result is NaN.
In other cases the result is an xs:double value representing an angle
θ in radians in the range 0 <= θ <=
+Ï€.
Returns the arc tangent of the argument.
If $arg is the empty sequence, the function returns the empty sequence.
Otherwise the result is the arc tangent of $arg, as defined
in the atan function applied to 64-bit binary floating point values.
The result is in the range -Ï€/2
to +Ï€/2 radians.
The treatment of the underflow exception is defined in
If $arg is positive or negative zero, the result is $arg.
If $arg is NaN then the result is NaN.
In other cases the result is an xs:double value representing an angle
θ in radians in the range -π/2 <=
θ <= +π/2.
Returns the angle in radians subtended at the origin by the point on a plane with coordinates (x, y) and the positive x-axis.
The result is the value of atan2(y, x) as defined in the atan2 function applied to
64-bit binary floating point values. The result is in the range -Ï€
to +Ï€ radians.
The treatment of the underflow exception is defined in
If either argument is NaN then the result is NaN.
If $y is positive and $x is positive and finite, then (subject
to rules for overflow, underflow and approximation) the value of atan2($y,
$x) is atan($y div $x).
If $y is positive and $x is negative and finite, then (subject
to the same caveats) the value of atan2($y, $x) is π
- atan($y div $x).
Some results for special values of the arguments are shown in the examples below.
Returns an xs:string whose characters have supplied
The function returns the string made up from the $arg. This will be the zero-length string if $arg
is the empty sequence.
A dynamic error is raised $arg is not a permitted XML character.
Returns the sequence of xs:string value.
The function returns a sequence of integers, each integer being the Unicode $arg.
If $arg is a zero-length string or the empty sequence, the function returns
the empty sequence.
Returns -1, 0, or 1, depending on whether $comparand1 collates before,
equal to, or after $comparand2 according to the rules of a selected
collation.
Returns -1, 0, or 1, depending on whether the value of the $comparand1 is
respectively less than, equal to, or greater than the value of $comparand2,
according to the rules of the collation that is used.
The collation used by this function is determined according to the rules in
If either $comparand1 or $comparand2 is the empty sequence,
the function returns the empty sequence.
This function, called with the first signature, defines the semantics of the "eq", "ne",
"gt", "lt", "le" and "ge" operators on xs:string values.
ssand the (German) character
ß(
sharp-s). Otherwise, the returned value depends on the semantics of the default collation.
ssand the (German) character
ß(
sharp-s).
ssand the (German) character
ß(
sharp-s) with less strength than the differences between the base characters, such as the final
n.
Returns true if two strings are equal, considered codepoint-by-codepoint.
If either argument is the empty sequence, the function returns the empty sequence.
Otherwise, the function returns true or false depending on
whether the value of $comparand1 is equal to the value of
$comparand2, according to the Unicode codepoint collation
(http://www.w3.org/2005/xpath-functions/collation/codepoint).
This function allows xs:anyURI values to be compared without having to
specify the Unicode codepoint collation.
Returns the concatenation of the string values of the arguments.
This function accepts two or more xs:anyAtomicType arguments and casts each
one to xs:string. The function returns the xs:string that is
the concatenation of the values of its arguments after conversion. If any argument is
the empty sequence, that argument is treated as the zero-length string.
The fn:concat function is specified to allow two or more arguments, which
are concatenated together. This is the only function specified in this document that
allows a variable number of arguments. This capability is retained for compatibility
with
As mentioned in fn:concat. If a normalized result is required,
fn:normalize-unicode can be applied to the xs:string
returned by fn:concat. The following XQuery:
where the "?" represents either the actual Unicode character COMBINING DIARESIS (Unicode codepoint U+0308) or "̈", will return:
"I plan to go to Mu?nchen in September"
where the "?" represents either the actual Unicode character COMBINING DIARESIS (Unicode codepoint U+0308) or "̈". It is worth noting that the returned value is not normalized in NFC; however, it is normalized in NFD.
However, the following XQuery:
where the "?" represents either the actual Unicode character COMBINING DIARESIS (Unicode codepoint U+0308) or "̈", will return:
"I plan to go to München in September"
This returned result is normalized in NFC.
Returns a string created by concatenating the items in a sequence, with a defined separator between adjacent items.
The effect of calling the single-argument version of this function is the same as
calling the two-argument version with $arg2 set to a zero-length
string.
The function returns an xs:string created by $arg1 to an xs:string,
and then concatenating the result strings in order,$arg2 as a
separator between adjacent strings. 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 function returns the
zero-length string.
Returns the portion of the value of $sourceString beginning at the position
indicated by the value of $start and continuing for the number of $length.
If the value of $sourceString is the empty sequence, the function returns
the zero-length string.
Otherwise, the function returns a string comprising those $sourceString whose index position (counting
from one) is greater than or equal to the value of $start (rounded to an
integer), and (if $length is specified) less than the sum of
$start and $length (both rounded to integers).
The characters returned do not extend beyond $sourceString. If
$start is zero or negative, only those characters in positions greater
than zero are returned.
More specifically, the three argument version of the function returns the characters in
$sourceString whose position $p satisfies:
fn:round($start) <= $p and $p < fn:round($start) + fn:round($length)
The two argument version of the function assumes that $length is infinite
and thus returns the $sourceString whose position $p satisfies:
fn:round($start) <= $p
In the above computations, the rules for op:numeric-less-than and
op:numeric-greater-than apply.
The first character of a string is located at position 1, not position 0.
The second and third arguments allow xs:double values (rather than
requiring xs:integer) in order to achieve compatibility with XPath 1.0.
A surrogate pair counts as one character, not two.
The consequences of supplying values such as NaN or positive or negative
infinity for the $start or $length arguments follow from the
above rules, and are not always intuitive.
$sourceString are selected.0 div 0E0 returns NaN, and
NaN compared to any other number returns false, no
characters are selected.INF are selected.-INF + INF is NaN, no
characters are selected.Returns the number of
The function returns an xs:integer equal to the length in $arg.
Calling the zero-argument version of the function is equivalent to calling
fn:string-length(fn:string(.)).
If the value of $arg is the empty sequence, the function returns the
xs:integer value zero (0).
If $arg is not specified and the context item is
Unlike some programming languages, a
There are situations where fn:string-length() has a different effect
from fn:string-length(.). For example, if the context item
is an attribute node typed as an xs:integer with the string value 000001,
then fn:string-length() returns 6 (the length of the string value of the node), while
fn:string-length(.) raises a type error (because the result of atomization
is not an xs:string).
Returns the value of $arg with leading and trailing whitespace removed, and
sequences of internal whitespace reduced to a single space character.
If the value of $arg is the empty sequence, the function returns the
zero-length string.
The function returns a string constructed by stripping leading and trailing whitespace
from the value of $arg, and replacing sequences of one or more adjacent
whitespace characters with a single space, #x20.
The whitespace characters are defined in the metasymbol S (Production 3) of
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
The definition of whitespace is unchanged in
S ::= (#x20 | #x9 | #xD | #xA)+
Returns the value of $arg after applying Unicode normalization.
If the value of $arg is the empty sequence, the function returns the
zero-length string.
If the single-argument version of the function is used, the result is the same as
calling the two-argument version with $normalizationForm set to the string
"NFC".
Otherwise, the function returns the value of $arg normalized according to
the rules of the normalization form identified by the value of
$normalizationForm.
The effective value of $normalizationForm is the value of the expression
fn:upper-case(fn:normalize-space($normalizationForm)).
If the effective value of $normalizationForm is NFC
,
then the function returns the value of $arg converted to Unicode
Normalization Form C (NFC).
If the effective value of $normalizationForm is NFD
,
then the function returns the value of $arg converted to Unicode
Normalization Form D (NFD).
If the effective value of $normalizationForm is NFKC
,
then the function returns the value of $arg in Unicode Normalization
Form KC (NFKC).
If the effective value of $normalizationForm is NFKD
,
then the function returns the value of $arg converted to Unicode
Normalization Form KD (NFKD).
If the effective value of $normalizationForm is
FULLY-NORMALIZED
, then the function returns the value of
$arg converted to fully normalized form.
If the effective value of $normalizationForm is the zero-length
string, no normalization is performed and $arg is returned.
Normalization forms NFC, NFD, NFKC, and NFKD, and the algorithms to be used for
converting a string to each of these forms, are defined in
The motivation for normalization form FULLY-NORMALIZED is explained in
A string is
A composing character is a character that is one or both of the following:
the second character in the canonical decomposition mapping of some
character that is not listed in the Composition Exclusion Table defined in
of non-zero canonical combining class (as defined in
A string is converted to FULLY-NORMALIZED form as follows:
if the first character in the string is a composing character, prepend a single space (x20);
convert the resulting string to normalization form NFC.
Conforming implementations
It is fn:normalize-unicode function leaves such codepoints unchanged. If the
implementation supports the requested normalization form then it
A $normalizationForm argument is not one of the values
supported by the implementation.
Converts a string to upper case.
If the value of $arg is the empty sequence, the zero-length string is
returned.
Otherwise, the function returns the value of $arg after translating every
Case mappings may change the length of a string. In general, the
fn:upper-case and fn:lower-case functions are not inverses
of each other: fn:lower-case(fn:upper-case($arg)) is not guaranteed to
return $arg, nor is fn:upper-case(fn:lower-case($arg)). The
Latin small letter dotless i (as used in Turkish) is perhaps the most prominent
lower-case letter which will not round-trip. The Latin capital letter i with dot above
is the most prominent upper-case letter which will not round trip; there are others,
such as Latin capital letter Sharp S (#1E9E) which was introduced in Unicode 5.1.
These functions may not always be linguistically appropriate (e.g. Turkish i without dot) or appropriate for the application (e.g. titlecase). In cases such as Turkish, a simple translation should be used first.
Because the function is not sensitive to locale, results will not always match user expectations. In Quebec, for example, the standard uppercase equivalent of "è" is "È", while in metropolitan France it is more commonly "E"; only one of these is supported by the functions as defined.
Many characters of class Ll lack uppercase equivalents in the Unicode case mapping tables; many characters of class Lu lack lowercase equivalents.
Converts a string to lower case.
If the value of $arg is the empty sequence, the zero-length string is
returned.
Otherwise, the function returns the value of $arg after translating every
Case mappings may change the length of a string. In general, the
fn:upper-case and fn:lower-case functions are not inverses
of each other: fn:lower-case(fn:upper-case($arg)) is not guaranteed to
return $arg, nor is fn:upper-case(fn:lower-case($arg)). The
Latin small letter dotless i (as used in Turkish) is perhaps the most prominent
lower-case letter which will not round-trip. The Latin capital letter i with dot above
is the most prominent upper-case letter which will not round trip; there are others,
such as Latin capital letter Sharp S (#1E9E) which was introduced in Unicode 5.1.
These functions may not always be linguistically appropriate (e.g. Turkish i without dot) or appropriate for the application (e.g. titlecase). In cases such as Turkish, a simple translation should be used first.
Because the function is not sensitive to locale, results will not always match user expectations. In Quebec, for example, the standard uppercase equivalent of "è" is "È", while in metropolitan France it is more commonly "E"; only one of these is supported by the functions as defined.
Many characters of class Ll lack uppercase equivalents in the Unicode case mapping tables; many characters of class Lu lack lowercase equivalents.
Returns the value of $arg modified by replacing or removing individual
characters.
If the value of $arg is the empty sequence, the function returns the
zero-length string.
Otherwise, the function returns a result string constructed by processing each $arg, in order,
according to the following rules:
If the character does not appear in the value of $mapString then it
is added to the result string unchanged.
If the character first appears in the value of $mapString at some
position $transString is
$transString is added to the result string.
If the character first appears in the value of $mapString at some
position $transString is less than
If $mapString is the zero-length string then the function returns
$arg unchanged.
If a character occurs more than once in $mapString, then the first
occurrence determines the action taken.
If $transString is longer than $mapString, the excess
characters are ignored.
Encodes reserved characters in a string that is intended to be used in the path segment of a URI.
If $uri-part is the empty sequence, the function returns the zero-length
string.
This function applies the URI escaping rules defined in section 2 of 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
Since
All characters are escaped except those identified as "unreserved" by
This function escapes URI delimiters and therefore cannot be used indiscriminately to encode "invalid" characters in a path segment.
This function is invertible but not idempotent. This is because a string containing a
percent character will be modified by applying the function: for example
100% becomes 100%25, while 100%25 becomes
100%2525.
Converts a string containing an IRI into a URI according to the rules of
If $iri is the empty sequence, the function returns the zero-length
string.
Otherwise, the function converts the value of $iri into a URI according to
the rules given in Section 3.1 of $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
Since
The function is idempotent but not invertible. Both the inputs My Documents
and My%20Documents will be converted to the output
My%20Documents.
This function does not check whether $iri is a valid IRI. It treats it as
an
The following printable ASCII characters are invalid in an IRI: "<", ">",
"
(double quote), space, "{", "}", "|", "\", "^", and "`". Since these
characters should not appear in an IRI, if they do appear in $iri they will
be percent-encoded. In addition, characters outside the range x20-x7E will be
percent-encoded because they are invalid in a URI.
Since this function does not escape the PERCENT SIGN "%" and this character is not allowed in data within a URI, users wishing to convert character strings (such as file names) that include "%" to a URI should manually escape "%" by replacing it with "%25".
Escapes a URI in the same way that HTML user agents handle attribute values expected to contain URIs.
If $uri is the empty sequence, the function returns the zero-length
string.
Otherwise, the function escapes all $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.
The behavior of this function corresponds to the recommended handling of non-ASCII
characters in URI attribute values as described in
Returns true if the string $arg1 contains $arg2 as a
substring, taking collations into account.
If the value of $arg1 or $arg2 is the empty sequence, or
contains only ignorable collation units, it is interpreted as the zero-length
string.
If the value of $arg2 is the zero-length string, then the function returns
true.
If the value of $arg1 is the zero-length string, the function returns
false.
The collation used by this function is determined according to the rules in
The function returns an xs:boolean indicating whether or not the value of
$arg1 contains (at the beginning, at the end, or anywhere within) at
least one sequence of collation units that provides a $arg2, according to the collation that is
used.
A
The collation used in these examples, http://example.com/CollationA is a
collation in which both "-" and "*" are ignorable collation units.
"Ignorable collation unit" is equivalent to "ignorable collation element" in
Returns true if the string $arg1 contains $arg2 as a leading
substring, taking collations into account.
If the value of $arg1 or $arg2 is the empty sequence, or
contains only ignorable collation units, it is interpreted as the zero-length
string.
If the value of $arg2 is the zero-length string, then the function returns
true. If the value of $arg1 is the zero-length string and
the value of $arg2 is not the zero-length string, then the function returns
false.
The collation used by this function is determined according to the rules in
The function returns an xs:boolean indicating whether or not the value of
$arg1 starts with a sequence of collation units that provides a
$arg2 according to the
collation that is used.
A
The collation used in these examples, http://example.com/CollationA is a
collation in which both "-" and "*" are ignorable collation units.
"Ignorable collation unit" is equivalent to "ignorable collation element" in
Returns true if the string $arg1 contains $arg2 as a trailing
substring, taking collations into account.
If the value of $arg1 or $arg2 is the empty sequence, or
contains only ignorable collation units, it is interpreted as the zero-length
string.
If the value of $arg2 is the zero-length string, then the function returns
true. If the value of $arg1 is the zero-length string and
the value of $arg2 is not the zero-length string, then the function returns
false.
The collation used by this function is determined according to the rules in
The function returns an xs:boolean indicating whether or not the value of
$arg1 $arg2 according to the
collation that is used.
A
The collation used in these examples, http://example.com/CollationA is a
collation in which both "-" and "*" are ignorable collation units.
"Ignorable collation unit" is equivalent to "ignorable collation element" in
Returns the part of $arg1 that precedes the first occurrence of
$arg2, taking collations into account.
If the value of $arg1 or $arg2 is the empty sequence, or
contains only ignorable collation units, it is interpreted as the zero-length
string.
If the value of $arg2 is the zero-length string, then the function returns
the zero-length string.
If the value of $arg1 does not contain a string that is equal to the value
of $arg2, then the function returns the zero-length string.
The collation used by this function is determined according to the rules in
The function returns the substring of the value of $arg1 that precedes in
the value of $arg1 the first occurrence of a sequence of collation units
that provides a $arg2
according to the collation that is used.
A
The collation used in these examples, http://example.com/CollationA is a
collation in which both "-" and "*" are ignorable collation units.
"Ignorable collation unit" is equivalent to "ignorable collation element" in
Returns the part of $arg1 that follows the first occurrence of
$arg2, taking collations into account.
If the value of $arg1 or $arg2 is the empty sequence, or
contains only ignorable collation units, it is interpreted as the zero-length
string.
If the value of $arg2 is the zero-length string, then the function returns
the value of $arg1.
If the value of $arg1 does not contain a string that is equal to the value
of $arg2, then the function returns the zero-length string.
The collation used by this function is determined according to the rules in
The function returns the substring of the value of $arg1 that follows in
the value of $arg1 the first occurrence of a sequence of collation units
that provides a $arg2
according to the collation that is used.
A dynamic error
The collation used in these examples, http://example.com/CollationA is a
collation in which both "-" and "*" are ignorable collation units.
"Ignorable collation unit" is equivalent to "ignorable collation element" in
Returns true if the supplied string matches a given regular expression.
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
If $input is the empty sequence, it is interpreted as the zero-length
string.
The function returns true if $input or some substring of
$input matches the regular expression supplied as $pattern.
Otherwise, the function returns false. The matching rules are influenced by
the value of $flags if present.
A dynamic error is raised $pattern is invalid according to the rules described in
A dynamic error is raised $flags is invalid according to the rules described in
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 multi-line mode).
This is different from the behavior of patterns in
Regular expression matching is defined on the basis of Unicode code points; it takes no account of collations.
Given the source document:
the following function calls produce the following results, with the
poem element as the context node:
Returns a string produced from the input string by replacing any substrings that match a given regular expression with a supplied 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
The $flags argument is interpreted in the same manner as for the
fn:matches function.
If $input is the empty sequence, it is interpreted as the zero-length
string.
The function returns the xs:string that is obtained by replacing each
non-overlapping substring of $input that matches the given
$pattern with an occurrence of the $replacement string.
If two overlapping substrings of $input both match the
$pattern, then only the first one (that is, the one whose first $input string) is
replaced.
If the q flag is present, the replacement string is used
Otherwise, within the $replacement string, a variable $N may
be used to refer to the substring captured by the Nth parenthesized sub-expression in
the regular expression. For each match of the pattern, these variables are assigned the
value of the content matched by the relevant sub-expression, and the modified
replacement string is then substituted for the $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:
If N=0, then the variable is replaced by the substring
matched by the regular expression as a whole.
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.
If S<N<=9, then the variable is
replaced by the zero-length string.
Otherwise (if N>S and
N>9), the last digit of N is taken to
be a literal character to be included "as is" in the replacement string, and the
rules are reapplied using the number N formed by stripping off this
last digit.
For example, if the replacement string is
"$23"
and there are 5 substrings, the result contains the value of the substring that
matches the second sub-expression, followed by the digit
3.
Unless the q flag is used, a literal $ character within the
replacement string must be written as \$, and a literal \
character must be written as \\.
If two alternatives within the pattern both match at the same position in the
$input, then the match that is chosen is the one matched by the first
alternative. For example:
A dynamic error is raised $pattern is invalid according to the rules described in section
A dynamic error is raised $flags is invalid according to the rules described in section
A dynamic error is raised fn:matches("", $pattern,
$flags) returns true. It is not an error, however, if a captured
substring is zero-length.
q flag,$replacement contains a dollar sign ($) character that is not
immediately followed by a digit 0-9 and not immediately preceded by a
backslash (\).
q flag,$replacement contains a backslash (\) character that is not part of a
\\ pair, unless it is immediately followed by a dollar sign ($)
character.
If the input string contains no substring that matches the regular expression, the result of the function is a single string identical to the input string.
The expression fn:replace("abracadabra", ".*?", "$1") raises an error,
because the pattern matches the zero-length string
d is replaced.Returns a sequence of strings constructed by splitting the input wherever a separator is found; the separator is any substring that matches a given regular expression.
The one-argument form of this function
splits the supplied string at whitespace boundaries. More specifically, calling fn:tokenize($input)
is equivalent to calling fn:tokenize(fn:normalize-space($input), ' ')) where the second argument
is a single space character (x20).
The effect of calling the two-argument form of this function (omitting the argument
$flags) is the same as the effect of calling the three-argument version with the
$flags argument set to a zero-length string. Flags are defined in
The following rules apply to the three-argument form of the function:
The $flags argument is interpreted in the same way as for the
fn:matches function.
If $input is the empty sequence, or if $input is the
zero-length string, the function returns the empty sequence.
The function returns a sequence of strings formed by breaking the $input
string into a sequence of strings, treating any substring that matches
$pattern as a separator. The separators themselves are not returned.
$input string, the result
sequence will start with a zero-length string. Similarly, 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:
A dynamic error is raised $pattern is invalid according to the rules described in section
A dynamic error is raised $flags is invalid according to the rules described in section
A dynamic error is raised $pattern matches a zero-length string, that is, if fn:matches("",
$pattern, $flags) returns true.
If the input string is not zero length, and no separators are found in the input string, the result of the function is a single string identical to the input string.
The one-argument form of the function has a similar effect to
the two-argument form with \s+ as the separator pattern, except that the one-argument
form strips leading and trailing whitespace, whereas the two-argument form delivers an extra
zero-length token if leading or trailing whitespace is present.
The function returns no information about the separators that were found
in the string. If this information is required, the fn:analyze-string function
can be used instead.
The separator used by the one-argument form of the function is any sequence of tab (x09), newline (x0A), carriage return (x0D) or space (x20) characters. This is the same as the separator recognized by list-valued attributes as defined in XSD. It is not the same as the separator recognized by list-valued attributes in HTML5, which also treats form-feed (x0C) as whitespace. If it is necessary to treat form-feed as a separator, an explicit separator pattern should be used.
fn:tokenize("abba", ".?") raises the dynamic error
Analyzes a string using a regular expression, returning an XML structure that identifies which parts of the input string matched or failed to match the regular expression, and in the case of matched substrings, which substrings matched each capturing group in the regular expression.
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
The $flags argument is interpreted in the same way as for the
fn:matches function.
If $input is the empty sequence the function behaves as if
$input were the zero-length string. In this situation the result will be
an element node with no children.
The function returns an element node whose local name is
analyze-string-result. This element and all its descendant elements have
the namespace URI http://www.w3.org/2005/xpath-functions. The namespace
prefix is fn:match and fn:non-match elements. This sequence
is formed by breaking the $input string into a sequence of strings,
returning any substring that matches $pattern as the content of a
match element, and any intervening substring as the content of a
non-match element.
More specifically, the function starts at the beginning of the input string and attempts
to find the first substring that matches the regular expression. If there are several
matches, the first match is defined to be the one whose starting position comes first in
the string. If several alternatives within the regular expression both match at the same
position in the input string, then the match that is chosen is the first alternative
that matches. For example, if the input string is The quick brown fox jumps
and the regular expression is jump|jumps, then the match that is chosen is
jump.
Having found the first match, the instruction proceeds to find the second and subsequent
matches by repeating the search, starting at the first
The input string is thus partitioned into a sequence of substrings, some of which match
the regular expression, others which do not match it. Each substring will contain at
least one character. This sequence is represented in the result by the sequence of
fn:match and fn:non-match children of the returned element
node; the string value of the fn:match or fn:non-match element
will be the corresponding substring of $input, and the string value of the
returned element node will therefore be the same as $input.
The content of an fn:non-match element is always a single text node.
The content of a fn:match element, however, is in general a sequence of
text nodes and fn:group element children. An fn:group element
with a nr attribute having the integer value N identifies the
substring captured by the Nth parenthesized sub-expression in the regular
expression. For each capturing subexpression there will be at most one corresponding
fn:group element in each fn:match element in the
result.
If the function is called twice with the same arguments, it is
The base URI of the element nodes in the result is
A schema is defined for the structure of the returned element: see
The result of the function will always be such that validation against this schema would succeed.
However, it is
A dynamic error is raised $pattern is invalid according to the rules described in section
A dynamic error is raised $flags is invalid according to the rules described in section
A dynamic error is raised $pattern matches a zero-length string, that is, if fn:matches("",
$pattern, $flags) returns true.
It is
The declarations and definitions in the schema are not automatically available in
the static context of the fn:analyze-string call (or of any other
expression). The contents of the static context are host-language defined, and in some
host languages are implementation-defined.
The schema defines the outermost element, analyze-string-result, in such
a way that mixed content is permitted. In fact the element will only have element nodes (match
and non-match) as its children, never text nodes. Although this might have originally been an
oversight, defining the analyze-string-result element with mixed="true" allows it
to be atomized, which is potentially useful (the atomized value will be the original input string),
and the capability has therefore been retained for compatibility with the 3.0 version of this
specification.
In the following examples, the result document is shown in serialized form, with whitespace between the element nodes. This whitespace is not actually present in the result.
Determines whether or not any of the supplied strings, when tokenized at whitespace boundaries, contains the supplied token, under the rules of the supplied collation.
If $input is the empty sequence, the function returns false.
Leading and trailing whitespace is trimmed from the supplied value of $token. If the trimmed value of $token
is a zero-length string, the function returns false.
The collation used by this function is determined according to the rules in
The function returns true if and only if there is string in $input which,
after tokenizing at whitespace boundaries, contains a token
that is equal to the trimmed value of $token under
the rules of the selected collation.
That is, the function returns the value of the expression:
Interior whitespace within $token will cause the function to return false,
unless such whitespace is ignored by the selected collation.
This function can be used for processing space-separated attribute values
(for example, the XHTML and DITA class attribute),
where one often needs to test for the presence
of a single token in a space-separated list. The function is designed to work
both when the attribute has been validated against an XSD list type, and when it
appears as a single untyped string. It differs from the
HTML 5 definition in that HTML 5 recognizes form feed (x0C) as a separator.
To reproduce the HTML token matching behavior, the HTML ASCII case-insensitive collation
should be used: see
Resolves a relative IRI reference against an absolute IRI.
The function is defined to operate on IRI references as defined in
The following rules apply in order:
If $relative is the empty sequence, the function returns the empty
sequence.
If $relative is an absolute IRI (as defined above), then it is returned
unchanged.
If the $base argument is not supplied, then:
If the static base URI in the static context is not absent, it is used as the effective
value of $base.
Otherwise, a dynamic error is raised:
The function resolves the relative IRI reference $relative
against the base IRI $base using the algorithm defined in
The first form of this function resolves $relative against the value of the
base-uri property from the static context. A dynamic error is raised
A dynamic error is raised $relative
is not a valid IRI according to the rules of RFC3987, extended with an
implementation-defined subset of the extensions permitted in LEIRI, or if it is not a
suitable relative reference to use as input to the RFC3986 resolution algorithm extended
to handle additional unreserved characters.
A dynamic error is raised $base is
not a valid IRI according to the rules of RFC3987, extended with an
implementation-defined subset of the extensions permitted in LEIRI, or if it is not a
suitable IRI to use as input to the chosen resolution algorithm (for example, if it is a
relative IRI reference, if it is a non-hierarchic URI, or if it contains a fragment
identifier).
A dynamic error is raised
Resolving a URI does not dereference it. This is merely a syntactic operation on two
The algorithms in the cited RFCs include some variations that are optional or recommended rather than mandatory; they also describe some common practices that are not recommended, but which are permitted for backwards compatibility. Where the cited RFCs permit variations in behavior, so does this specification.
Throughout this family of specifications, the phrase "resolving a relative URI (or IRI) reference" should be understood as using the rules of this function, unless otherwise stated.
RFC3986 defines an algorithm for resolving relative references
in the context of the URI syntax defined in that RFC. RFC3987 describes a modification
to that algorithm to make it applicable to IRIs (specifically: additional characters
permitted in an IRI are handled the same way that RFC3986 handles unreserved characters).
The LEIRI specification does not explicitly define a resolution algorithm, but suggests
that it
Returns the xs:boolean value true.
The result is equivalent to xs:boolean("1").
Returns the xs:boolean value false.
The result is equivalent to xs:boolean("0").
xs:boolean values.Returns true if the two arguments are the same boolean value.
The function returns true if both arguments are true or if
both arguments are false. It returns false if one of the
arguments is true and the other argument is false.
xs:boolean values. Also
used in the definition of the "ge" operator.Returns true if the first argument is false and the second is true.
The function returns true if $arg1 is false and
$arg2 is true. Otherwise, it returns
false.
xs:boolean values. Also
used in the definition of the "le" operator.Returns true if the first argument is true and the second is false.
The function call op:boolean-greater-than($A, $B) is defined to return the
same result as op:boolean-less-than($B, $A)
Computes the effective boolean value of the sequence $arg.
The function computes the effective boolean value of a sequence, defined according to
the following rules. See also
If $arg is the empty sequence, fn:boolean returns
false.
If $arg is a sequence whose first item is a node,
fn:boolean returns true.
If $arg is a singleton value of type xs:boolean or a
derived from xs:boolean, fn:boolean returns
$arg.
If $arg is a singleton value of type xs:string or a type
derived from xs:string, xs:anyURI or a type derived from
xs:anyURI, or xs:untypedAtomic,
fn:boolean returns false if the operand value has
zero length; otherwise it returns true.
If $arg is a singleton value of any numeric type or a type derived
from a numeric type, fn:boolean returns false if the
operand value is NaN or is numerically equal to zero; otherwise it
returns true.
In all cases other than those listed above, fn:boolean raises a type error
The result of this function is not necessarily the same as $arg cast as
xs:boolean. For example, fn:boolean("false") returns the value
true whereas "false" cast as xs:boolean (which can also be
written xs:boolean("false")) returns false.
fn:boolean($abc) raises a type error
fn:boolean([]) raises a type error
Returns true if the effective boolean value of $arg is
false, or false if it is true.
The value of $arg is first reduced to an effective boolean value by
applying the fn:boolean() function. The function returns true
if the effective boolean value is false, or false if the
effective boolean value is true.
fn:not(1 to 10) raises a type error
xs:yearMonthDuration
values. Also used in the definition of the "ge" operator.Returns true if $arg1 is a shorter duration than $arg2.
If the number of months in the value of $arg1 is numerically less than the
number of months in the value of $arg2, the function returns true.
Otherwise, the function returns false.
Either or both durations may be negative.
xs:yearMonthDuration
values. Also used in the definition of the "le" operator.Returns true if $arg1 is a longer duration than $arg2.
The function call op:yearMonthDuration-greater-than($A, $B) is defined to
return the same result as op:yearMonthDuration-less-than($B, $A)
xs:dayTimeDuration values.
Also used in the definition of the "ge" operator.Returns true if $arg1 is a shorter duration than $arg2.
If the number of seconds in the value of $arg1 is numerically less than the
number of seconds in the value of $arg2, the function returns true.
Otherwise, the function returns false.
Either or both durations may be negative
xs:dayTimeDuration values.
Also used in the definition of the "le" operator.Returns true if $arg1 is a longer duration than $arg2.
The function call op:dayTimeDuration-greater-than($A, $B) is defined to
return the same result as op:dayTimeDuration-less-than($B, $A)
xs:duration values. Also
used in the definition of the "ne" operator.Returns true if $arg1 and $arg2 are durations of the same
length.
If the xs:yearMonthDuration components of $arg1 and
$arg2 are equal and the xs:dayTimeDuration components of
$arg1 and $arg2 are equal, the function returns
true.
Otherwise, the function returns false.
The semantics of this function are:
that is, the function returns true if the months and seconds values of the
two durations are equal.
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.
Returns the number of years in a duration.
If $arg is the empty sequence, the function returns the empty sequence.
Otherwise, the function returns an xs:integer representing the years
component in the value of $arg. ($months, $seconds) tuple, the result is the value of ($months idiv 12)
If $arg is a negative duration then the result will be negative.
If $arg is an xs:dayTimeDuration the function returns 0.
Returns the number of months in a duration.
If $arg is the empty sequence, the function returns the empty sequence.
Otherwise, the function returns an xs:integer representing the months
component in the value of $arg. ($months, $seconds) tuple, the result is the value of ($months mod 12)
If $arg is a negative duration then the result will be negative.
If $arg is an xs:dayTimeDuration the function returns 0.
Returns the number of days in a duration.
If $arg is the empty sequence, the function returns the empty sequence.
Otherwise, the function returns an xs:integer representing the days
component in the value of $arg. ($months, $seconds) tuple, the result is the value of ($seconds idiv 86400)
If $arg is a negative duration then the result will be negative.
If $arg is an xs:yearMonthDuration the function returns 0.
Returns the number of hours in a duration.
If $arg is the empty sequence, the function returns the empty sequence.
Otherwise, the function returns an xs:integer representing the hours
component in the value of $arg. ($months, $seconds) tuple, the result is the value of ($seconds mod 86400) idiv 3600
If $arg is a negative duration then the result will be negative.
If $arg is an xs:yearMonthDuration the function returns 0.
Returns the number of minutes in a duration.
If $arg is the empty sequence, the function returns the empty sequence.
Otherwise, the function returns an xs:integer representing the minutes
component in the value of $arg. ($months, $seconds) tuple, the result is the value of ($seconds mod 3600) idiv 60
If $arg is a negative duration then the result will be negative.
If $arg is an xs:yearMonthDuration the function returns 0.
Returns the number of seconds in a duration.
If $arg is the empty sequence, the function returns the empty sequence.
Otherwise, the function returns an xs:decimal representing the seconds
component in the value of $arg. ($months, $seconds) tuple, the result is the value of ($seconds mod 60)
as an xs:decimal
If $arg is a negative duration then the result will be negative.
If $arg is an xs:yearMonthDuration the function returns 0.
xs:yearMonthDuration values.Returns the result of adding two xs:yearMonthDuration values.
The function returns the result of adding the value of $arg1 to the value
of $arg2. The result will be an xs:yearMonthDuration whose
length in months is equal to the length in months of $arg1 plus the length
in months of $arg2.
For handling of overflow, see
Either duration (and therefore the result) may be negative.
xs:yearMonthDuration values.Returns the result of subtracting one xs:yearMonthDuration value from
another.
The function returns the result of subtracting the value of $arg2 from the
value of $arg1. The result will be an xs:yearMonthDuration
whose length in months is equal to the length in months of $arg1 minus the
length in months of $arg2.
For handling of overflow, see
Either duration (and therefore the result) may be negative.
xs:yearMonthDuration and a numeric
value.Returns the result of multiplying the value of $arg1 by $arg2.
The result is rounded to the nearest month.
The result is the xs:yearMonthDuration whose length in months is equal to
the result of applying the fn:round function to the value obtained by
multiplying the length in months of $arg1 by the value of
$arg2.
If $arg2 is positive or negative zero, the result is a zero-length
duration. If $arg2 is positive or negative infinity, the result overflows
and is handled as described in
For handling of overflow and underflow, see
A dynamic error is raised $arg2 is
NaN.
Either duration (and therefore the result) may be negative.
xs:yearMonthDuration and a numeric
value.Returns the result of dividing the value of $arg1 by $arg2.
The result is rounded to the nearest month.
The result is the xs:yearMonthDuration whose length in months is equal to
the result of applying the fn:round function to the value obtained by
dividing the length in months of $arg1 by the value of
$arg2.
If $arg2 is positive or negative infinity, the result is a zero-length
duration. If $arg2 is positive or negative zero, the result overflows and
is handled as described in
For handling of overflow and underflow, see
A dynamic error is raised $arg2 is
NaN.
Either operand (and therefore the result) may be negative.
xs:yearMonthDuration values.Returns the ratio of two xs:yearMonthDuration values.
The function returns the result of dividing the length in months of $arg1
by the length in months of $arg2, according to the rules of the
op:numeric-divide function for integer operands.
For handling of overflow and underflow, see
Either duration (and therefore the result) may be negative.
The following example demonstrates how to calculate the length of an
xs:yearMonthDuration value in months:
xs:dayTimeDuration values.Returns the sum of two xs:dayTimeDuration values.
The function returns the result of adding the value of $arg1 to the value
of $arg2. The result is the xs:dayTimeDuration whose length in
seconds is equal to the sum of the length in seconds of the two input durations.
For handling of overflow, see
Either duration (and therefore the result) may be negative.
xs:dayTimeDuration values.Returns the result of subtracting one xs:dayTimeDuration from another.
The function returns the result of subtracting the value of $arg2 from the
value of $arg1. The result is the xs:dayTimeDuration whose
length in seconds is equal to the length in seconds of $arg1 minus the
length in seconds of $arg2.
For handling of overflow, see
Either duration (and therefore the result) may be negative.
xs:dayTimeDuration and a numeric
value.Returns the result of multiplying a xs:dayTimeDuration by a number.
The function returns the result of multiplying the value of $arg1 by
$arg2. The result is the xs:dayTimeDuration whose length in
seconds is equal to the length in seconds of $arg1 multiplied by the
numeric value $arg2.
If $arg2 is positive or negative zero, the result is a zero-length
duration. If $arg2 is positive or negative infinity, the result overflows
and is handled as described in
For handling of overflow and underflow, see
A dynamic error is raised $arg2 is
NaN.
Either operand (and therefore the result) may be negative.
xs:dayTimeDuration values.Returns the result of multiplying a xs:dayTimeDuration by a number.
The function returns the result of dividing the value of $arg1 by
$arg2. The result is the xs:dayTimeDuration whose length in
seconds is equal to the length in seconds of $arg1 divided by the numeric
value $arg2.
If $arg2 is positive or negative infinity, the result is a zero-length
duration. If $arg2 is positive or negative zero, the result overflows and
is handled as described in
For handling of overflow and underflow, see
A dynamic error is raised $arg2 is
NaN.
Either operand (and therefore the result) may be negative.
xs:dayTimeDuration values.Returns the ratio of two xs:dayTimeDuration values, as a decimal
number.
The function returns the result of dividing the value of $arg1 by
$arg2. The result is the xs:dayTimeDuration whose length in
seconds is equal to the length in seconds of $arg1 divided by the length in
seconds of $arg2. The calculation is performed by applying
op:numeric-divide to the two xs:decimal operands.
For handling of overflow and underflow, see
Either operand (and therefore the result) may be negative.
This examples shows how to determine the number of seconds in a duration.
Returns an xs:dateTime value created by combining an xs:date
and an xs:time.
If either $arg1 or $arg2 is the empty sequence the function
returns the empty sequence.
Otherwise, the function returns an xs:dateTime whose date component is
equal to $arg1 and whose time component is equal to $arg2.
The timezone of the result is computed as follows:
If neither argument has a timezone, the result has no timezone.
If exactly one of the arguments has a timezone, or if both arguments have the same timezone, the result has this timezone.
A dynamic error is raised
"24:00:00" is an alternate lexical form
for "00:00:00"xs:dateTime values. Also
used in the definition of the "ne", "le" and "ge" operators.Returns true if the two supplied xs:dateTime values refer to the same
instant in time.
If either $arg1 or $arg2 has no timezone component, the
effective value of the argument is obtained by substituting the implicit timezone from
the dynamic evaluation context.
The function then returns true if and only if the effective value of
$arg1 is equal to the effective value of $arg2 according to
the algorithm defined in section 3.2.7.4 of Order relation on dateTime
for xs:dateTime values with
timezones. Otherwise the function returns false.
Assume that the dynamic context provides an implicit timezone value of
-05:00
xs:dateTime values. Also
used in the definition of the "ge" operator.Returns true if the first argument represents an earlier instant in time
than the second argument.
If either $arg1 or $arg2 has no timezone component, the
effective value of the argument is obtained by substituting the implicit timezone from
the dynamic evaluation context.
The function then returns true if and only if the effective value of
$arg1 is less than the effective value of $arg2 according
to the algorithm defined in section 3.2.7.4 of Order relation on dateTime
for xs:dateTime values with
timezones. Otherwise the function returns false.
xs:dateTime values. Also
used in the definition of the "le" operator.Returns true if the first argument represents a later instant in time than
the second argument.
The function call op:dateTime-greater-than($A, $B) is defined to return the
same result as op:dateTime-less-than($B, $A)
xs:date values. Also used
in the definition of the "ne", "le" and "ge" operators.Returns true if and only if the starting instants of the two supplied
xs:date values are the same.
The starting instant of an xs:date is the xs:dateTime at time
00:00:00 on that date.
The function returns the result of the expression:
xs:dateTime("2004-12-25T00:00:00Z") and
xs:dateTime("2004-12-25T00:00:00+07:00"). These are normalized to
xs:dateTime("2004-12-25T00:00:00Z") and
xs:dateTime("2004-12-24T17:00:00Z"). xs:date values. Also used in the
definition of the "ge" operator.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 function returns the result of the expression:
xs:date values. Also used in the
definition of the "le" operator.Returns true if and only if the starting instant of $arg1 is
greater than the starting instant of $arg2. Returns false
otherwise.
The function call op:date-greater-than($A, $B) is defined to return the
same result as op:date-less-than($B, $A)
xs:time values. Also used
in the definition of the "ne", "le" and "ge" operators.Returns true if the two xs:time values represent the same
instant in time, when treated as being times on the same date, before adjusting the
timezone.
Each of the supplied xs:time values is expanded to an
xs:dateTime value by associating the time with an arbitrary date. The
function returns the result of comparing these two xs:dateTime values using
op:dateTime-equal.
The result of the function is thus the same as the value of the expression:
Assume that the date components from the reference xs:dateTime
correspond to 1972-12-31.
xs:dateTimes calculated using the reference date
components are 1972-12-31T08:00:00+09:00 and
1972-12-31T17:00:00-06:00. These normalize to
1972-12-30T23:00:00Z and 1972-12-31T23:00:00Z.
xs:dateTime
values, a time of 24:00:00 is equivalent to 00:00:00 on
the following day. For xs:time, the normalization from
24:00:00 to 00:00:00 happens before the
xs:time is converted into an xs:dateTime for the
purpose of the equality comparison. For xs:time, any operation on
24:00:00 produces the same result as the same operation on
00:00:00 because these are two different lexical representations
of the same value. xs:time values. Also used in the
definition of the "ge" operator.Returns true if the first xs:time value represents an earlier
instant in time than the second, when both are treated as being times on the same date,
before adjusting the timezone.
Each of the supplied xs:time values is expanded to an
xs:dateTime value by associating the time with an arbitrary date. The
function returns the result of comparing these two xs:dateTime values using
op:dateTime-less-than.
The result of the function is thus the same as the value of the expression:
Assume that the dynamic context provides an implicit timezone value of
-05:00.
xs:time values. Also used in the
definition of the "le" operator.Returns true if the first xs:time value represents a later
instant in time than the second, when both are treated as being times on the same date,
before adjusting the timezone.
The function call op:time-greater-than($A, $B) is defined to return the
same result as op:time-less-than($B, $A)
xs:gYearMonth values. Also
used in the definition of the "ne" operator.Returns true if the two xs:gYearMonth values have the same starting
instant.
The starting instants of $arg1 and $arg2 are calculated by
supplying the missing components of $arg1 and $arg2 from the
xs:dateTime template xxxx-xx-01T00:00:00. The function
returns the result of comparing these two starting instants using
op:dateTime-equal.
Assume that the dynamic context provides an implicit timezone value of
-05:00.
op:gYearMonth-equal(xs:gYearMonth("1986-02"), xs:gYearMonth("1986-03"))
returns false(). The starting instants are
1986-02-01T00:00:00-05:00 and 1986-03-01T00:00:00,
respectively.
op:gYearMonth-equal(xs:gYearMonth("1978-03"), xs:gYearMonth("1986-03Z"))
returns false(). The starting instants are
1978-03-01T00:00:00-05:00 and 1986-03-01T00:00:00Z,
respectively.
xs:gYear values. Also used in the
definition of the "ne" operator.Returns true if the two xs:gYear values have the same starting instant.
The starting instants of $arg1 and $arg2 are calculated by
supplying the missing components of $arg1 and $arg2 from the
xs:dateTime template xxxx-01-01T00:00:00. The function
returns the result of comparing these two starting instants using
op:dateTime-equal.
Assume that the dynamic context provides an implicit timezone value of
-05:00. Assume, also, that the xs:dateTime template is
xxxx-01-01T00:00:00.
op:gYear-equal(xs:gYear("2005-12:00"), xs:gYear("2005+12:00")) returns
false(). The starting instants are
2005-01-01T00:00:00-12:00 and 2005-01-01T00:00:00+12:00,
respectively, and normalize to 2005-01-01T12:00:00Z and
2004-12-31T12:00:00Z.
xs:gMonthDay values. Also
used in the definition of the "ne" operator.Returns true if the two xs:gMonthDay values have the same starting instant,
when considered as days in the same year.
The starting instants of $arg1 and $arg2 are calculated by
supplying the missing components of $arg1 and $arg2 from the
xs:dateTime template 1972-xx-xxT00:00:00 or an equivalent.
The function returns the result of comparing these two starting instants using
op:dateTime-equal.
Assume that the dynamic context provides an implicit timezone value of
-05:00. Assume for the purposes of illustration that the
xs:dateTime template used is 1972-xx-xxT00:00:00 (this
does not affect the result).
1972-12-25T00:00:00-14:00 and
1972-12-26T00:00:00+10:00, respectively, and normalize to
1972-12-25T14:00:00Z and 1972-12-25T14:00:00Z.
xs:gMonth values. Also used
in the definition of the "ne" operator.Returns true if the two xs:gMonth values have the same starting instant,
when considered as months in the same year.
The starting instants of $arg1 and $arg2 are calculated by
supplying the missing components of $arg1 and $arg2 from the
xs:dateTime template 1972-xx-01T00:00:00 or an equivalent.
The function returns the result of comparing these two starting instants using
op:dateTime-equal.
Assume that the dynamic context provides an implicit timezone value of
-05:00. Assume, also, that the xs:dateTime template
chosen is 1972-xx-01T00:00:00.
1972-12-01T00:00:00-14:00 and
1972-12-01T00:00:00+10:00, respectively, and normalize to
1972-11-30T14:00:00Z and 1972-12-01T14:00:00Z.
xs:gDay values. Also used in the
definition of the "ne" operator.Returns true if the two xs:gDay values have the same starting instant, when
considered as days in the same month of the same year.
The starting instants of $arg1 and $arg2 are calculated by
supplying the missing components of $arg1 and $arg2 from the
xs:dateTime template 1972-12-xxT00:00:00 or an equivalent.
The function returns the result of comparing these two starting instants using
op:dateTime-equal.
Assume that the dynamic context provides an implicit timezone value of
-05:00. Assume, also, that the xs:dateTime template is
1972-12-xxT00:00:00.
1972-12-25T00:00:00-14:00 and
1972-12-25T00:00:00+10:00, respectively, and normalize to
1972-12-25T14:00:00Z and 1972-12-24T14:00:00Z.
Returns the year component of an xs:dateTime.
If $arg is the empty sequence, the function returns the empty sequence.
Otherwise, the function returns an xs:integer representing the year
component in the local value of $arg. The result may be negative.
Ignoring complications that arise with midnight on the last day of the year, the year returned is the same numeric value that appears in the lexical representation, which for negative years means the meaning may vary depending on whether XSD 1.0 or XSD 1.1 conventions are in use.
Returns the month component of an xs:dateTime.
If $arg is the empty sequence, the function returns the empty sequence.
Otherwise, the function returns an xs:integer between 1 and 12, both
inclusive, representing the month component in the local value of $arg.
Returns the day component of an xs:dateTime.
If $arg is the empty sequence, the function returns the empty sequence.
Otherwise, the function returns an xs:integer between 1 and 31, both
inclusive, representing the day component in the local value of $arg.
Returns the hours component of an xs:dateTime.
If $arg is the empty sequence, the function returns the empty sequence.
Otherwise, the function returns an xs:integer between 0 and 23, both
inclusive, representing the hours component in the local value of $arg.
Returns the minute component of an xs:dateTime.
If $arg is the empty sequence, the function returns the empty sequence.
Otherwise, the function returns an xs:integer value between 0 and 59, both
inclusive, representing the minute component in the local value of
$arg.
Returns the seconds component of an xs:dateTime.
If $arg is the empty sequence, the function returns the empty sequence.
Otherwise, the function returns an xs:decimal value greater than or equal
to zero and less than 60, representing the seconds and fractional seconds in the local
value of $arg.
Returns the timezone component of an xs:dateTime.
If $arg is the empty sequence, the function returns the empty sequence.
Otherwise, the function returns the timezone component of $arg, if any. If
$arg has a timezone component, then the result is an
xs:dayTimeDuration that indicates deviation from UTC; its value may
range from +14:00 to -14:00 hours, both inclusive. If $arg has no timezone
component, the result is the empty sequence.
Returns the year component of an xs:date.
If $arg is the empty sequence, the function returns the empty sequence.
Otherwise, the function returns an xs:integer representing the year in the
local value of $arg. The value may be negative.
The year returned is the same numeric value that appears in the lexical representation, which for negative years means the meaning may vary depending on whether XSD 1.0 or XSD 1.1 conventions are in use.
Returns the month component of an xs:date.
If $arg is the empty sequence, the function returns the empty sequence.
Otherwise, the function returns an xs:integer between 1 and 12, both
inclusive, representing the month component in the local value of $arg.
Returns the day component of an xs:date.
If $arg is the empty sequence, the function returns the empty sequence.
Otherwise, the function returns an xs:integer between 1 and 31, both
inclusive, representing the day component in the localized value of
$arg.
Returns the timezone component of an xs:date.
If $arg is the empty sequence, the function returns the empty sequence.
Otherwise, the function returns the timezone component of $arg, if any. If
$arg has a timezone component, then the result is an
xs:dayTimeDuration that indicates deviation from UTC; its value may
range from +14:00 to -14:00 hours, both inclusive. If $arg has no timezone
component, the result is the empty sequence.
Returns the hours component of an xs:time.
If $arg is the empty sequence, the function returns the empty sequence.
Otherwise, the function returns an xs:integer between 0 and 23, both
inclusive, representing the value of the hours component in the local value of
$arg.
Assume that the dynamic context provides an implicit timezone value of
-05:00.
Returns the minutes component of an xs:time.
If $arg is the empty sequence, the function returns the empty sequence.
Otherwise, the function returns an xs:integer value between 0 and 59, both
inclusive, representing the value of the minutes component in the local value of
$arg.
Returns the seconds component of an xs:time.
If $arg is the empty sequence, the function returns the empty sequence.
Otherwise, the function returns an xs:decimal value greater than or equal
to zero and less than 60, representing the seconds and fractional seconds in the local
value of $arg.
Returns the timezone component of an xs:time.
If $arg is the empty sequence, the function returns the empty sequence.
Otherwise, the function returns the timezone component of $arg, if any. If
$arg has a timezone component, then the result is an
xs:dayTimeDuration that indicates deviation from UTC; its value may
range from +14:00 to -14:00 hours, both inclusive. If $arg has no timezone
component, the result is the empty sequence.
Adjusts an xs:dateTime value to a specific timezone, or to no timezone at
all.
If $timezone is not specified, then the effective value of
$timezone is the value of the implicit timezone in the dynamic
context.
If $arg is the empty sequence, then the function returns the empty
sequence.
If $arg does not have a timezone component and $timezone is
the empty sequence, then the result is $arg.
If $arg does not have a timezone component and $timezone is
not the empty sequence, then the result is $arg with $timezone
as the timezone component.
If $arg has a timezone component and $timezone is the empty
sequence, then the result is the local value of $arg without its timezone
component.
If $arg has a timezone component and $timezone is not the
empty sequence, then the result is the xs:dateTime value that is equal to
$arg and that has a timezone component equal to
$timezone.
A dynamic error is raised $timezone
is less than -PT14H or greater than PT14H or is not an
integral number of minutes.
Assume the dynamic context provides an implicit timezone of -05:00
(-PT5H0M).
Adjusts an xs:date value to a specific timezone, or to no timezone at all;
the result is the date in the target timezone that contains the starting instant of the
supplied date.
If $timezone is not specified, then the effective value of
$timezone is the value of the implicit timezone in the dynamic
context.
If $arg is the empty sequence, then the function returns the empty
sequence.
If $arg does not have a timezone component and $timezone is
the empty sequence, then the result is the value of $arg.
If $arg does not have a timezone component and $timezone is
not the empty sequence, then the result is $arg with $timezone
as the timezone component.
If $arg has a timezone component and $timezone is the empty
sequence, then the result is the local value of $arg without its timezone
component.
If $arg has a timezone component and $timezone is not the
empty sequence, then the function returns the value of the expression:
Let $dt be the value of fn:dateTime($arg,
xs:time('00:00:00')).
Let $adt be the value of fn:adjust-dateTime-to-timezone($dt,
$timezone)
The function returns the value of xs:date($adt)
A dynamic error is raised $timezone
is less than -PT14H or greater than PT14H or is not an
integral number of minutes.
Assume the dynamic context provides an implicit timezone of -05:00
(-PT5H0M).
$arg is converted to
xs:dateTime("2002-03-07T00:00:00-07:00"). This is adjusted to the
implicit timezone, giving "2002-03-07T02:00:00-05:00".
$arg is converted to the xs:dateTime
"2002-03-07T00:00:00-07:00". This is adjusted to the given timezone,
giving "2002-03-06T21:00:00-10:00". Adjusts an xs:time value to a specific timezone, or to no timezone at
all.
If $timezone is not specified, then the effective value of
$timezone is the value of the implicit timezone in the dynamic
context.
If $arg is the empty sequence, then the function returns the empty
sequence.
If $arg does not have a timezone component and $timezone is
the empty sequence, then the result is $arg.
If $arg does not have a timezone component and $timezone is
not the empty sequence, then the result is $arg with $timezone
as the timezone component.
If $arg has a timezone component and $timezone is the empty
sequence, then the result is the localized value of $arg without its
timezone component.
If $arg has a timezone component and $timezone is not the
empty sequence, then:
Let $dt be the xs:dateTime value
fn:dateTime(xs:date('1972-12-31'), $arg).
Let $adt be the value of fn:adjust-dateTime-to-timezone($dt,
$timezone)
The function returns the xs:time value
xs:time($adt).
A dynamic error is raised $timezone
is less than -PT14H or greater than PT14H or if does not
contain an integral number of minutes.
Assume the dynamic context provides an implicit timezone of -05:00
(-PT5H0M).
xs:dateTime values.Returns an xs:dayTimeDuration representing the amount of elapsed time
between the instants arg2 and arg1.
If either $arg1 or $arg2 do not contain an explicit timezone
then, for the purpose of the operation, the implicit timezone provided by the dynamic
context (See
The function returns the elapsed time between the date/time instant arg2
and the date/time instant arg1, computed according to the algorithm given
in Appendix E of xs:dayTimeDuration.
If the normalized value of $arg1 precedes in time the normalized value of
$arg2, then the returned value is a negative duration.
Assume that the dynamic context provides an implicit timezone value of
-05:00.
xs:date values.Returns the xs:dayTimeDuration that corresponds to the elapsed time between
the starting instant of $arg2 and the starting instant of
$arg2.
If either $arg1 or $arg2 do not contain an explicit timezone
then, for the purpose of the operation, the implicit timezone provided by the dynamic
context (See
The starting instant of an xs:date is the xs:dateTime at
00:00:00 on that date.
The function returns the result of subtracting the two starting instants using
op:subtract-dateTimes.
If the starting instant of $arg1 precedes in time the starting instant of
$arg2, then the returned value is a negative duration.
Assume that the dynamic context provides an implicit timezone value of
Z.
{2000,
10, 30, 0, 0, 0, PT0S} and {1999, 11, 28, 0, 0, 0,
PT0S}.Now assume that the dynamic context provides an implicit timezone value of
+05:00.
{2000,
10, 29, 19, 0, 0, PT0S} and {1999, 11, 28, 0, 0, 0,
PT0S}.xs:time values.Returns the xs:dayTimeDuration that corresponds to the elapsed time between
the values of $arg2 and $arg1 treated as times on the same
date.
The function returns the result of the expression:
Any other reference date would work equally well.
Assume that the dynamic context provides an implicit timezone value of
-05:00. Assume, also, that the date components of the reference
xs:dateTime correspond to "1972-12-31".
xs:dateTime
value {1972, 12, 31, 11, 12, 0, PT0S} the xs:dateTime
value {1972, 12, 31, 9, 0, 0, PT0S}.xs:dateTime values are {1972, 12, 31, 11,
0, 0, -PT5H} and {1972, 12, 31, 21, 30, 0, PT5H30M}. These
normalize to {1972, 12, 31, 16, 0, 0, PT0S} and {1972, 12, 31,
16, 0, 0, PT0S}. xs:dateTime values are {1972,
12, 31, 23, 0, 0, PT0S} and {1972, 12, 30, 23, 0, 0,
PT0S}.xs:dateTime values are {1972,
12, 31, 0, 0, 0, ()} and {1972, 12, 31, 23, 59, 59.0,
()}.xs:dateTime and an
xs:yearMonthDuration value. Returns the xs:dateTime that is a given duration after a specified
xs:dateTime (or before, if the duration is negative).
The function returns the result of adding $arg2 to the value of
$arg1 using the algorithm described in Appendix E of $arg2
is negative, then the result xs:dateTime precedes $arg1.
The result has the same timezone as $arg1. If $arg1 has no
timezone, the result has no timezone.
xs:dateTime and an
xs:dayTimeDuration value. Returns the xs:dateTime that is a given duration after a specified
xs:dateTime (or before, if the duration is negative).
The function returns the result of adding $arg2 to the value of
$arg1 using the algorithm described in Appendix E of $arg2
is negative, then the result xs:dateTime precedes $arg1.
The result has the same timezone as $arg1. If $arg1 has no
timezone, the result has no timezone.
xs:dateTime and an
xs:yearMonthDuration value. Returns the xs:dateTime that is a given duration before a specified
xs:dateTime (or after, if the duration is negative).
The function returns the xs:dateTime computed by negating
$arg2 and adding the result to the value of $arg1 using the
function op:add-yearMonthDuration-to-dateTime.
xs:dateTime an and
xs:dayTimeDuration valuesReturns the xs:dateTime that is a given duration before a specified
xs:dateTime (or after, if the duration is negative).
The function returns the xs:dateTime computed by negating
$arg2 and adding the result to the value of $arg1 using the
function op:add-dayTimeDuration-to-dateTime.
xs:date and an
xs:yearMonthDuration value. Returns the xs:date that is a given duration after a specified
xs:date (or before, if the duration is negative).
The function returns the result of casting $arg1 to an
xs:dateTime, adding $arg2 using the function
op:add-yearMonthDuration-to-dateTime, and casting the result back to an
xs:date.
xs:date and an
xs:dayTimeDuration value. Returns the xs:date that is a given duration after a specified
xs:date (or before, if the duration is negative).
The function returns the result of casting $arg1 to an
xs:dateTime, adding $arg2 using the function
op:add-dayTimeDuration-to-dateTime, and casting the result back to an
xs:date.
xs:dateTime value {2004, 10, 30, 0, 0, 0, PT0S}.
Adding the second argument to this gives the xs:dateTime value
{2004, 11, 1, 2, 30, 0, PT0S}. The time components are then
discarded. xs:date and an
xs:yearMonthDuration value. Returns the xs:date that is a given duration before a specified
xs:date (or after, if the duration is negative).
Returns the xs:date computed by negating $arg2 and adding the
result to $arg1 using the function
op:add-yearMonthDuration-to-date.
xs:date and an
xs:dayTimeDuration. Returns the xs:date that is a given duration before a specified
xs:date (or after, if the duration is negative).
Returns the xs:date computed by negating $arg2 and adding the
result to $arg1 using the function
op:add-dayTimeDuration-to-date.
xs:time and an
xs:dayTimeDuration value.Returns the xs:time value that is a given duration after a specified
xs:time (or before, if the duration is negative or causes wrap-around
past midnight)
First, the days component in the canonical lexical representation of $arg2
is set to zero (0) and the value of the resulting xs:dayTimeDuration is
calculated. Alternatively, the value of $arg2 modulus 86,400 is used as the
second argument. This value is added to the value of $arg1 converted to an
xs:dateTime using a reference date such as 1972-12-31, and
the time component of the result is returned. Note that the xs:time
returned may occur in a following or preceding day and may be less than
$arg1.
The result has the same timezone as $arg1. If $arg1 has no
timezone, the result has no timezone.
{0, 0, 0, 2, 27, 0, PT3H}xs:time and an
xs:dayTimeDuration value. Returns the xs:time value that is a given duration before a specified
xs:time (or after, if the duration is negative or causes wrap-around
past midnight)
The function returns the result of negating $arg2 and adding the result to
$arg1 using the function op:add-dayTimeDuration-to-time.
Returns a string containing an xs:dateTime value formatted for display.
See
Returns a string containing an xs:date value formatted for display.
See
Returns a string containing an xs:time value formatted for display.
See
Parses a string containing the date and time in IETF format, returning the corresponding
xs:dateTime value.
The function accepts a string matching the production input in the
following grammar:
input
|
::= |
S? (dayname ","? S)? ((datespec S time) | asctime) S?
|
dayname
|
::= |
"Mon" | "Tue" | "Wed" | "Thu" | "Fri" | "Sat" | "Sun" | "Monday | "Tuesday"
| "Wednesday" | "Thursday" | "Friday" | "Saturday" | "Sunday"
|
datespec
|
::= |
daynum dsep monthname dsep year
|
asctime
|
::= |
monthname dsep daynum S time S year
|
dsep
|
::= |
S | (S? "-" S?)
|
daynum
|
::= |
digit digit?
|
year
|
::= |
digit digit (digit digit)?
|
digit
|
::= |
[0-9]
|
monthname
|
::= |
"Jan" | "Feb" | "Mar" | "Apr" | "May" | "Jun" | "Jul" | "Aug" | "Sep" |
"Oct" | "Nov" | "Dec"
|
time
|
::= |
hours ":" minutes (":" seconds)? (S? timezone)?
|
hours
|
::= |
digit digit? |
minutes
|
::= |
digit digit
|
seconds
|
::= |
digit digit ("." digit+)?
|
timezone
|
::= |
tzname | tzoffset (S? "(" S? tzname S? ")")?
|
tzname
|
::= |
"UT" | "UTC" | "GMT" | "EST" | "EDT" | "CST" | "CDT" | "MST" | "MDT" | "PST"
| "PDT"
|
tzoffset
|
::= |
("+"|"-") hours ":"? minutes? |
S
|
::= |
( x09 | x0A | x0D | x20 )+
|
The input is case-insensitive: upper-case and lower-case distinctions in the above grammar show the conventional usage, but otherwise have no significance.
If the input is an empty sequence, the result is an empty sequence.
The dayname, if present, is ignored.
The daynum, monthname, and year supply the day,
month, and year of the resulting xs:dateTime value. A two-digit year
The hours, minutes, and seconds (including
fractional seconds) values supply the corresponding components of the resulting
xs:dateTime value; if the seconds value
If both a tzoffset and a tzname are supplied then the
tzname is ignored.
If a tzoffset is supplied then this defines the hours and minutes parts of the timezone offset:
If it contains a colon, this separates the hours part from the minutes part.
Otherwise, the grammar allows a sequence of from one to four digits. These are interpreted
as H, HH, HMM, or HHMM respectively, where H
or HH is the hours part, and MM (if present) is the minutes part.
00.If a tzname is supplied with no tzoffset then it is translated
to a timezone offset as follows:
| tzname | Offset |
|---|---|
| UT, UTC, GMT | 00:00 |
| EST | -05:00 |
| EDT | -04:00 |
| CST | -06:00 |
| CDT | -05:00 |
| MST | -07:00 |
| MDT | -06:00 |
| PST | -08:00 |
| PDT | -07:00 |
If neither a tzoffset nor tzname is supplied, a timezone
offset of 00:00 is assumed.
A dynamic error is raised
The parse-ietf-date function attempts to interpret its input as a date
in any of the three formats specified by HTTP
These formats are used widely on the Internet to represent timestamps, and were specified in:
asctime() formatThe grammar for this function is slightly more liberal than the RFCs (reflecting the internet tradition of being liberal in what is accepted). For example the function:
Accepts a single-digit value where appropriate in place of a two-digit value with a leading zero (so
"Wed 1 Jun" is acceptable in place of "Wed 01 Jun",
Accepts one or more whitespace characters (x20, x09, x0A, x0D) wherever a single space is required, and allows whitespace to be omitted where it is not required for parsing
Accepts and ignores whitespace characters (x20, x09, x0A, x0D) at the start or end of the string.
In new protocols IETF recommends the format of
An fn:format-dateTime with a picture
string of "[FNn3], [D01] [MNn3] [Y04] [H01]:[m01]:[s01] [Z0000]".
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.
If $qname is the empty sequence, returns the empty sequence.
More specifically, the function searches the namespace bindings of $element
for a binding whose name matches the prefix of $qname, or the zero-length
string if it has no prefix, and returns 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 binding.
If the $qname has no prefix, and there is no namespace binding for
$element corresponding to the default (unnamed) namespace, then the
resulting expanded-QName has no namespace part.
The prefix (or absence of a prefix) in the supplied $qname argument is
retained in the returned expanded-QName, as described in
A dynamic error is raised $qname does
not have the correct lexical form for an instance of xs:QName.
A dynamic error is raised $qname has
a prefix and there is no namespace binding for $element that matches this
prefix.
Sometimes the requirement is to construct an xs:QName without using the
default namespace. This can be achieved by writing:
If the requirement is to construct an xs:QName using the namespaces in the
static context, then the xs:QName constructor should be used.
Assume that the element bound to $element has a single namespace binding
bound to the prefix eg.
fn:resolve-QName("hello", $element) returns a QName with local name
"hello" that is in no namespace.
fn:resolve-QName("eg:myFunc", $element) returns an xs:QName
whose namespace URI is specified by the namespace binding corresponding to the prefix
"eg" and whose local name is "myFunc".
Returns an xs:QName value formed using a supplied namespace URI and lexical QName.
The namespace URI in the returned QName is taken from $paramURI. If
$paramURI is the zero-length string or the empty sequence, it represents
"no namespace".
The prefix (or absence of a prefix) in $paramQName is retained in the
returned xs:QName value.
The local name in the result is taken from the local part of
$paramQName.
A dynamic error is raised $paramQName
does not have the correct lexical form for an instance of xs:QName.
A dynamic error is raised $paramURI
is the zero-length string or the empty sequence, and the value of
$paramQName contains a colon (:).
A dynamic error $paramURI is not a valid URI (XML Namespaces 1.0) or IRI (XML Namespaces
1.1).
fn:QName("http://www.example.com/example", "person") returns an
xs:QName with namespace URI = "http://www.example.com/example", local
name = "person" and prefix = "".
fn:QName("http://www.example.com/example", "ht:person") returns an
xs:QName with namespace URI = "http://www.example.com/example", local
name = "person" and prefix = "ht".
xs:QName. Returns true if two supplied QNames have the same namespace URI and the
same local part.
The function returns true if the namespace URIs of $arg1 and
$arg2 are equal and the local names of $arg1 and
$arg2 are equal.
Otherwise, the function returns false.
The namespace URI parts are considered equal if they are both fn:codepoint-equal function.
The local parts are also compared under the rules of the fn:codepoint-equal
function.
The prefix parts of $arg1 and $arg2, if any, are ignored.
Returns the prefix component of the supplied QName.
If $arg is the empty sequence the function returns the empty sequence.
If $arg has no prefix component the function returns the empty
sequence.
Otherwise, the function returns an xs:NCName representing the prefix
component of $arg.
Returns the local part of the supplied QName.
If $arg is the empty sequence the function returns the empty sequence.
Otherwise, the function returns an xs:NCName representing the local part of
$arg.
Returns the namespace URI part of the supplied QName.
If $arg is the empty sequence the function returns the empty sequence.
Otherwise, the function returns an xs:anyURI representing the namespace URI
part of $arg.
If $arg is in no namespace, the function returns the zero-length
xs:anyURI.
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, the function returns the namespace URI of that namespace.
If $element has no in-scope namespace whose namespace prefix is equal to
$prefix, the function returns the empty sequence.
If $prefix is the zero-length string or the empty sequence, then if
$element has a default namespace (that is, a namespace node with no
name), the function returns the namespace URI of the default namespace. If
$element has no default namespace, the function returns the empty
sequence.
Prefixes are equal only if their Unicode codepoints match exactly.
Returns the prefixes of the in-scope namespaces for an element node.
The function returns a sequence of strings representing the prefixes of the in-scope
namespaces for $element.
For namespace bindings that have a prefix, the function returns the prefix as an
xs:NCName. For the default namespace, which has no prefix, it returns
the zero-length string.
The result sequence contains no duplicates.
The ordering of the result sequence is
The XML namespace is in scope for every element, so the result will always include the string "xml".
xs:hexBinary
values.Returns true if two xs:hexBinary values contain the same octet
sequence.
The function returns true if $value1 and $value2
are of the same length, measured in binary octets, and contain the same octets in the
same order. Otherwise, it returns false.
xs:hexBinary values. Also used in the
definition of the "ge" operator.Returns true if the first argument is less than the second.
The function returns true if any of the following conditions is true:
$arg1 is zero-length (contains no octets) and $arg2 is
not zero-length.
Neither argument is zero-length, and the first octet of $arg1 is less
than the first octet of $arg2, treating the value of the octet as an
unsigned integer in the range 0 to 255.
Neither argument is zero-length, the first octet of $arg1 is equal to
the first octet of $arg2, and the xs:hexBinary value
formed by taking all octets of arg1 after the first is less than the
xs:hexBinary value formed by taking all octets of
arg2 after the first.
Otherwise, the function returns false.
xs:hexBinary values. Also used in the
definition of the "le" operator.Returns true if the first argument is greater than the second.
The function call op:hexBinary-greater-than($A, $B) is defined to return
the same result as op:hexBinary-less-than($B, $A)
xs:base64Binary
values.Returns true if two xs:base64Binary values contain the same octet
sequence.
The function returns true if $value1 and $value2
are of the same length, measured in binary octets, and contain the same octets in the
same order. Otherwise, it returns false.
xs:base64Binary values. Also used in
the definition of the "ge" operator.Returns true if the first argument is less than the second.
The function returns true if any of the following conditions is true:
$arg1 is zero-length (contains no octets) and $arg2 is
not zero-length.
Neither argument is zero-length, and the first octet of $arg1 is less
than the first octet of $arg2, treating the value of the octet as an
unsigned integer in the range 0 to 255.
Neither argument is zero-length, the first octet of $arg1 is equal to
the first octet of $arg2, and the xs:base64Binary value
formed by taking all octets of arg1 after the first is less than the
xs:base64Binary value formed by taking all octets of
arg2 after the first.
Otherwise, the function returns false.
xs:base64Binary values. Also used in
the definition of the "le" operator.Returns true if the first argument is greater than the second.
The function call op:base64Binary-greater-than($A, $B) is defined to return
the same result as op:base64Binary-less-than($B, $A)
xs:NOTATION. Returns true if the two xs:NOTATION values have the same
namespace URI and the same local part.
The function returns true if the namespace URIs of $arg1 and
$arg2 are equal and the local names of $arg1 and
$arg2 are equal.
Otherwise, the function returns false.
The namespace URI parts are considered equal if they are both fn:codepoint-equal function.
The local parts are also compared under the rules of the fn:codepoint-equal
function.
The prefix parts of $arg1 and $arg2, if any, are ignored.
Returns the name of a node, as an xs:string that is either the zero-length
string, or has the lexical form of an xs:QName.
If the argument is omitted, it defaults to the context item (.). The
behavior of the function if the argument is omitted is exactly the same as if the
context item had been passed as the argument.
If the argument is supplied and is the empty sequence, the function returns the zero-length string.
If the node identified by $arg has no name (that is, if it is a document
node, a comment, a text node, or a namespace node having no name), the function returns
the zero-length string.
Otherwise, the function returns the value of the expression
fn:string(fn:node-name($arg)).
The following errors may be raised when $arg is omitted:
If the context item is
If the context item is not a node, type error
Because the result depends on the choice of namespace prefixes in the source document,
it is not good practice to use the result of this function for anything other than display
purposes. For example, the test name(.) = 'my:profile' will fail if the source
document uses an unexpected namespace prefix. Such a test (assuming it relates to an element node)
is better written as boolean(self::my:profile).
Returns the local part of the name of $arg as an xs:string
that is either the zero-length string, or has the lexical form of an
xs:NCName.
If the argument is omitted, it defaults to the context item (.). The
behavior of the function if the argument is omitted is exactly the same as if the
context item had been passed as the argument.
If the argument is supplied and is the empty sequence, the function returns the zero-length string.
If the node identified by $arg has no name (that is, if it is a document
node, a comment, a text node, or a namespace node having no name), the function returns
the zero-length string.
Otherwise, the function returns the local part of the expanded-QName of the node
identified by $arg, as determined by the dm:node-name accessor
defined in xs:string whose lexical form is an xs:NCName.
The following errors may be raised when $arg is omitted:
If the context item is
If the context item is not a node, type error
Returns the namespace URI part of the name of $arg, as an
xs:anyURI value.
If the argument is omitted, it defaults to the context node (.). The
behavior of the function if the argument is omitted is exactly the same as if the
context item had been passed as the argument.
If the node identified by $arg is neither an element nor an attribute node,
or if it is an element or attribute node whose expanded-QName (as determined by the
dm:node-name accessor in the xs:anyURI
value.
Otherwise, the result will be the namespace URI part of the expanded-QName of the node
identified by $arg, as determined by the dm:node-name accessor
defined in xs:anyURI value.
The following errors may be raised when $arg is omitted:
If the context item is
If the context item is not a node, type error
Returns the value indicated by $arg or, if $arg is not
specified, the context item after atomization, converted to an xs:double.
Calling the zero-argument version of the function is defined to give the same result as
calling the single-argument version with the context item (.). That is,
fn:number() is equivalent to fn:number(.), as defined by
the rules that follow.
If $arg is the empty sequence or if $arg cannot be converted
to an xs:double, the xs:double value NaN is
returned.
Otherwise, $arg is converted to an xs:double following the
rules of xs:double
fails, the xs:double value NaN is returned.
A dynamic error is raised $arg is omitted and the context item is
As a consequence of the rules given above, a type error occurs if the context item cannot be atomized, or if the result of atomizing the context item is a sequence containing more than one atomic value.
XSD 1.1 allows the string +INF as a representation of positive infinity;
XSD 1.0 does not. It is
Generally fn:number returns NaN rather than raising a dynamic
error if the argument cannot be converted to xs:double. However, a type
error is raised in the usual way if the supplied argument cannot be atomized or if the
result of atomization does not match the required argument type.
Assume that the context item is the xs:string value "15".
Then fn:number() returns 1.5e1.
This function tests whether the language of $node, or the context item if
the second argument is omitted, as specified by xml:lang attributes is the
same as, or is a sublanguage of, the language specified by $testlang.
The behavior of the function if the second argument is omitted is exactly the same as if
the context item (.) had been passed as the second argument.
The language of the argument $node, or the context item if the second
argument is omitted, is determined by the value of the xml:lang attribute
on the node, or, if the node has no such attribute, by the value of the
xml:lang attribute on the nearest ancestor of the node that has an
xml:lang attribute. If there is no such ancestor, then the function
returns false.
If $testlang is the empty sequence it is interpreted as the zero-length
string.
The relevant xml:lang attribute is determined by the value of the XPath
expression:
If this expression returns an empty sequence, the function returns false.
Otherwise, the function returns true if and only if, based on a caseless
default match as specified in section 3.13 of
$testlang is equal to the string-value of the relevant
xml:lang attribute, or
$testlang is equal to some substring of the string-value of the
relevant xml:lang attribute that starts at the start of the
string-value and ends immediately before a hyphen, "-" (the character "-" is
HYPHEN-MINUS, #x002D).
The following errors may be raised when $arg is omitted:
If the context item is
If the context item is not a node, type error
The expression fn:lang("en") would return true if the
context node were any of the following four elements:
<para xml:lang="en"/>
<div xml:lang="en"><para>And now, and
forever!</para></div>
<para xml:lang="EN"/>
<para xml:lang="en-us"/>
The expression fn:lang("fr") would return false if the
context node were <para xml:lang="EN"/>
Returns a path expression that can be used to select the supplied node relative to the root of its containing document.
The behavior of the function if the argument is omitted is exactly the same as if the
context item (.) had been passed as the argument.
If $arg is the empty sequence, the function returns the empty sequence.
If $arg is a document node, the function returns the string
"/".
Otherwise, the function returns a string that consists of a sequence of steps, one
for each ancestor-or-self of $arg other than the root node. This string is
prefixed by "Q{http://www.w3.org/2005/xpath-functions}root()" if the root
node is not a document node. Each step consists of the character "/"
followed by a string whose form depends on the kind of node selected by that step, as
follows:
For an element node,
Q{,
where
For an attribute node:
if the node is in no namespace, @, where
otherwise, @Q{, where
For a text node: text()[ where
For a comment node: comment()[ where
For a processing-instruction node:
processing-instruction(
where
For a namespace node:
If the namespace node has a name:
namespace::, where
If the namespace node has no name (that is, it represents the default
namespace):
namespace::*[Q{http://www.w3.org/2005/xpath-functions}local-name()=""]
The following errors may be raised when $arg is omitted:
If the context item is
If the context item is not a node, type error
Returns the root of the tree to which $arg belongs. This will usually, but
not necessarily, be a document node.
If the function is called without an argument, the context item (.) is used
as the default argument. The behavior of the function if the argument is omitted is
exactly the same as if the context item had been passed as the argument.
The function returns the value of the expression
($arg/ancestor-or-self::node())[1].
The following errors may be raised when $arg is omitted:
If the context item is
If the context item is not a node, type error
These examples use some variables which could be defined in
Or they could be defined in
fn:root($i) returns the element node $i
fn:root($o/quantity) returns the element node $o
fn:root($odoc//quantity) returns the document node $odoc
fn:root($newi) returns the element node $o
The final three examples could be made type-safe by wrapping their operands with
fn:exactly-one().
Returns true if the supplied node has one or more child nodes (of any kind).
If the argument is omitted, it defaults to the context item (.). The
behavior of the function if the argument is omitted is exactly the same as if the
context item had been passed as the argument.
Provided that the supplied argument $node matches the expected type
node()?, the result of the function call
fn:has-children($node) is defined to be the same as the result of the
expression fn:exists($node/child::node()).
The following errors may be raised when $node is omitted:
If the context item is
If the context item is not a node, type error
If $node is an empty sequence the result is false.
The motivation for this function is to support streamed evaluation. According to the
streaming rules in
This is because it makes two downward selections to read the child row
elements. The use of fn:has-children in the xsl:if conditional
is intended to circumvent this restriction.
Although the function was introduced to support streaming use cases, it has general utility as a convenience function.
Returns every node within the input sequence that is not an ancestor of another member of the input sequence; the nodes are returned in document order with duplicates eliminated.
The effect of the function call fn:innermost($nodes) is defined to be
equivalent to the result of the expression:
That is, the function takes as input a sequence of nodes, and returns every node within the sequence that is not an ancestor of another node within the sequence; the nodes are returned in document order with duplicates eliminated.
If the source document contains nested sections represented by div
elements, the expression innermost(//div) returns those div
elements that do not contain further div elements.
Returns every node within the input sequence that has no ancestor that is itself a member of the input sequence; the nodes are returned in document order with duplicates eliminated.
The effect of the function call fn:outermost($nodes) is defined to be
equivalent to the result of the expression:
That is, the function takes as input a sequence of nodes, and returns every node within the sequence that does not have another node within the sequence as an ancestor; the nodes are returned in document order with duplicates eliminated.
The formulation $nodes except $nodes/descendant::node() might appear to be
simpler, but does not correctly account for attribute nodes, as these are not
descendants of their parent element.
The motivation for the function was based on XSLT streaming use cases. There are cases
where the outermost(//section) but do not allow //section; the
function can therefore be useful in cases where it is known that sections will not be
nested, as well as cases where the application actually wishes to process all sections
except those that are nested within another.
If the source document contains nested sections represented by div
elements, the expression outermost(//div) returns those div
elements that are not contained within further div elements.
Returns a sequence of positive integers giving the positions within the sequence
$seq of items that are equal to $search.
The function returns a sequence of positive integers giving the positions within the
sequence $seq of items that are equal to $search.
The collation used by this function is determined according to the rules in
The items in the sequence $seq are compared with $search under
the rules for the eq operator. Values of type xs:untypedAtomic
are compared as if they were of type xs:string. Values that cannot be
compared, because the eq operator is not defined for their types, are
considered to be distinct. If an item compares equal, then the position of that item in
the sequence $seq is included in the result.
The first item in a sequence is at position 1, not position 0.
The result sequence is in ascending numeric order.
If the value of $seq is the empty sequence, or if no item in
$seq matches $search, then the function returns the empty
sequence.
No error occurs if non-comparable values are encountered. So when comparing two atomic
values, the effective boolean value of fn:index-of($a, $b) is true if
$a and $b are equal, false if they are not equal or not
comparable.
If @a is an attribute of type xs:NMTOKENS whose string
value is "red green blue", and whose typed value is therefore
("red", "green", "blue"), then fn:index-of(@a, "blue")
returns 3. This is because the function calling mechanism atomizes the
attribute node to produce a sequence of three xs:NMTOKEN values.
Returns true if the argument is the empty sequence.
If the value of $arg is the empty sequence, the function returns
true; otherwise, the function returns false.
Assuming $in is an element with no children:
The result is false().
Returns true if the argument is a non-empty sequence.
If the value of $arg is a non-empty sequence, the function returns
true; otherwise, the function returns false.
Assuming $in is an element with no children:
The result is true().
Returns the values that appear in a sequence, with duplicates eliminated.
The function returns the sequence that results from removing from $arg all
but one of a set of values that are considered equal to one another.
fn:deep-equal($J, $K, $coll) is true,
where $coll is the collation selected according to the rules in
The order in which the sequence of values is returned is
Which value of a set of values that compare equal is returned is
If the input sequence contains values of different numeric types that differ from each
other by small amounts, then the eq operator is not transitive, because of rounding
effects occurring during type promotion. In the situation where the input contains three
values A, B, and C such that A eq B,
B eq C, but A ne C, then the number of items in the result
of the function (as well as the choice of which items are returned) is
For example, this arises when computing:
because the values of type xs:float and xs:double both compare
equal to the value of type xs:decimal but not equal to each other.
If $arg is the empty sequence, the function returns the empty sequence.
Values of type xs:untypedAtomic are compared as if they were of type
xs:string.
Values that cannot be compared, because the eq operator is not defined for
their types, are considered to be distinct.
For xs:float and xs:double values, positive zero is equal to
negative zero and, although NaN does not equal itself, if $arg
contains multiple NaN values a single NaN is returned.
If xs:dateTime, xs:date or xs:time values do not
have a timezone, they are considered to have the implicit timezone provided by the
dynamic context for the purpose of comparison. Note that xs:dateTime,
xs:date or xs:time values can compare equal even if their
timezones are different.
xs:integer 2 or the xs:decimal 2.0Returns a sequence constructed by inserting an item or a sequence of items at a given position within an existing sequence.
The value returned by the function consists of all items of $target whose
index is less than $position, followed by all items of
$inserts, followed by the remaining elements of $target, in
that order.
If $target is the empty sequence, $inserts is returned. If
$inserts is the empty sequence, $target is returned.
If $position is less than one (1), the first position, the effective value
of $position is one (1). If $position is greater than the
number of items in $target, then the effective value of
$position is equal to the number of items in $target plus
1.
The value of $target is not affected by the sequence construction.
Returns a new sequence containing all the items of $target except the item
at position $position.
The function returns a sequence consisting of all items of $target whose
index is less than $position, followed by all items of $target
whose index is greater than $position.
If $position is less than 1 or greater than the number of items in
$target, $target is returned.
If $target is the empty sequence, the empty sequence is returned.
Returns the first item in a sequence.
The function returns the value of the expression $arg[1]
If $arg is the empty sequence, the empty sequence is returned. Otherwise
the first item in the sequence is returned.
Returns all but the first item in a sequence.
The function returns the value of the expression subsequence($arg, 2)
If $arg is the empty sequence, or a sequence containing a single item, then
the empty sequence is returned.
Reverses the order of items in a sequence.
The function returns a sequence containing the items in $arg in reverse
order.
If $arg is the empty sequence, the empty sequence is returned.
Returns the contiguous sequence of items in the value of $sourceSeq
beginning at the position indicated by the value of $startingLoc and
continuing for the number of items indicated by the value of $length.
In the two-argument case, returns:
In the three-argument case, returns:
The first item of a sequence is located at position 1, not position 0.
If $sourceSeq is the empty sequence, the empty sequence is returned.
In the two-argument case, the function returns a sequence comprising those items of $sourceSeq whose index position (counting from one)
is greater than or equal to the value of $startingLoc (rounded to an integer). No error occurs if $startingLoc is
zero or negative.
In the three-argument case, The function returns a sequence comprising those items of $sourceSeq whose index position (counting from one)
is greater than or equal to the value of $startingLoc (rounded to an integer), and
less than the sum of $startingLoc and $length (both rounded to integers). No error occurs if $startingLoc is
zero or negative, or if $startingLoc plus $length exceeds the number of items in the sequence, or if
$length is negative.
As a consequence of the general rules, if $startingLoc is
-INF and $length is +INF, then
fn:round($startingLoc) + fn:round($length) is NaN; since
position() lt NaN is always false, the result is an empty sequence.
The reason the function accepts arguments of type xs:double is that many
computations on untyped data return an xs:double result; and the reason for
the rounding rules is to compensate for any imprecision in these floating-point
computations.
Returns the items of $sourceSeq in an
The function returns the items of $sourceSeq in an
Query optimizers may be able to do a better job if the order of the output sequence is not specified. For example, when retrieving prices from a purchase order, if an index exists on prices, it may be more efficient to return the prices in index order rather than in document order.
Returns $arg if it contains zero or one items. Otherwise, raises an
error.
Except in error cases, the function returns $arg unchanged.
A dynamic error is raised $arg
contains more than one item.
Returns $arg if it contains one or more items. Otherwise, raises an error.
Except in error cases, the function returns $arg unchanged.
A dynamic error is raised $arg is an
empty sequence.
Returns $arg if it contains exactly one item. Otherwise, raises an error.
Except in error cases, the function returns $arg unchanged.
A dynamic error is raised $arg is an
empty sequence or a sequence containing more than one item.
This function assesses whether two sequences are deep-equal to each other. To be
deep-equal, they must contain items that are pairwise deep-equal; and for two items to
be deep-equal, they must either be atomic values that compare equal, or nodes of the
same kind, with the same name, whose children are deep-equal
The $collation argument identifies a collation which is used at all levels
of recursion when strings are compared (but not when names are compared), according to
the rules in
If the two sequences are both empty, the function returns true.
If the two sequences are of different lengths, the function returns
false.
If the two sequences are of the same length, the function returns true if
and only if every item in the sequence $parameter1 is deep-equal to the
item at the same position in the sequence $parameter2. The rules for
deciding whether two items are deep-equal follow.
Call the two items $i1 and $i2 respectively.
If $i1 and $i2 are both atomic values, they are deep-equal if
and only if ($i1 eq $i2) is true, or if both values are
NaN. If the eq operator is not defined for $i1
and $i2, the function returns false.
If one of the pair $i1 or $i2 is an atomic
value and the other is not, false.
If $i1 and $i2 are both true if and only if all the
following conditions apply:
Both maps have the same number of entries.
For every entry in the first map, there is an entry in the second map that:
has the
has the same associated value (compared using the fn:deep-equal
function, under the collation supplied in the original call to
fn:deep-equal).
If $i1 and $i2 are both true if and only if all
the following conditions apply:
Both arrays have the same number of members (array:size($i1) eq
array:size($i2)).
Members in the same position of both arrays are deep-equal to each other, under
the collation supplied in the original call to fn:deep-equal: that is,
every $p in 1 to array:size($i1) satisfies deep-equal($i1($p), $i2($p),
$collation)
If $i1 and $i2 are both nodes, they are compared as described
below:
If the two nodes are of different kinds, the result is false.
If the two nodes are both document nodes then they are deep-equal if and only if
the sequence $i1/(*|text()) is deep-equal to the sequence
$i2/(*|text()).
If the two nodes are both element nodes then they are deep-equal if and only if all of the following conditions are satisfied:
The two nodes have the same name, that is (node-name($i1) eq
node-name($i2)).
Either both nodes are annotated as having simple content or both nodes are annotated as having complex content. For this purpose "simple content" means either a simple type or a complex type with simple content; "complex content" means a complex type whose variety is mixed, element-only, or empty.
It is a consequence of this rule that validating a document D against a schema will usually (but not necessarily) result in a document that is not deep-equal to D. The exception is when the schema allows all elements to have mixed content.
The two nodes have the same number of attributes, and for every attribute
$a1 in $i1/@* there exists an attribute
$a2 in $i2/@* such that $a1 and
$a2 are deep-equal.
One of the following conditions holds:
Both element nodes are annotated as having simple content (as defined
in 3(b) above), and the typed value of $i1 is deep-equal
to the typed value of $i2.
Both element nodes have a type annotation that is a complex type with
variety element-only, and the sequence $i1/* is
deep-equal to the sequence $i2/*.
Both element nodes have a type annotation that is a complex type with
variety mixed, and the sequence $i1/(*|text()) is
deep-equal to the sequence $i2/(*|text()).
Both element nodes have a type annotation that is a complex type with variety empty.
If the two nodes are both attribute nodes then they are deep-equal if and only if both the following conditions are satisfied:
The two nodes have the same name, that is (node-name($i1) eq
node-name($i2)).
The typed value of $i1 is deep-equal to the typed value of
$i2.
If the two nodes are both processing instruction nodes, then they are deep-equal if and only if both the following conditions are satisfied:
The two nodes have the same name, that is (node-name($i1) eq
node-name($i2)).
The string value of $i1 is equal to the string value of
$i2.
If the two nodes are both namespace nodes, then they are deep-equal if and only if both the following conditions are satisfied:
The two nodes either have the same name or are both nameless, that is
fn:deep-equal(node-name($i1), node-name($i2)).
The string value of $i1 is equal to the string value of
$i2 when compared using the Unicode codepoint collation.
If the two nodes are both text nodes or comment nodes, then they are deep-equal if and only if their string-values are equal.
In all other cases the result is false.
A type error is raised
The two nodes are not required to have the same type annotation, and they are not
required to have the same in-scope namespaces. They may also differ in their parent,
their base URI, and the values returned by the is-id and
is-idrefs accessors (see
The contents of comments and processing instructions are significant only if these nodes appear directly as items in the two sequences being compared. The content of a comment or processing instruction that appears as a descendant of an item in one of the sequences being compared does not affect the result. However, the presence of a comment or processing instruction, if it causes a text node to be split into two text nodes, may affect the result.
Comparing items of different kind (for example, comparing an atomic
value to a node, or a map to an array, or an integer to an xs:date) returns false, it does not return an error. So
the result of fn:deep-equal(1, current-dateTime()) is false.
Comparing a function (other than a map or array) to any other value raises a type error.
Returns the number of items in a sequence.
The function returns the number of items in the value of $arg.
Returns 0 if $arg is the empty sequence.
Returns the average of the values in the input sequence $arg, that is, the
sum of the values divided by the number of values.
If $arg is the empty sequence, the empty sequence is returned.
If $arg contains values of type xs:untypedAtomic they are cast
to xs:double.
Duration values must either all be xs:yearMonthDuration values or must all
be xs:dayTimeDuration values. For numeric values, the numeric promotion
rules defined in $arg must satisfy the following condition:
There must be a type T such that:
$arg is an instance of T.xs:double, xs:float,
xs:decimal, xs:yearMonthDuration, or
xs:dayTimeDuration.The function returns the average of the values as sum($arg) div
count($arg); but the implementation may use an otherwise equivalent algorithm
that avoids arithmetic overflow.
A type error is raised
xs:decimal.fn:avg(($d1, $seq3)) raises a type error
Returns a value that is equal to the highest value appearing in the input sequence.
The following conversions are applied to the input sequence $arg, in order:
Values of type xs:untypedAtomic in $arg are cast to
xs:double.
If the resulting sequence contains values that are instances of more than one primitive type
(meaning the 19 primitive types defined in
If each value is an instance of one of the types xs:string or xs:anyURI,
then all the values are cast to type xs:string.
If each value is an instance of one of the types xs:decimal or xs:float,
then all the values are cast to type xs:float.
If each value is an instance of one of the types xs:decimal, xs:float,
or xs:double, then all the values are cast to type xs:double.
Otherwise, a type error is raised
The primitive type of an xs:integer value for this purpose is xs:decimal.
The items in the resulting sequence may be reordered in an arbitrary order. The resulting sequence is referred to below as the converted sequence. The function returns an item from the converted sequence rather than the input sequence.
If the converted sequence is empty, the function returns the empty sequence.
All items in the converted sequence must be derived from a single base type for which
the le operator is defined. In addition, the values in the sequence must
have a total order. If date/time values do not have a timezone, they are considered to
have the implicit timezone provided by the dynamic context for the purpose of
comparison. Duration values must either all be xs:yearMonthDuration values
or must all be xs:dayTimeDuration values.
If the converted sequence contains the value NaN, the value
NaN is returned
xs:float or xs:double as appropriate)
If the items in the converted sequence are of type xs:string or types
derived by restriction from xs:string, then the determination of the item
with the smallest value is made according to the collation that is used. If the type of
the items in the converted sequence is not xs:string and
$collation is specified, the collation is ignored.
The collation used by this function is determined according to the rules in
The function returns the result of the expression:
evaluated with $collation as the default collation if specified, and with
$c as the converted sequence.
A type error is raised
Because the rules allow the sequence to be reordered, if there are two or more items that are
"equal highest", the specific item whose value is returned is xs:dateTime
values compare equal despite being in different timezones.
If the converted sequence contains exactly one value then that value is returned.
The default type when the fn:max function is applied to
xs:untypedAtomic values is xs:double. This differs from the
default type for operators such as gt, and for sorting in XQuery and XSLT,
which is xs:string.
The rules for the dynamic type of the result are stricter in version 3.1 of the specification than
in earlier versions. For example, if all the values in the input sequence belong to types derived from
xs:integer, version 3.0 required only that the result be an instance
of the least common supertype of the types present in the input sequence; Version 3.1
requires that the returned value retains its original type. This does not apply, however, where type promotion
is needed to convert all the values to a common primitive type.
fn:max((3,4,"Zero")) raises a type error
Returns a value that is equal to the lowest value appearing in the input sequence.
The following rules are applied to the input sequence:
Values of type xs:untypedAtomic in $arg are cast to
xs:double.
If the resulting sequence contains values that are instances of more than one primitive type
(meaning the 19 primitive types defined in
If each value is an instance of one of the types xs:string or xs:anyURI,
then all the values are cast to type xs:string.
If each value is an instance of one of the types xs:decimal or xs:float,
then all the values are cast to type xs:float.
If each value is an instance of one of the types xs:decimal, xs:float,
or xs:double, then all the values are cast to type xs:double.
Otherwise, a type error is raised
The primitive type of an xs:integer value for this purpose is xs:decimal.
The items in the resulting sequence may be reordered in an arbitrary order. The resulting sequence is referred to below as the converted sequence. The function returns an item from the converted sequence rather than the input sequence.
If the converted sequence is empty, the empty sequence is returned.
All items in the converted sequence must be derived from a single base type for which
the le operator is defined. In addition, the values in the sequence must
have a total order. If date/time values do not have a timezone, they are considered to
have the implicit timezone provided by the dynamic context for the purpose of
comparison. Duration values must either all be xs:yearMonthDuration values
or must all be xs:dayTimeDuration values.
If the converted sequence contains the value NaN, the value
NaN is returned
xs:float or xs:double as appropriate)
If the items in the converted sequence are of type xs:string or types
derived by restriction from xs:string, then the determination of the item
with the smallest value is made according to the collation that is used. If the type of
the items in the converted sequence is not xs:string and
$collation is specified, the collation is ignored.
The collation used by this function is determined according to the rules in
The function returns the result of the expression:
evaluated with $collation as the default collation if specified, and with
$c as the converted sequence.
A type error is raised
Because the rules allow the sequence to be reordered, if there are two or items that are
"equal lowest", the specific item whose value is returned is xs:dateTime
values compare equal despite being in different timezones.
If the converted sequence contains exactly one value then that value is returned.
The default type when the fn:min function is applied to
xs:untypedAtomic values is xs:double. This differs from the
default type for operators such as lt, and for sorting in XQuery and XSLT,
which is xs:string.
The rules for the dynamic type of the result are stricter in version 3.1 of the specification than
in earlier versions. For example, if all the values in the input sequence belong to types derived from
xs:integer, version 3.0 required only that the result be an instance
of the least common supertype of the types present in the input sequence; Version 3.1
requires that the returned value retains its original type. This does not apply, however, where type promotion
is needed to convert all the values to a common primitive type.
fn:min((3,4,"Zero")) raises a type error
fn:min((xs:float(0.0E0), xs:float(-0.0E0))) can return either positive
or negative zero. The two items are equal, so it is
Returns a value obtained by adding together the values in $arg.
Any values of type xs:untypedAtomic in $arg are cast to
xs:double. The items in the resulting sequence may be reordered in an
arbitrary order. The resulting sequence is referred to below as the converted
sequence.
If the converted sequence is empty, then the single-argument form of the function
returns the xs:integer value 0; the two-argument form returns
the value of the argument $zero.
If the converted sequence contains the value NaN, NaN is
returned.
All items in $arg must be numeric or derived from a single base type. In
addition, the type must support addition. Duration values must either all be
xs:yearMonthDuration values or must all be
xs:dayTimeDuration values. For numeric values, the numeric promotion
rules defined in xs:double will be an
xs:double.
The result of the function, using the second signature, is the result of the expression:
where $c is the converted sequence.
The result of the function, using the first signature, is the result of the expression:
fn:sum($arg, 0).
A type error is raised
The second argument allows an appropriate value to be defined to represent the sum of an empty sequence. For example, when summing a sequence of durations it would be appropriate to return a zero-length duration of the appropriate type. This argument is necessary because a system that does dynamic typing cannot distinguish "an empty sequence of integers", for example, from "an empty sequence of durations".
If the converted sequence contains exactly one value then that value is returned.
fn:sum(($d1, 9E1)) raises a type error
$zero value should be
the same type as the items in $arg, or even that it should belong to
a type that supports addition.Returns the sequence of element nodes that have an ID value matching the
value of one or more of the IDREF values supplied in $arg.
The function returns a sequence, in document order with duplicates eliminated,
containing every element node E that satisfies all the following
conditions:
E is in the target document. The target document is the document
containing $node, or the document containing the context item
(.) if the second argument is omitted. The behavior of the
function if $node is omitted is exactly the same as if the context
item had been passed as $node.
E has an ID value equal to one of the candidate
IDREF values, where:
An element has an ID value equal to V if either
or both of the following conditions are true:
The is-id property (See V under the rules of the
eq operator using the Unicode codepoint collation
(http://www.w3.org/2005/xpath-functions/collation/codepoint).
The element has an attribute node whose is-id property
(See V under the rules of the
eq operator using the Unicode code point collation
(http://www.w3.org/2005/xpath-functions/collation/codepoint).
Each xs:string in $arg is parsed as if it were of
type IDREFS, that is, each xs:string in
$arg is treated as a whitespace-separated sequence of
tokens, each acting as an IDREF. These tokens are then included
in the list of candidate IDREFs. If any of the tokens is not a
lexically valid IDREF (that is, if it is not lexically an
xs:NCName), it is ignored. Formally, the candidate
IDREF values are the strings in the sequence given by the
expression:
If several elements have the same ID value, then E is
the one that is first in document order.
A dynamic error is raised $node, or the context item if the second argument is absent, is a node
in a tree whose root is not a document node.
The following errors may be raised when $node is omitted:
If the context item is
If the context item is not a node, type error
The effect of this function is anomalous in respect of element nodes with the
is-id property. For legacy reasons, this function returns the element
that has the is-id property, whereas it would be more appropriate to return
its parent, that being the element that is uniquely identified by the ID. A new function
fn:element-with-id has been introduced with the desired
behavior.
If the data model is constructed from an Infoset, an attribute will have the
is-id property if the corresponding attribute in the Infoset had an
attribute type of ID: typically this means the attribute was declared as an
ID in a DTD.
If the data model is constructed from a PSVI, an element or attribute will have the
is-id property if its typed value is a single atomic value of type
xs:ID or a type derived by restriction from xs:ID.
No error is raised in respect of a candidate IDREF value that does not
match the ID of any element in the document. If no candidate
IDREF value matches the ID value of any element, the
function returns the empty sequence.
It is not necessary that the supplied argument should have type xs:IDREF
or xs:IDREFS, or that it should be derived from a node with the
is-idrefs property.
An element may have more than one ID value. This can occur with synthetic
data models or with data models constructed from a PSVI where the element and one of its
attributes are both typed as xs:ID.
If the source document is well-formed but not valid, it is possible for two or more
elements to have the same ID value. In this situation, the function will
select the first such element.
It is also possible in a well-formed but invalid document to have an element or
attribute that has the is-id property but whose value does not conform to
the lexical rules for the xs:ID type. Such a node will never be selected by
this function.
xml:id attribute has the is-id property,
so the employee element is selected.empnr element is given the type
xs:ID as a result of schema validation, the element will have the
is-id property and is therefore selected. Note the difference from
the behavior of fn:element-with-id. Returns the sequence of element nodes that have an ID value matching the
value of one or more of the IDREF values supplied in $arg.
The effect of this function is identical to fn:id in respect of
elements that have an attribute with the is-id property. However, it
behaves differently in respect of element nodes with the is-id property.
Whereas the fn:id function, for legacy reasons, returns the element that has the
is-id property, this function returns the element identified by the ID,
which is the parent of the element having the is-id property.
The function returns a sequence, in document order with duplicates eliminated,
containing every element node E that satisfies all the following
conditions:
E is in the target document. The target document is the document
containing $node, or the document containing the context item
(.) if the second argument is omitted. The behavior of the
function if $node is omitted is exactly the same as if the context
item had been passed as $node.
E has an ID value equal to one of the candidate
IDREF values, where:
An element has an ID value equal to V if either
or both of the following conditions are true:
The element has an child element node whose is-id
property (See V under the rules of the
eq operator using the Unicode code point collation
(http://www.w3.org/2005/xpath-functions/collation/codepoint).
The element has an attribute node whose is-id property
(See V under the rules of the
eq operator using the Unicode code point collation
(http://www.w3.org/2005/xpath-functions/collation/codepoint).
Each xs:string in $arg is parsed as if it were of
type IDREFS, that is, each xs:string in
$arg is treated as a whitespace-separated sequence of
tokens, each acting as an IDREF. These tokens are then included
in the list of candidate IDREFs. If any of the tokens is not a
lexically valid IDREF (that is, if it is not lexically an
xs:NCName), it is ignored. Formally, the candidate
IDREF values are the strings in the sequence given by the
expression:
If several elements have the same ID value, then E is
the one that is first in document order.
A dynamic error is raised $node, or the context item if the second argument is omitted, is a node
in a tree whose root is not a document node.
The following errors may be raised when $node is omitted:
If the context item is
If the context item is not a node, type error
This function is equivalent to the fn:id function except when dealing with
ID-valued element nodes. Whereas the fn:id function selects the element
containing the identifier, this function selects its parent.
If the data model is constructed from an Infoset, an attribute will have the
is-id property if the corresponding attribute in the Infoset had an
attribute type of ID: typically this means the attribute was declared as an
ID in a DTD.
If the data model is constructed from a PSVI, an element or attribute will have the
is-id property if its typed value is a single atomic value of type
xs:ID or a type derived by restriction from xs:ID.
No error is raised in respect of a candidate IDREF value that does not
match the ID of any element in the document. If no candidate
IDREF value matches the ID value of any element, the
function returns the empty sequence.
It is not necessary that the supplied argument should have type xs:IDREF
or xs:IDREFS, or that it should be derived from a node with the
is-idrefs property.
An element may have more than one ID value. This can occur with synthetic
data models or with data models constructed from a PSVI where the element and one of its
attributes are both typed as xs:ID.
If the source document is well-formed but not valid, it is possible for two or more
elements to have the same ID value. In this situation, the function will
select the first such element.
It is also possible in a well-formed but invalid document to have an element or
attribute that has the is-id property but whose value does not conform to
the lexical rules for the xs:ID type. Such a node will never be selected by
this function.
xml:id attribute has the is-id property,
so the employee element is selected.empnr element is given the type
xs:ID as a result of schema validation, the element will have the
is-id property and is therefore its parent is selected. Note the
difference from the behavior of fn:id.Returns the sequence of element or attribute nodes with an IDREF value
matching the value of one or more of the ID values supplied in
$arg.
The function returns a sequence, in document order with duplicates eliminated,
containing every element or attribute node $N that satisfies all the
following conditions:
$N is in the target document. The target document is the document
containing $node or the document containing the context item
(.) if the second argument is omitted. The behavior of the
function if $node is omitted is exactly the same as if the context
item had been passed as $node.
$N has an IDREF value equal to one of the candidate
ID values, where:
A node $N has an IDREF value equal to
V if both of the following conditions are true:
The is-idrefs property (see $N is true.
The sequence
contains a string that is
equal to V under the rules of the eq
operator using the Unicode code point collation
(http://www.w3.org/2005/xpath-functions/collation/codepoint).
Each xs:string in $arg is parsed as if it were of
lexically of type xs:ID. These xs:strings are then
included in the list of candidate xs:IDs. If any of the strings
in $arg is not a lexically valid xs:ID (that is,
if it is not lexically an xs:NCName), it is ignored. More
formally, the candidate ID values are the strings in the
sequence:
A dynamic error is raised $node, or the context item if the second argument is omitted, is a node
in a tree whose root is not a document node.
The following errors may be raised when $node is omitted:
If the context item is
If the context item is not a node, type error
An element or attribute typically acquires the is-idrefs property by being
validated against the schema type xs:IDREF or xs:IDREFS, or
(for attributes only) by being described as of type IDREF or
IDREFS in a DTD.
Because the function is sensitive to the way in which the data model is constructed, calls on this function are not always interoperable.
No error is raised in respect of a candidate ID value that does not match
the IDREF value of any element or attribute in the document. If no
candidate ID value matches the IDREF value of any element or
attribute, the function returns the empty sequence.
It is possible for two or more nodes to have an IDREF value that matches a
given candidate ID value. In this situation, the function will return all
such nodes. However, each matching node will be returned at most once, regardless how
many candidate ID values it matches.
It is possible in a well-formed but invalid document to have a node whose
is-idrefs property is true but that does not conform to the lexical
rules for the xs:IDREF type. The effect of the above rules is that
ill-formed candidate ID values and ill-formed IDREF values are
ignored.
If the data model is constructed from a PSVI, the typed value of a node that has the
is-idrefs property will contain at least one atomic value of type
xs:IDREF (or a type derived by restriction from xs:IDREF).
It may also contain atomic values of other types. These atomic values are treated as
candidate ID values xs:NCName, and there must be at least one instance of xs:IDREF
in the typed value of the node. If these conditions are not satisfied, such values are ignored.
manager has the is-idref property, the call on fn:idref selects
the manager element. If, instead, the manager had a ref
attribute with the is-idref property, the call on fn:idref would select the attribute node.employee/deputy has the is-idref property, the call on fn:idref selects
the deputy element.Retrieves a document using a URI supplied as an xs:string, and returns the
corresponding document node.
If $uri is the empty sequence, the result is an empty sequence.
If $uri is a relative URI reference, it is resolved relative to the value
of the xs:string.
If the
The URI may include a fragment identifier.
By default, this function is
However, for performance reasons, implementations may provide a user option to evaluate
the function without a guarantee of determinism. The manner in which any such option is
provided is implementation-defined. If the user has not selected such an option, a call
of the function must either return a deterministic result or must raise a dynamic error
If $uri is read from a source document, it is generally appropriate to
resolve it relative to the base URI property of the relevant node in the source
document. This can be achieved by calling the fn:resolve-uri function,
and passing the resulting absolute URI as an argument to the fn:doc
function.
If two calls to this function supply different absolute URI References as arguments, the same document node may be returned if the implementation can determine that the two arguments refer to the same resource.
By defining the semantics of this function in terms of a string-to-document-node
mapping in the dynamic context, the specification is acknowledging that the results of
this function are outside the purview of the language specification itself, and depend
entirely on the run-time environment in which the expression is evaluated. This run-time
environment includes not only an unpredictable collection of resources ("the web"), but
configurable machinery for locating resources and turning their contents into document
nodes within the XPath data model. Both the set of resources that are reachable, and the
mechanisms by which those resources are parsed and validated, are
One possible processing model for this function is as follows. The resource identified
by the URI Reference is retrieved. If the resource cannot be retrieved, a dynamic error
is raised
Various aspects of this processing are
The set of URI schemes that the implementation recognizes is implementation-defined. Implementations may allow the mapping of URIs to resources to be configured by the user, using mechanisms such as catalogs or user-written URI handlers.
The handling of non-XML media types is implementation-defined. Implementations may allow instances of the data model to be constructed from non-XML resources, under user control.
It is
Implementations may provide user-defined error handling options that allow processing to continue following an error in retrieving a resource, or in parsing and validating its content. When errors have been handled in this way, the function may return either an empty sequence, or a fallback document provided by the error handler.
Implementations may provide user options that relax the requirement for the function to return deterministic results.
The effect of a fragment identifier in the supplied URI
is
A dynamic error $uri is not a valid URI
A dynamic error is raised
A dynamic error is raised
A dynamic error is raised
A dynamic error is raised
The function returns true if and only if the function call fn:doc($uri)
would return a document node.
If $uri is an empty sequence, this function returns false.
If a call on fn:doc($uri) would return a document node, this function
returns true.
A dynamic error is raised $uri is not
a valid URI according to the rules applied by the implementation of
fn:doc.
In all other cases this function returns false.
If this function returns true, then calling fn:doc($uri)
within the same fn:doc function,
this guarantee is lost.
Returns a sequence of items identified by a collection URI; or a default collection if no URI is supplied.
This function takes an xs:string as argument and returns a sequence of
$arg as an xs:anyURI and
resolving it according to the mapping specified in
If
If $arg is not specified, the function returns the sequence of
If the value of $arg is a relative xs:anyURI, it is resolved
against the value of the base-URI property from the static context.
If $arg is the empty sequence, the function behaves as if it had been
called without an argument. See above.
By default, this function is
There is no requirement that
A dynamic error is raised
A dynamic error is raised
A dynamic error is raised
A dynamic error $arg is not
a valid xs:anyURI.
In earlier releases, the primary use for the fn:collection function
was to retrieve a collection of XML documents, perhaps held as lexical XML in operating
system filestore, or perhaps held in an XML database. In this release the concept has
been generalised to allow other resources to be retrieved: for example JSON documents might
be returned as arrays or maps, non-XML text files might be returned as strings, and binary
files might be returned as instances of xs:base64Binary.
The abstract concept of a collection might be realized in different ways by different implementations, and the ways in which URIs map to collections can be equally variable. Specifying resources using URIs is useful because URIs are dynamic, can be parameterized, and do not rely on an external environment.
Returns a sequence of xs:anyURI values representing the URIs in a URI
collection.
The zero-argument form of the function returns the URIs in the
If the value of $arg is a relative xs:anyURI, it is resolved
against the value of the base-URI property from the static context.
If $arg is the empty sequence, the function behaves as if it had been
called without an argument. See above.
The single-argument form of the function returns the sequence of URIs corresponding to
the supplied URI in the
By default, this function is
There is no requirement that the URIs returned by this function should all be distinct, and no assumptions can be made about the order of URIs in the sequence, unless the implementation defines otherwise.
A dynamic error is raised
A dynamic error is raised
A dynamic error is raised
A dynamic error $arg is not
a valid xs:anyURI.
In some implementations, there might be a close relationship between fn:collection function), and
Thus, some implementations might ensure that calling fn:uri-collection and then
applying fn:doc to each of the returned URIs delivers the same result as
calling fn:collection with the same argument; however, this is not
guaranteed.
In the case where fn:uri-collection returns the URIs of resources that
could also be retrieved directly using fn:collection, there are several reasons why it
might be appropriate to use this function in preference
to the fn:collection function. For example:
It allows different URIs for different kinds of resource to be dereferenced in
different ways: for
example, the returned URIs might be referenced using the
fn:unparsed-text function rather than the fn:doc
function.
In XSLT 3.0 it allows the documents in a collection to be processed in streaming mode using the
xsl:stream instruction.
It allows recovery from failures to read, parse, or validate individual documents,
by calling the fn:doc (or other dereferencing) function within the scope of try/catch.
It allows selection of which documents to read based on their URI, for example
they can be filtered to select those whose URIs end in .xml, or those
that use the https scheme.
An application might choose to limit the number of URIs processed in a single run, for example it might process only the first 50 URIs in the collection; or it might present the URIs to the user and allow the user to select which of them need to be further processed.
It allows the URIs to be modified before they are dereferenced, for example by adding or removing query parameters, or by redirecting the request to a local cache or to a mirror site.
For some of these use cases, this assumes that the cost of calling
fn:collection might be significant (for example, it might involving
retrieving all the documents in the collection over the network and parsing them). This
will not necessarily be true of all implementations.
The fn:unparsed-text function reads an external resource (for example, a
file) and returns a string representation of the resource.
The $href argument
The mapping of URIs to the string representation of a resource is the mapping defined in
the
If the value of the $href argument is an empty sequence, the function
returns an empty sequence.
The $encoding argument, if present, is the name of an encoding. The values
for this attribute follow the same rules as for the encoding attribute in
an XML declaration. The only values which every utf-8 and utf-16.
The encoding of the external resource is determined as follows:
external encoding information is used if available, otherwise
if the media type of the resource is text/xml or
application/xml (see text/*+xml or application/*+xml (see
the value of the $encoding argument is used if present, otherwise
the processor
UTF-8 is assumed.
The result of the function is a string containing the string representation of the resource retrieved using the URI.
A dynamic error is raised $href
contains a fragment identifier,
A dynamic error is raised $encoding argument is not a valid encoding name, if the
A dynamic error is raised $encoding
is absent and the
If it is appropriate to use a base URI other than the dynamic base URI (for example,
when resolving a relative URI reference read from a source document) then it is
advisable to resolve the relative URI reference using the fn:resolve-uri
function before passing it to the fn:unparsed-text function.
There is no essential relationship between the sets of URIs accepted by the two
functions fn:unparsed-text and fn:doc (a URI accepted by one
may or may not be accepted by the other), and if a URI is accepted by both there is no
essential relationship between the results (different resource representations are
permitted by the architecture of the web).
There are no constraints on the MIME type of the resource.
The fact that the resolution of URIs is defined by a mapping in the dynamic context
means that in effect, various aspects of the behavior of this function are
The set of URI schemes that the implementation recognizes is implementation-defined. Implementations may allow the mapping of URIs to resources to be configured by the user, using mechanisms such as catalogs or user-written URI handlers.
The handling of media types is implementation-defined.
Implementations may provide user-defined error handling options that allow processing to continue following an error in retrieving a resource, or in reading its content. When errors have been handled in this way, the function may return a fallback document provided by the error handler.
Implementations may provide user options that relax the requirement for the function to return deterministic results.
The rules for determining the encoding are chosen for consistency with
If the text file contains characters such as < and &,
these will typically be output as < and & if
the string is serialized as XML or HTML. If these characters actually represent markup
(for example, if the text file contains HTML), then an XSLT stylesheet can attempt to
write them as markup to the output file using the disable-output-escaping
attribute of the xsl:value-of instruction. Note, however, that XSLT
implementations are not required to support this feature.
This XSLT example attempts to read a file containing 'boilerplate' HTML and copy it directly to the serialized output file:
The fn:unparsed-text-lines function reads an external resource (for
example, a file) and returns its contents as a sequence of strings, one for each line of
text in the string representation of the resource.
The unparsed-text-lines function reads an external resource (for example, a
file) and returns its string representation as a sequence of strings, separated at
newline boundaries.
The result of the single-argument function is the same as the result of the expression
fn:tokenize(fn:unparsed-text($href), '\r\n|\r|\n')[not(position()=last() and
.='')]. The result of the two-argument function is the same as the result of
the expression fn:tokenize(fn:unparsed-text($href, $encoding),
'\r\n|\r|\n')[not(position()=last() and .='')].
The result is thus a sequence of strings containing the text of the resource retrieved using the URI, each string representing one line of text. Lines are separated by one of the sequences x0A, x0D, or x0Dx0A. The characters representing the newline are not included in the returned strings. If there are two adjacent newline sequences, a zero-length string will be returned to represent the empty line; but if the external resource ends with the sequence x0A, x0D, or x0Dx0A, the result will be as if this final line ending were not present.
Error conditions are the same as for the fn:unparsed-text function.
See the notes for fn:unparsed-text.
Because errors in evaluating the fn:unparsed-text function are
non-recoverable, these two functions are provided to allow an application to determine
whether a call with particular arguments would succeed.
The fn:unparsed-text-available function determines whether a call
on the fn:unparsed-text function with identical arguments would
return a string.
If the first argument is an empty sequence, the function returns false.
In other cases, the function returns true if a call on
fn:unparsed-text with the same arguments would succeed, and
false if a call on fn:unparsed-text with the same arguments would
fail with a non-recoverable dynamic error.
The functions fn:unparsed-text and
fn:unparsed-text-available have the same requirement for
fn:doc and fn:doc-available. This means that unless the
user has explicitly stated a requirement for a reduced level of determinism, either of
these functions if called twice with the same arguments during the course of a
transformation fn:unparsed-text-available
unparsed-text with the same arguments.
This requires that the fn:unparsed-text-available function should
actually attempt to read the resource identified by the URI, and check that it is
correctly encoded and contains no characters that are invalid in XML. Implementations
may avoid the cost of repeating these checks for example by caching the validated
contents of the resource, to anticipate a subsequent call on the
fn:unparsed-text or fn:unparsed-text-lines
function. Alternatively, implementations may be able to rewrite an expression such as
if (unparsed-text-available(A)) then unparsed-text(A) else ... to
generate a single call internally.
Since the function fn:unparsed-text-lines succeeds or fails under
exactly the same circumstances as fn:unparsed-text, the
fn:unparsed-text-available function may equally be used to test
whether a call on fn:unparsed-text-lines would succeed.
Returns the value of a system environment variable, if it exists.
The set of available
If the $name argument matches the name of one of these pairs, the function
returns the corresponding value.
If there is no environment variable with a matching name, the function returns the empty sequence.
The collation used for matching names is
The function is
On many platforms, the term "environment variable" has a natural meaning in terms of facilities provided by the operating system. This interpretation of the concept does not exclude other interpretations, such as a mapping to a set of configuration parameters in a database system.
Environment variable names are usually case sensitive. Names are usually of the form
(letter|_) (letter|_|digit)*, but this varies by platform.
On some platforms, there may sometimes be multiple environment variables with the same
name; in this case, it is implementation-dependent as to which is returned; see for
example
The requirement to ensure that the function is deterministic means in practice that the implementation must make a snapshot of the environment variables at some time during execution, and return values obtained from this snapshot, rather than using live values that are subject to change at any time.
Operating system environment variables may be associated with a particular process,
while queries and stylesheets may execute across multiple processes (or multiple
machines). In such circumstances implementations
Security advice: Queries from untrusted sources should not be permitted unrestricted
access to environment variables. For example, the name of the account under which the
query is running may be useful information to a would-be intruder. An implementation may
therefore choose to restrict access to the environment, or may provide a facility to
make fn:environment-variable always return the empty sequence.
Returns a list of environment variable names that are suitable for passing to
fn:environment-variable, as a (possibly empty) sequence of strings.
The function returns a sequence of strings, being the names of the environment variables
in the dynamic context in some
The function is
The function returns a list of strings, containing no duplicates.
It is intended that the strings in this list should be suitable for passing to
fn:environment-variable.
See also the note on security under the definition of the
fn:environment-variable function. If access to environment variables has
been disabled, fn:available-environment-variables always returns the empty
sequence.
This function returns a string that uniquely identifies a given node.
If the argument is omitted, it defaults to the context item (.). The
behavior of the function if the argument is omitted is exactly the same as if the
context item had been passed as the argument.
If the argument is the empty sequence, the result is the zero-length string.
In other cases, the function returns a string that uniquely identifies a given node.
fn:codepoint-equal(fn:generate-id($N), fn:generate-id($M)) returns true
if and only if ($M is $N) returns true.
The returned identifier
The following errors may be raised when $arg is omitted:
If the context item is
If the context item is not a node, type error
An implementation is free to generate an identifier in any convenient way provided that it always generates the same identifier for the same node and that different identifiers are always generated from different nodes. An implementation is under no obligation to generate the same identifiers each time a document is transformed or queried.
There is no guarantee that a generated unique identifier will be distinct from any unique IDs specified in the source document.
There is no inverse to this function; it is not directly possible to find the node with
a given generated ID. Of course, it is possible to search a given sequence of nodes
using an expression such as $nodes[generate-id()=$id].
It is advisable, but not required, for implementations to generate IDs that are distinct even when compared using a case-blind collation.
The primary use case for this function is to generate hyperlinks. For example, when
generating HTML, an anchor for a given section $sect can be generated by
writing (in either XSLT or XQuery):
]]>
and a link to that section can then be produced with code such as:
here]]>
Note that anchors generated in this way will not necessarily be the same each time a document is republished.
Since the keys in a map must be atomic values, it is possible to use generated IDs
as surrogates for nodes when constructing a map. For example, in some implementations,
testing whether a node $N is a member of a large node-set $S
using the expression fn:exists($N intersect $S) may be expensive; there
may then be performance benefits in creating a map:
let $SMap := map:merge($S!map{fn:generate-id(.) : .})
and then testing for membership of the node-set using:
map:contains($SMap, fn:generate-id($N))
This function takes as input an XML document represented as a string, and returns the document node at the root of an XDM tree representing the parsed document.
If $arg is the empty sequence, the function returns the empty sequence.
The precise process used to construct the XDM instance is
The fn:parse-xml
function call is used both as the base URI used by the XML parser to resolve relative
entity references within the document, and as the base URI of the document node that is
returned.
The document URI of the returned node is
The function is
A dynamic error is raised $arg is not a well-formed and namespace-well-formed XML document.
A dynamic error is raised $arg is not valid against its DTD.
Since the XML document is presented to the parser as a string, rather than as a sequence of octets, the encoding specified within the XML declaration has no meaning. If the XML parser accepts input only in the form of a sequence of octets, then the processor must ensure that the string is encoded as octets in a way that is consistent with rules used by the XML parser to detect the encoding.
The primary use case for this function is to handle input documents that contain nested
XML documents embedded within CDATA sections. Since the content of the CDATA section are
exposed as text, the receiving query or stylesheet may pass this text to the
fn:parse-xml function to create a tree representation of the nested
document.
Similarly, nested XML within comments is sometimes encountered, and lexical XML is sometimes returned by extension functions, for example, functions that access web services or read from databases.
A use case arises in XSLT where there is a need to preprocess an input document before
parsing. For example, an application might wish to edit the document to remove its
DOCTYPE declaration. This can be done by reading the raw text using the
fn:unparsed-text function, editing the resulting string, and then
passing it to the fn:parse-xml function.
The expression fn:parse-xml("<alpha>abcd</alpha>") returns a newly
created document node, having an alpha element as its only child; the
alpha element in turn is the parent of a text node whose string value
is "abcd".
This function takes as input an XML external entity represented as a string, and returns the document node at the root of an XDM tree representing the parsed document fragment.
If $arg is the empty sequence, the function returns the empty sequence.
The input must be a namespace-well-formed external general parsed entity. More
specifically, it must be a string conforming to the production rule
The string is parsed to form a sequence of nodes which become children of the new document node, in the same way as the content of any element is converted into a sequence of children for the resulting element node.
Schema validation is
The precise process used to construct the XDM instance is
The fn:parse-xml-fragment
function call is used as the base URI of the document node that is returned.
The document URI of the returned node is
The function is
A dynamic error is raised $arg is not a well-formed external general parsed entity, if it contains
entity references other than references to predefined entities, or if a document that
incorporates this well-formed parsed entity would not be namespace-well-formed.
See also the notes for the fn:parse-xml function.
The main differences between fn:parse-xml and
fn:parse-xml-fragment are that for fn:parse-xml, the
children of the resulting document node must contain exactly one element node and no
text nodes, wheras for fn:parse-xml-fragment, the resulting document node
can have any number (including zero) of element and text nodes among its children. An
additional difference is that the
Note that all whitespace outside the
One use case for this function is to handle XML fragments stored in databases, which
frequently allow zero-or-more top level element nodes. Another use case is to parse the
contents of a CDATA section embedded within another XML document.
The expression
fn:parse-xml-fragment("<alpha>abcd</alpha><beta>abcd</beta>")
returns a newly created document node, having two elements named alpha
and beta as its children; each of these elements in turn is the parent
of a text node.
The expression fn:parse-xml-fragment("He was <i>so</i> kind")
returns a newly created document node having three children: a text node whose string
value is "He was ", an element node named i having a child
text node with string value "so", and a text node whose string value is
" kind".
The expression fn:parse-xml-fragment("") returns a document node having
no children.
The expression fn:parse-xml-fragment(" ") returns a document node whose
children comprise a single text node whose string value is a single space.
The expression fn:parse-xml-fragment('<?xml version="1.0" encoding="utf8"
standalone="yes"?><a/>') results in a dynamic error fn:parse-xml function
will also be accepted by fn:parse-xml-fragment.)
This function serializes the supplied input sequence $arg as described in
The value of the first argument $arg acts as the input sequence to the serialization process,
which starts with sequence normalization.
The second argument $params, if present, provides serialization parameters. These may be supplied in either
of two forms:
As an output:serialization-parameters
element, having the format described in element(output:serialization-parameters).
As a map. In this case the type of the supplied argument must match the required type map(*)
The single-argument version of this function has the same effect as the two-argument
version called with $params set to an empty sequence. This in turn is the
same as the effect of passing an output:serialization-parameters element
with no child elements.
The final stage of serialization, that is, encoding, is skipped. If the serializer does not allow this phase to be skipped, then the sequence of octets returned by the serializer is decoded into a string by reversing the character encoding performed in the final stage.
If the second argument is omitted, or is supplied in the form of an output:serialization-parameters
element, then the values of any serialization parameters that are not explicitly specified is
If the second argument is supplied as a map, then the
Each entry in the map defines one serialization parameter.
The key of the entry is an xs:string value in the cases of parameter names defined in these specifications, or an
xs:QName (with non-absent namespace) in the case of implementation-defined serialization parameters.
The required type of each parameter, and its default value, are defined by the following table. The default value is used when the map contains no entry for the parameter in question, and also when an entry is present, with the empty sequence as its value. The table also indicates how the value of the map entry is to be interpreted in cases where further explanation is needed.
| Parameter | Required type | Interpretation | Default Value |
|---|---|---|---|
allow-duplicate-names |
xs:boolean? |
true() means "yes", false() means "no" |
no |
byte-order-mark |
xs:boolean? |
true() means "yes", false() means "no" |
no |
cdata-section-elements |
xs:QName* |
() |
|
doctype-public |
xs:string? |
Zero-length string and () both represent "absent" |
absent |
doctype-system |
xs:string? |
Zero-length string and () both represent "absent" |
absent |
encoding |
xs:string? |
utf-8 |
|
escape-uri-attributes |
xs:boolean? |
true() means "yes", false() means "no" |
yes |
html-version |
xs:decimal? |
5 |
|
include-content-type |
xs:boolean? |
true() means "yes", false() means "no" |
yes |
indent |
xs:boolean? |
true() means "yes", false() means "no" |
no |
item-separator |
xs:string? |
absent | |
json-node-output-method |
union(xs:string, xs:QName)? |
See Notes 1, 2 | xml |
media-type |
xs:string? |
(a media type suitable for the chosen method) |
|
method |
union(xs:string, xs:QName)? |
See Notes 1, 2 | xml |
normalization-form |
xs:string? |
none |
|
omit-xml-declaration |
xs:boolean? |
true() means "yes", false() means "no" |
yes |
standalone |
xs:boolean? |
true() means "yes", false() means "no", () means "omit" |
omit |
suppress-indentation |
xs:QName* |
() |
|
undeclare-prefixes |
xs:boolean? |
true() means "yes", false() means "no" |
no |
use-character-maps |
map(xs:string, xs:string)? |
See Note 3 | map{} |
version |
xs:string? |
1.0 |
Notes to the table:
The notation union(A, B) is used to represent a union type whose member types are A
and B.
If an xs:QName is supplied method or json-node-output-method
options,xml and json
are defined as strings, not as xs:QName values.
use-character-maps optionxs:string instances),
and whose corresponding values are the strings to be substituted for these characters.
A type error element(output:serialization-parameters)?
or map(*).
This is defined as a type error so that it can be enforced via the function signature by implementations that generalize the type system in a suitable way.
If the host language makes serialization an optional feature and the implementation does
not support serialization, then a dynamic error
The serialization process will raise an error if $arg is an attribute or
namespace node.
When the second argument is supplied as a map,
and the supplied value is of the wrong type for the particular parameter, for example if the value of indent
is a string rather than a boolean, then as defined by the use-character-maps includes a key that is a string whose length is not one (1)).
If any serialization error occurs, including the detection of an invalid value for a
serialization parameter as described above, this results in the fn:serialize call failing with
a dynamic error.
One use case for this function arises when there is a need to construct an XML document
containing nested XML documents within a CDATA section (or on occasions within a
comment). See fn:parse-xml for further details.
Another use case arises when there is a need to call an extension function that expects a lexical XML document as input.
There are also use cases where the application wants to post-process the output of a
query or transformation, for example by adding an internal DTD subset, or by inserting
proprietary markup delimiters such as the <% ... %> used by some
templating languages.
The ability to specify the serialization parameters in an output:serialization-parameters
element provides backwards compatibility with the 3.0 version of this specification; the ability to
use a map takes advantage of new features in the 3.1 version. The default parameter values are
implementation-defined when an output:serialization-parameters
element is used (or when the argument is omitted), but are fixed by this specification in the
case where a map (including an empty map) is supplied for the argument.
Given the variables:
The following call might produce the output shown:
The following call would also produce the output shown (though the second argument could equally well be supplied
as an empty map (map{}), since both parameters are given their default values):
Returns the context position from the dynamic context.
Returns the context position from the dynamic context. (See
A dynamic error is raised
Returns the context size from the dynamic context.
Returns the context size from the dynamic context. (See
A dynamic error is raised
Under most circumstances, the context size is absent only if the context item is absent. However, XSLT 3.0 with streaming defines situations in which the context item and context position are known, but the context size is unknown.
Returns the current date and time (with timezone).
Returns the current dateTime (with timezone) from the dynamic context. (See xs:dateTime that is current at some time during the evaluation of a
query or transformation in which fn:current-dateTime is executed.
This function is fn:current-dateTime() is
If the implementation supports data types from XSD 1.1 then the returned value will be
an instance of xs:dateTimeStamp. Otherwise, the only guarantees are that it
will be an instance of xs:dateTime and will have a timezone component.
The returned xs:dateTime will always have an associated timezone, which
will always be the same as the implicit timezone in the dynamic context
fn:current-dateTime() returns an xs:dateTimeStamp
corresponding to the current date and time. For example, a call of
fn:current-dateTime() might return
2004-05-12T18:17:15.125Z corresponding to the current time on May 12,
2004 in timezone Z.
Returns the current date.
Returns xs:date(fn:current-dateTime()). This is an xs:date
(with timezone) that is current at some time during the evaluation of a query or
transformation in which fn:current-date is executed.
This function is fn:current-date is
The returned date will always have an associated timezone, which will always be the same as the implicit timezone in the dynamic context
fn:current-date() returns an xs:date corresponding to the
current date. For example, a call of fn:current-date() might return
2004-05-12+01:00.
Returns the current time.
Returns xs:time(fn:current-dateTime()). This is an xs:time
(with timezone) that is current at some time during the evaluation of a query or
transformation in which fn:current-time is executed.
This function is fn:current-time() is
The returned time will always have an associated timezone, which will always be the same as the implicit timezone in the dynamic context
fn:current-time() returns an xs:time corresponding to the
current time. For example, a call of fn:current-time() might return
23:17:00.000-05:00.
Returns the value of the implicit timezone property from the dynamic context.
Returns the value of the implicit timezone property from the dynamic context. Components
of the dynamic context are described in
Returns the value of the default collation property from the static context.
Returns the value of the default collation property from the static context. Components
of the static context are described in
The default collation property can never be absent. If it is not explicitly defined, a
system defined default can be invoked. If this is not provided, the Unicode codepoint
collation (http://www.w3.org/2005/xpath-functions/collation/codepoint) is
used.
Returns the value of the default language property from the dynamic context.
Returns the value of the default language property from the dynamic context. Components
of the dynamic context are described in
The default language property can never be absent. The functions fn:format-integer,
fn:format-date, fn:format-time, and fn:format-dateTime
are defined to use the default language if no explicit language is supplied. The default language
may play a role in selection of a default collation, but this is not a requirement.
This function returns the value of the
The function returns the value of the
Components of the static context are described in
XQuery 3.0 and XSLT 3.0 give an implementation freedom to use different base URIs during
the static analysis phase and the dynamic evaluation phase, that is, for compile-time
and run-time resources respectively. This is appropriate when the implementation allows
the output of static analysis (a "compiled" query or stylesheet) to be deployed for execution
to a different location from the one where static analysis took place. In this situation, the
fn:static-base-uri function should return a URI suitable for locating
resources needed during dynamic evaluation.
Returns the function having a given name and arity, if there is one.
A call to fn:function-lookup returns the function obtained by looking up
the expanded QName supplied as $name and the arity supplied as
$arity in the named functions component of the dynamic context
(specifically, the dynamic context of the call to fn:function-lookup).
Furthermore, if that function has an implementation-dependent implementation (see note
below), then the implementation of the function returned by
fn:function-lookup is associated with the static and dynamic context of
the call to fn:function-lookup.
The above rule deliberately uses the same wording as the corresponding rule for Named Function References. The term "a function [with] an implementation-dependent implementation" essentially means a function whose implementation is provided by the language processor rather than by the stylesheet or query author. This rule is therefore relevant to built-in functions and vendor-supplied extension functions whose result depends on the context of the function call.
Otherwise (if no known function can be identified by name and arity), an empty sequence is returned.
If the arguments to fn:function-lookup identify a function that is present
in the static context of the function call, the function will always return the same
function that a static reference to this function would bind to. If there is no such
function in the static context, then the results depend on what is present in the
dynamic context, which is
This function can be useful where there is a need to make a dynamic decision on which of several statically-known functions to call. It can thus be used as a substitute for polymorphism, in the case where the application has been designed so several functions implement the same interface.
The function can also be useful in cases where a query or stylesheet module is written
to work with alternative versions of a library module. In such cases the author of the
main module might wish to test whether an imported library module contains or does not
contain a particular function, and to call a function in that module only if it is
available in the version that was imported. A static call would cause a static error if
the function is not available, whereas getting the function using
fn:function-lookup allows the caller to take fallback action in this
situation.
If the function that is retrieved by fn:function-lookup is fn:function-lookup
function itself. The context thus effectively forms part of the closure of the returned
function. In practice this applies only where the target of
fn:function-lookup is a built-in function, because user-defined
functions never depend on the static or dynamic context of the function call. The rule
applies recursively, since fn:function-lookup is itself a context-dependent
built-in function.
These specifications do not define any circumstances in which the dynamic context will
contain functions that are not present in the static context, but neither do they rule
this out. For example an API
The mere fact that a function exists and has a name does not of itself mean that the
function is present in the dynamic context. For example, functions obtained through
use of the fn:load-xquery-module function are not added to the dynamic context.
The expression (fn:function-lookup(xs:QName('xs:dateTimeStamp'), 1),
xs:dateTime#1)[1] ('2011-11-11T11:11:11Z') returns an
xs:dateTime value set to the specified date, time, and timezone; if
the implementation supports XSD 1.1 then the result will be an instance of the
derived type xs:dateTimeStamp. The query is written to ensure that no
failure occurs when the implementation does not recognize the type
xs:dateTimeStamp.
The expression let $f := fn:function-lookup(xs:QName('zip:binary-entry'), 2)
return if (exists($f)) then $f($href, $entry) else () returns the result of
calling zip:binary-entry($href, $entry) if the function is available, or
an empty sequence otherwise.
Returns the name of the function identified by a function item.
If $func refers to a named function, fn:function-name($func)
returns the name of that function.
Otherwise ($func refers to an anonymous function),
fn:function-name($func) returns an empty sequence.
The prefix part of the returned QName is
Returns the arity of the function identified by a function item.
The fn:function-arity function returns the arity (number of arguments) of
the function identified by $func.
Applies the function item $action to every item from the sequence $seq in turn, returning the concatenation of the resulting sequences in order.
The effect of the function is equivalent to the following implementation in XQuery:
or its equivalent in XSLT:
The function call fn:for-each($SEQ, $F) is equivalent to the expression
for $i in $SEQ return $F($i), assuming that ordering mode is
ordered.
Returns those items from the sequence $seq for which the supplied function $f returns true.
The effect of the function is equivalent to the following implementation in XQuery:
or its equivalent in XSLT:
As a consequence of the function signature and the function calling rules, a type error
occurs if the supplied function $f returns anything other than a single
xs:boolean item; there is no conversion to an effective boolean
value.
The function call fn:filter($SEQ, $F) has a very similar effect to the
expression $SEQ[$F(.)]. There are some differences, however. In the case of
fn:filter, the function $F is required to return a boolean;
there is no special treatment for numeric predicate values, and no conversion to an
effective boolean value. Also, with a filter expression $SEQ[$F(.)], the
focus within the predicate is different from that outside; this means that the use of a
context-sensitive function such as fn:lang#1 will give different results in
the two cases.
Processes the supplied sequence from left to right, applying the supplied function repeatedly to each item in turn, together with an accumulated result value.
The effect of the function is equivalent to the following implementation in XQuery:
or its equivalent in XSLT:
As a consequence of the function signature and the function calling rules, a type error
occurs if the supplied function $f cannot be applied to two arguments, where
the first argument is either the value of $zero or the result of a previous
application of $f, and the second
This operation is often referred to in the functional programming literature as "folding" or "reducing" a sequence. It takes a function that operates on a pair of values, and applies it repeatedly, with an accumulated result as the first argument, and the next item in the sequence as the second argument. The accumulated result is initially set to the value of the $zero argument, which is conventionally a value (such as zero in the case of addition, one in the case of multiplication, or a zero-length string in the case of string concatenation) that causes the function to return the value of the other argument unchanged.
Processes the supplied sequence from right to left, applying the supplied function repeatedly to each item in turn, together with an accumulated result value.
The effect of the function is equivalent to the following implementation in XQuery:
or its equivalent in XSLT:
As a consequence of the function signature and the function calling rules, a type error occurs if the supplied function $f cannot be applied to two arguments, where the first argument is any item in the sequence $seq, and the second is either the value of $zero or the result of a previous application of $f.
This operation is often referred to in the functional programming literature as "folding" or "reducing" a sequence. It takes a function that operates on a pair of values, and applies it repeatedly, with the next item in the sequence as the first argument, and the result of processing the remainder of the sequence as the second argument. The accumulated result is initially set to the value of the $zero argument, which is conventionally a value (such as zero in the case of addition, one in the case of multiplication, or a zero-length string in the case of string concatenation) that causes the function to return the value of the other argument unchanged.
In cases where the function performs an associative operation on its two arguments (such
as addition or multiplication), fn:fold-right produces the same result as
fn:fold-left.
Applies the function item $action to successive pairs of items taken one from $seq1 and one from $seq2, returning the concatenation of the resulting sequences in order.
The effect of the function is equivalent to the following implementation in XQuery:
or its equivalent in XSLT:
If one sequence is longer than the other, excess items in the longer sequence are ignored.
Sorts a supplied sequence, based on the value of a sort key supplied as a function.
Calling the single-argument version of the function is equivalent to calling the two-argument form
with default-collation() as the second argument: that is, it sorts a sequence of items according
to the typed value of the items, using the default collation to compare strings.
Calling the two-argument version of the function is equivalent to calling the three-argument form
with fn:data#1 as the third argument: that is, it sorts a sequence of items according
to the typed value of the items, using a specified collation to compare strings.
In the case of both fn:sort#2 and fn:sort#3, supplying an empty
sequence as the second argument is equivalent to supplying fn:default-collation(). For more
information on collations see
The result of the function is obtained as follows:
For each item in the sequence $input, the function supplied as $key
is evaluated with that item as its argument.
The resulting values are the sort keys of the items in the input sequence.
The result sequence contains the same items as the input sequence $input, but generally in a different order.
Let $C be the selected collation, or the default collation where applicable.
The order of items in the result is such that, given two items $A and $B:
If (fn:deep-equal($key($A), $key($B), $C), then the relative order of $A and $B
in the output is the same as their relative order in the input (that is, the sort is stable)
Otherwise, if (deep-less-than($key($A), $key($B), $C), then $A precedes $B in the output.
The function deep-less-than is defined as the boolean result of the expression:
if (fn:empty($A))
then fn:exists($B)
else if (fn:deep-equal($A[1], $B[1], $C))
then deep-less-than(fn:tail($A), fn:tail($B), $C)
else if ($A[1] ne $A[1] (:that is, $A[1] is NaN:))
then fn:true()
else if (is-string($A[1]) and is-string($B[1])
then fn:compare($A[1], $B[1], $C) lt 0
else $A[1] lt $B[1]where the function is-string($X) returns true if and only if $X is an instance of
xs:string, xs:anyURI, or xs:untypedAtomic.
This ordering of sequences is referred to by mathematicians as "lexicographic ordering".
If the set of computed sort keys contains values that are not comparable using the lt operator then the sort
operation will fail with a type error (
XSLT and XQuery both provide native sorting capability, but previous releases of XPath provided no sorting functionality for use in standalone environments.
In addition there are cases where this function may be more flexible than the built-in sorting capability for XQuery or XSLT, for example when the sort key or collation is chosen dynamically, or when the sort key is a sequence of items rather than a single item.
The results are compatible with the results of XSLT sorting (using xsl:sort) in the case where the sort key evaluates to a sequence of
length zero or one, given the options stable="yes" and order="ascending".
The results are compatible with the results of XQuery sorting (using the order by clause) in the case where the sort key evaluates to a sequence of
length zero or one, given the options stable, ascending, and empty least.
To sort a set of strings $in using Swedish collation:
To sort a sequence of employees by last name as the major sort key and first name as the minor sort key, using the default collation:
Makes a dynamic call on a function with an argument list supplied in the form of an array.
The result of the function is obtained by invoking the supplied function $function with arguments
taken from the members of the supplied array $array. The first argument of the function call is the first
member of $array, the second argument is the second member of $array, and so on.
The arity of the supplied function $function must be the same as the size of the array $array.
The effect of calling fn:apply($f, [$a, $b, $c, ...]) is the same as the effect of the dynamic function call
$f($a, $b, $c, ....). For example, the function conversion rules are applied to the supplied arguments
in the usual way.
A dynamic error is raised if the arity of the function $function is not the same as the size of the
array $array (
The function is useful where the arity of a function item is not known statically.
The expression fn:apply($f, array:subarray(["a", "b", "c", "d", "e", "f"], 1, fn:function-arity($f)))
calls the supplied function $f supplying the number of arguments required by its arity.
Determines whether two atomic values can coexist as separate keys within a map.
The internal function op:same-key (which is not available at the user level) is used to assess whether two atomic
values are considered to be duplicates when used as keys in a map. A map cannot
contain two separate entries whose keys are map:get
and map:remove.
The function returns true if and only if one of the following conditions is true:
All of the following conditions are true:
$k1 is an instance of xs:string, xs:anyURI, or xs:untypedAtomic
$k2 is an instance of xs:string, xs:anyURI, or xs:untypedAtomic
fn:codepoint-equal($k1, $k2)
Strings are compared without any dependency on collations.
All of the following conditions are true:
$k1 is an instance of xs:decimal, xs:double, or xs:float
$k2 is an instance of xs:decimal, xs:double, or xs:float
One of the following conditions is true:
Both $k1 and $k2 are NaN
xs:double('NaN') is the same key as xs:float('NaN')
Both $k1 and $k2 are positive infinity
xs:double('INF') is the same key as xs:float('INF')
Both $k1 and $k2 are negative infinity
xs:double('-INF') is the same key as xs:float('-INF')
$k1 and $k2 when converted to decimal numbers with no rounding or loss of precision
are mathematically equal.
Every instance of xs:double, xs:float, and xs:decimal can be represented
exactly as a decimal number provided enough digits are available both before and after the decimal point. Unlike the eq
relation, which converts both operands to xs:double values, possibly losing precision in the process, this
comparison is transitive.
Positive and negative zero are the same key.
All of the following conditions are true:
$k1 is an instance of xs:date, xs:time, xs:dateTime,
xs:gYear, xs:gYearMonth, xs:gMonth, xs:gMonthDay, or xs:gDay
$k2 is an instance of xs:date, xs:time, xs:dateTime,
xs:gYear, xs:gYearMonth, xs:gMonth, xs:gMonthDay, or xs:gDay
One of the following conditions is true:
Both $k1 and $k2 have a timezone
Neither $k1 nor $k2 has a timezone
fn:deep-equal($k1, $k2)
The use of deep-equal rather than eq ensures that comparing values of different
types yields false rather than an error.
Unlike the eq operator, this comparison has no dependency on the implicit timezone, which means that
the question of whether or not a map contains duplicate keys is not dependent on this aspect of the dynamic context.
All of the following conditions are true:
$k1 is an instance of xs:boolean, xs:hexBinary, xs:base64Binary,
xs:duration, xs:QName, or xs:NOTATION
$k2 is an instance of xs:boolean, xs:hexBinary, xs:base64Binary,
xs:duration, xs:QName, or xs:NOTATION
fn:deep-equal($k1, $k2)
The use of deep-equal rather than eq ensures that comparing values of different
types yields false rather than an error.
The rules for comparing keys in a map are chosen to ensure that the comparison is:
As always, any algorithm that delivers the right result is acceptable. For example, when testing whether an xs:double
value D is the same key as an xs:decimal value that has N significant digits, it is not
necessary to know all the digits in the decimal expansion of D to establish the result: computing the first N+1
significant digits (or indeed, simply knowing that there are more than N significant digits) is sufficient.
Returns a map that combines the entries from a number of existing maps.
The function map:merge $maps
argument.
Informally, the supplied maps are combined as follows:
There is one entry in the returned map for each distinct key present in the union
of the input maps, where two keys are distinct if they are not the
If there are duplicate keys, that is, if two or more maps contain entries having the
$options) argument.
The definitive specification is as follows.
The effect of calling the single-argument function is the same as the effect of
calling the two-argument function with an empty map as the value of $options.
The $options argument can be used to control the way in which duplicate keys are handled.
The
The entries that may appear in the $options map are as follows:
$maps contain entries with key values
K1 and K2 where K1 and K2 are the
$maps argument.
$maps argument.
$maps argument.
The key value in the result map that corresponds to such a set of duplicates must
be the xs:byte(1)
and xs:short(1), the key in the result could legitimately be xs:long(1).
The result of the function call map:merge($MAPS, $OPTIONS)
is defined to be consistent with the result of the expression:
By way of explanation, $combine-maps is a function that combines
two maps by iterating over the keys of the second map, adding each key and its corresponding
value to the first map as it proceeds. The second call of fn:fold-left
in the return clause then iterates over the maps supplied in the call
to map:merge, accumulating a single map that absorbs successive maps
in the input sequence by calling $combine-maps.
This algorithm processes the supplied maps in a defined order, but processes the keys within each map in implementation-dependent order.
The use of fn:random-number-generator represents one possible conformant
implementation for "duplicates":"use-any", but it is not the only conformant
implementation and is not intended to be a realistic implementation. The purpose of this
option is to allow the implementation to use whatever strategy is most efficient; for example,
if the input maps are processed in parallel, then specifying "duplicates":"use-any"
means that the implementation does not need to keep track of the original order of the sequence of input
maps.
An error is raised $options indicates that duplicates are to be rejected, and a duplicate key is encountered.
An error is raised $options includes an entry whose key is defined
in this specification, and whose value is not a permitted value for that key.
If the input is an empty sequence, the result is an empty map.
If the input is a sequence of length one, the result map is
There is no requirement that the supplied input maps should have the same or compatible
types. The type of a map (for example map(xs:integer, xs:string)) is
descriptive of the entries it currently contains, but is not a constraint on how the map
may be combined with other maps.
$week, supplemented with an additional
entry.$week, with one entry replaced by a
new entry. Both input maps contain an entry with the key 6; the
one used in the result is the one that comes last in the input
sequence.$week, with one entry replaced by a
new entry. Both input maps contain an entry with the key 6; the
one used in the result is the one that comes first in the input
sequence.$week, with one entry replaced by a
new entry. Both input maps contain an entry with the key 6; the
entry that appears in the result is the sequence-concatenation of the entries
in the input maps, retaining order.Returns a sequence containing all the keys present in a map
The function map:keys takes any $map argument and returns the keys that are present in the map as
a sequence of atomic values, in
The function is
The number of items in the result will be the same as the number of entries in the map, and the result sequence will contain no duplicate values.
Tests whether a supplied map contains an entry for a given key
The function map:contains returns true if the $map contains an entry with $key; otherwise it returns false.
Returns the value associated with a supplied key in a given map.
The function map:get attempts to find an entry within the $map that has $key. If there is such an entry, it returns the associated value;
otherwise it returns an empty sequence.
A return value of () from map:get could indicate that
the key is present in the map with an associated value of (), or it could
indicate that the key is not present in the map. The two cases can be distinguished by
calling map:contains.
Invoking the get: that is, when $map is a map, the expression
$map($K) is equivalent to map:get($map, $K). Similarly, the
expression map:get(map:get(map:get($map, 'employee'), 'name'), 'first') can
be written as $map('employee')('name')('first').
Searches the supplied input sequence and any contained maps and arrays for a map entry with the supplied key, and returns the corresponding values.
The function map:find searches the sequence supplied as $input
looking for map entries whose key is the $key. The associated value in any such map entry (each being in general a sequence)
is returned as a member of the result array.
The search processes the $input sequence using the following recursively-defined rules
(any equivalent algorithm may be used provided it delivers
the same result, respecting those rules that constrain the order of the result):
To process a sequence, process each of its items in order.
To process an item that is an array, process each of the array's members in order (each member is, in general, a sequence).
To process an item that is a map, then for each key-value entry (K, V)
in the map (in
If K is the $key,
then add V as a new member to the end of the result array.
Process V (which is, in general, a sequence).
To process an item that is neither a map nor an array, do nothing. (Such items are ignored).
If $input is an empty sequence, map, or array, or if the requested $key is not found,
the result will be a zero-length array.
Returns a map containing all the contents of the supplied map, but with an additional entry, which replaces any existing entry for the same key.
The function map:put returns $map,
with the exception of any entry whose key is the $key, together with a new
entry whose key is $key and whose associated value is $value.
The effect of the function call map:put($MAP, $KEY, $VALUE) is equivalent
to the result of the following steps:
let $MAP2 := map:remove($MAP, $KEY)
This returns a map in which all entries with the same key as $KEY have been removed.
Construct and return a map containing:
All the entries (key/value pairs) in $MAP2, and
The entry map:entry($KEY, $VALUE)
There is no requirement that the type of $key and $value be consistent with the types
of any existing keys and values in the supplied map.
The function map:entry returns a $key, and its associated value is $value.
If the supplied key is the xs:float or
xs:double value NaN, the supplied $map is
empty (that is, it contains no entries).
If the supplied key is xs:untypedAtomic, it is converted
to xs:string.
The function call map:entry(K, V) produces the same result as the
expression map{K : V}.
The function map:entry is intended primarily for use in conjunction with
the function map:merge. For example, a map containing seven entries may be
constructed like this:
The map:merge function can be used to construct
a map with a variable number of entries, for example:
Returns a map containing all the entries from a supplied map, except
The function map:remove returns a $map except for any entry whose key is
the $keys.
No failure occurs $keys does not correspond to any entry in $map;
that key value is simply ignored
The effect of the function call map:remove($MAP, $KEY) can be described more formally as the result of the expression below:
Applies a supplied function to every entry in a map, returning the concatenation of the results.
The function map:for-each takes any $map argument and applies the supplied function
to each entry in the map, in
The function is
The function supplied as $action takes two arguments. It is called
supplying the key of the map entry as the first argument, and the associated value as
the second argument.
map:keys. The
result is in implementation-dependent order.This XQuery example converts the entries in a map to attributes on a newly constructed element node:
The result is the element <box height="3" width="4"
depth="5"/>.
Returns the number of entries in the supplied map.
The function map:size takes any $map argument and returns the number of entries that are present
in the map.
Given a string value and a collation, generates an internal value called a collation key, with the property that the matching and ordering of collation keys reflects the matching and ordering of strings under the specified collation.
Calling the one-argument version of this function is equivalent to calling the two-argument version supplying the default collation as the second argument.
The function returns an $K1 and $K2:
collation-key($K1, $C) eq collation-key($K2, $C) if and only if
compare($K1, $K2, $C) eq 0
collation-key($K1, $C) lt collation-key($K2, $C) if and only if
compare($K1, $K2, $C) lt 0
The collation used by this function is determined according to the rules in xs:base64Binary values
to ensure unambiguous and context-free comparison semantics.
An implementation is free to generate a collation key in any convenient way provided
that it always generates the same collation key for two strings that are equal under the
collation, and different collation keys for strings that are not equal. This holds only
within a single
It is possible to define collations that do not have the ability to generate collation
keys. Supplying such a collation will cause the function to fail. The ability to
generate collation keys is an
An error is raised
The function is provided primarily for use with maps. If a map is required where
codepoint equality is inappropriate for comparing keys, then a common technique is to
normalize the key so that equality matching becomes feasible. There are many ways
keys can be normalized, for example by use of functions such as
fn:upper-case, fn:lower-case,
fn:normalize-space, or fn:normalize-unicode, but this
function provides a way of normalizing them according to the rules of a specified
collation. For example, if the collation ignores accents, then the function will
generate the same collation key for two input strings that differ only in their use of
accents.
The result of the function is defined to be an xs:base64Binary value. Binary values
are chosen because they have unambiguous and context-free comparison semantics, because the value space
is unbounded, and because the ordering rules are such that between any two values in the ordered value space, an
arbitrary number of further values can be interpolated. The choice between xs:base64Binary
and xs:hexBinary is arbitrary; the only operation that behaves differently between the two binary
data types is conversion to/from a string, and this operation is not one that is normally required for
effective use of collation keys.
For collations based on the Unicode Collation Algorithm, an algorithm for computing
collation keys is provided in
This specification does not mandate that collation keys should retain ordering. This is partly because the primary use case is for maps, where only equality comparisons are required, and partly to allow the use of binary data types (which are currently unordered types) for the result. The specification may be revised in a future release to specify that ordering is preserved.
The fact that collation keys are ordered can be exploited in XQuery, whose order by
clause does not allow the collation to be selected dynamically. This restriction can be circumvented
by rewriting the clause order by $e/@key collation "URI" as order by fn:collation-key($e/@key, $collation),
where $collation allows the collation to be chosen dynamically.
Note that xs:base64Binary becomes an ordered type
in XPath 3.1, making binary collation keys possible.
As the above examples illustrate, it is important that when the
collation-key function is used to add entries to a map, then it must
also be used when retrieving entries from the map. This process can be made less
error-prone by encapsulating the map within a function: function($k)
{$M(collation-key($k, $collation)}.
Parses a string supplied in the form of a JSON text, returning the results in the form
of an XML
The effect of the one-argument form of this function is the same as calling the
two-argument form with an empty map as the value of the $options
argument.
The first argument is a JSON-text as defined in
If $json-text is an empty sequence, the function returns the empty sequence.
The $options argument can be used to control the way in which the parsing
takes place. The
The entries that may appear in the $options map are as follows:
JSON-text in escape option is set to truevalidate is true then reject, otherwise retain.validate=true
liberal option has the value true.
fallback function
as described below; in the absence of a fallback function, they are replaced by
the Unicode REPLACEMENT CHARACTER (xFFFD)escaped and escaped-key will not be present in the XDM output.
all codepoints in the range x00 to x1F
or x7F to x9F;
all codepoints that do not represent characters that are valid in the version of XML supported by the processor, including codepoints representing unpaired surrogates;
the backslash character itself (x5C).
\t), or a six-character escape sequence otherwise
(for example \uDEAD). Characters other than these will not be escaped in the result,
even if they were escaped in the input. In the result:
Any string element whose string value contains a
backslash character must have the attribute value escaped="true".
Any element that contains a key attribute whose string value
contains a backslash character must have the attribute
escaped-key="true".
The values of the escaped and
escaped-key attributes are immaterial when there is no backslash
present, and it is never necessary to include either attribute when its value
is false.
fallback option if the escape option is present
with the value true.
function($s){"�"}: that is,
a function that replaces the escape sequence with the Unicode REPLACEMENT CHARACTER.liberal:true() is specified): for example
\b or \uFFFF or \uDEAD. The function is \x0A).
The function returns a string
which is inserted into the result in place of the invalid character. The
function also has the option of raising a dynamic error by calling fn:error.
The various structures that can occur in JSON are transformed recursively to XDM values
according to the rules given in
The function returns a document node, whose only child is the element node representing the outermost construct in the JSON text.
The function is
The base URI of the returned document node is taken from the static base URI of the function call.
The choice of namespace prefix (or absence of a prefix) in the names of constructed
nodes is
The XDM tree returned by the function does not contain any
unnecessary (albeit valid) nodes such as whitespace text nodes, comments, or processing instructions.
It does not include any whitespace in the value of number or boolean
element nodes, escaped or escaped-key
attribute nodes.
If the result is typed, every element named string will have an attribute named
escaped whose value is either true or false, and every element having
an attribute named key will also have an attribute named escaped-key whose value is either
true or false.
If the result is untyped, the attributes escaped and escaped-key will
either be present with the value true, or will be absent. They will never be present with the value false.
An error is raised $input does not conform to the JSON grammar as defined
by "liberal":true() is present and
the processor chooses to accept the deviation.
An error is raised validate option is true and the processor does not support
schema validation or typed data.
An error is raised $options includes an entry whose key is defined in this specification,
and whose value is not a permitted value for that key.
To read a JSON file, this function can be used in conjunction with the
fn:unparsed-text function.
Many JSON implementations allow commas to be used after the last item in an object or
array, although the specification does not permit it. The option
spec="liberal" is provided to allow such deviations from the
specification to be accepted. Some JSON implementations also allow constructors such as
new Date("2000-12-13") to appear as values: specifying
spec="liberal" allows such extensions to be accepted, but does not
guarantee it. If such extensions are accepted, the resulting value is
implementation-defined, and will not necessarily conform to the schema at
If the input starts with a byte order mark, this function ignores it. The byte order mark may have been added to the data stream in order to facilitate decoding of an octet stream to a character string, but since this function takes a character string as input, the byte order mark serves no useful purpose.
The possibility of the input containing characters that are not valid in XML (for example, unpaired surrogates)
arises only when such characters are expressed using JSON escape sequences. The is because the input to the function
is an instance of xs:string, which by definition can only contain characters that are valid in XML.
escaped attribute
on the second string element.The following example illustrates use of the fallback function to
handle characters that are invalid in XML.
Converts an XML tree, whose format corresponds to the XML representation of JSON defined in this specification, into a string conforming to the JSON grammar.
The effect of the one-argument form of this function is the same as calling the
two-argument form with an empty map as the value of the $options
argument.
The first argument $input is a node; the subtree rooted at this node will typically be
the XML representation of a JSON document as defined in
If $input is the empty sequence, the function returns the empty sequence.
The $options argument can be used to control the way in which the conversion
takes place. The
The entries that may appear in the $options map are as follows:
The node supplied as $input must be one of the following:
An element node whose name matches the name of a global element declaration in the schema given in
If the type annotation of the element matches the type of the relevant element declaration in the schema (indicating that the element has been validated against the schema), then the element is considered valid.
Otherwise, the processor
Otherwise (if the processor does not attempt validation using the schema),
the processor http://www.w3.org/2005/xpath-functions, is such that validation
against the schema would have an outcome of
The process described here is not precisely equivalent to schema validation.
For example, schema validation will fail if there is an invalid xsi:type
or xsi:nil attribute, whereas this process will ignore such attributes.
An element node E having a key attribute and/or an escaped-key attribute
provided that E would satisfy one of the above
conditions if the key and/or escaped-key attributes were removed.
A document node having exactly one element child and no text node children, where the element child satisfies one of the conditions above.
Furthermore, $input must satisfy the following constraint
(which cannot be conveniently expressed in the schema). Every element M that is a descendant-or-self of
$input and has local name map and namespace URI http://www.w3.org/2005/xpath-functions
must satisfy the following rule: there must not be two distinct children of M (say C/1 and C/2)
such that the normalized key of C/1 is equal to the normalized key of C/2. The normalized key
of an element C is as follows:
If C has the attribute value escaped-key="true", then the value of the
key attribute of C, with all JSON escape sequences replaced by the corresponding Unicode characters
according to the JSON escaping rules.
Otherwise (the escaped-key attribute of C is absent or set to false),
the value of the key attribute of C.
Nodes in the input tree are handled by applying the following rules, recursively. In these rules the term
"an element named N" means "an element node whose local name is N and whose namespace URI is
http://www.w3.org/2005/xpath-functions".
A document node having a single element node child is processed by processing that child.
An element named null results in the output null.
An element $E named boolean results in the output true or false
depending on the result of xs:boolean(fn:string($E))
An element $E named number results in the output of the string
xs:string(xs:double(fn:string($E)))
An element named string results in the output of the string value of the element, enclosed in
quotation marks, with any special characters in the string escaped as described below.
An element named array results in the output of the children of the array element,
each processed by applying these rules recursively: the items in the resulting list are enclosed between square brackets,
and separated by commas.
An element named map results in the output of a sequence of map entries corresponding to
the children of the map element, enclosed between curly braces and separated by commas.
Each entry comprises the value of the key attribute of the child element, enclosed in quotation marks
and escaped as described below, followed by a colon, followed by the result of processing the child element
by applying these rules recursively.
Comments, processing instructions, and whitespace text node children of map and array
are ignored.
Strings are escaped as follows:
If the attribute escaped="true" is present for a string value, or escaped-key="true" for a key value, then:
any valid JSON escape sequence present in the string is copied unchanged to the output;
any invalid JSON escape sequence results in a dynamic error
any unescaped occurrence of quotation mark, backspace, form-feed, newline, carriage return, tab, \", \b, \f, \n, \r, \t, \/
any other codepoint in the range 1-31 or 127-159 is replaced by an escape in the form \uHHHH where HHHH is the upper-case hexadecimal representation of the codepoint value.
Otherwise (that is, in the absence of the attribute escaped="true" for a string value,
or escaped-key="true" for a key value):
any occurrence of backslash is replaced by \\
any occurrence of quotation mark, backspace, form-feed, newline, carriage return, or tab is
replaced by \", \b, \f, \n, \r, or \t respectively;
any other codepoint in the range 1-31 or 127-159 is replaced by an escape in
the form \uHHHH where HHHH is the upper-case hexadecimal representation of the codepoint value.
A dynamic error is raised $options includes an entry whose key is defined in this specification,
and whose value is not a permitted value for that key.
A dynamic error is raised $input is not a document or element node or is not valid according to the schema for the XML representation of
JSONmap element has two children whose normalized key values are the same.
A dynamic error is raised $input includes a string labeled with escaped="true", or
a key labeled with escaped-key="true", where the content of the string or key
contains an invalid JSON escape sequence: specifically, where it contains a backslash (\) that is not followed by one
of the characters ", \, /, b, f, n,
r, t, or u, or where it contains the characters \u
not followed by four hexadecimal digits (that is [0-9A-Fa-f]{4}).
The rule requiring schema validity has a number of consequences, including the following:
The input cannot contain no-namespace attributes, or attributes in the namespace http://www.w3.org/2005/xpath-functions,
except where explicitly allowed by the schema. Attributes in other namespaces, however, are ignored.
Nodes that do not affect schema validity, such as comments, processing instructions, namespace nodes, and whitespace text node
children of map and array, are ignored.
Numeric values are restricted to those that are valid in JSON: the schema disallows positive and negative infinity and NaN.
Duplicate key values are not permitted. \n and \u000A are treated as duplicates even though
the rules in the schema do not treat them as such.
The rule allowing the top-level element to have a key attribute (which is ignored)
allows any element in the output of the fn:json-to-xml function
to be processed: for example, it is possible to take a JSON document, convert it to XML, select
a subtree based on the value of a key attribute, and then convert this subtree
back to JSON, perhaps after a transformation. The rule means that an element with the appropriate name will be
accepted if it has been validated against one of the
types mapWithinMapType, arrayWithinMapType, stringWithinMapType,
numberWithinMapType, booleanWithinMapType, or nullWithinMapType.
The input [1,"is",true].
The input {"Sunday":1,"Monday":2}.
Parses a string supplied in the form of a JSON text, returning the results typically in the form of a map or array.
The effect of the one-argument form of this function is the same as calling the
two-argument form with an empty map as the value of the $options
argument.
The first argument is a JSON text as defined in
If the value of $json-text is the empty sequence, the function returns the empty sequence.
The result will also be an empty sequence if $json-text is the string "null".
The $options argument can be used to control the way in which the parsing
takes place. The
The entries that may appear in the $options map are as follows:
JSON-text in escape option is set to truefallback function
as described below; in the absence of a fallback function, they are replaced by
the Unicode REPLACEMENT CHARACTER (xFFFD)all codepoints in the range x00 to x1F
or x7F to x9F;
all codepoints that do not represent characters that are valid in the version of XML supported by the processor, including codepoints representing unpaired surrogates;
the backslash character itself (x5C).
\t), or a six-character escape sequence otherwise
(for example \uDEAD). Characters other than these are not escaped in the result, even if they
were escaped in the input.
fallback option if the escape option is present
with the value true.
function($s){"�"}: that is,
a function that replaces the escape sequence with the Unicode REPLACEMENT CHARACTER.escape option) that is valid according to the JSON
grammar, whether the special character is represented in the input directly or as an escape sequence.
The function is called once for any surrogate
that is not properly paired with another surrogate. The string supplied as the argument will always be a two- or six- character escape
sequence, starting with a backslash, that conforms to the rules in the JSON grammar (as extended by the
implementation if liberal:true() is specified): for example
\b or \uFFFF or \uDEAD. The function is \x0A). The function returns a string
which is inserted into the result in place of the invalid character. The
function also has the option of raising a dynamic error by calling fn:error.
The various structures that can occur in JSON are transformed recursively to XDM values as follows:
A JSON xs:string; the
associated value may be of any type, and is the result of converting the JSON
value by recursive application of these rules. For example, the JSON text
{"x":2, "y":5} is transformed to the value map{"x":2,
"y":5}.
If duplicate keys are encountered in a JSON duplicates option defined above.
A JSON ["a", "b", null] is transformed to the value
["a", "b", ()].
A JSON xs:string value.
escape and fallback options, as described in the table above.
A JSON xs:double value using
the rules for casting from xs:string to xs:double.
The JSON true and false are
converted to the corresponding xs:boolean values.
The JSON value
A dynamic error $input does not conform to the JSON grammar, unless the option
"liberal":true() is present and the processor chooses to accept the deviation.
A dynamic error "duplicates":"reject" is present and the value of
$input contains a JSON object with duplicate keys.
A dynamic error $options
map contains an entry whose key is defined in this specification and whose value is not valid for that key,
or if it contains an entry with the key fallback when the option "escape":true()
is also present.
The result of the function will be an instance of one of the following types. An
instance of test (or in XQuery, typeswitch) can be used to
distinguish them:
map(xs:string, item()?) for a JSON object
array(item()?) for a JSON array
xs:string for a JSON string
xs:double for a JSON number
xs:boolean for a JSON boolean
empty-sequence() for a JSON null (or for empty input)
If the input starts with a byte order mark, this function ignores it. The byte order mark may have been added to the data stream in order to facilitate decoding of an octet stream to a character string, but since this function takes a character string as input, the byte order mark serves no useful purpose.
The possibility of the input containing characters that are not valid in XML (for example, unpaired surrogates)
arises only when such characters are expressed using JSON escape sequences. The is because the input to the function
is an instance of xs:string, which by definition can only contain characters that are valid in XML.
Reads an external resource containing JSON, and returns the result of parsing the resource as JSON.
The effect of the single-argument call fn:json-doc($H) is the same as the effect of the two-argument call
fn:json-doc($H, map{}) where an empty map is supplied as the second argument.
The effect of the two-argument function call fn:json-doc($H, $M)is equivalent to the function composition
fn:unparsed-text($H) => fn:parse-json($M); except that:
The function
If the resource contains characters that are not valid in the version of XML used by the processor,
then rather than raising an error as fn:unparsed-text#1 does, the function replaces such characters by the equivalent
JSON escape sequence prior to parsing.
Equivalently, the implementation can use some other internal representation of strings that allows non-XML characters to be manipulated.
If the value of $href is the empty sequence, the function returns the empty sequence.
The function may raise any error defined for the fn:unparsed-text or fn:parse-json
functions.
If the input cannot be decoded (that is, converted into a sequence of Unicode codepoints, which may or may not represent characters),
then a dynamic error occurs as with the fn:unparsed-text function.
If the input can be decoded,
then the possibility still arises that the resulting sequence of codepoints includes codepoints that do not represent characters that are valid in the
version of XML that the processor supports. Such codepoints are translated into JSON escape sequences (for example, \uFFFF),
and the JSON escape sequence is then passed to the fallback function specified in the $options argument, which in turn
defaults to a function that returns the Unicode REPLACEMENT CHARACTER (xFFFD).
Returns the number of members in the supplied array.
If $array is empty the function returns zero.
Otherwise, the function returns the number of members in $array.
Note that because an array is an item, the fn:count function when applied to an array always returns 1 (one).
Returns the value at the specified position in the supplied array (counting from 1).
The result is the value of $array($position).
A dynamic error occurs $position is not in the range 1 to
array:size($array) inclusive.
Returns an array containing all the members of a supplied array, except for one member which is replaced with a new value.
The result is an array whose size is array:size($array), in which all
members in positions other than $position are the same as the members in the corresponding position
of $array, and the member in position $position is $member.
The result is equivalent to the result of the expression
$array => array:remove($position) => array:insert-before($position, $member).
A dynamic error occurs $position is not in the range 1 to
array:size($array) inclusive.
This error will always occur if $array is empty.
Returns an array containing all the members of a supplied array, plus one additional member at the end.
The result is an array whose size is array:size($array) + 1, in which all
members in positions 1 to array:size($array) are the same as the members in the corresponding position
of $array, and the member in position array:size($array) + 1 is $appendage.
The result is equivalent to the result of the expression
op:array-concat( $array, [$appendage] ).
Concatenates the contents of several arrays into a single array.
The function can be expressed as follows in XQuery:
declare function array:join($arrays as array(*)*) as array(*) {
if (fn:empty($arrays))
then []
else if (fn:count($arrays) eq 1)
then $arrays
else
op:array-concat(fn:head($arrays), array:join(fn:tail($arrays)))
};Returns an array containing all members from a supplied array starting at a supplied position, up to a specified length.
$length equal to the value of array:size($array) -
$start + 1.
The result of the three-argument version of the function is given by the expression
array:join( ($start to $start + $length - 1) ! [$array(.)] )
A dynamic error is raised $start is less than one
array:size($array) + 1
For the three-argument version of the function:
A dynamic error is raised $length is less than zero.
A dynamic error is raised $start + $length is greater than array:size($array) + 1.
The value of $start can be equal to array:size($array) + 1 provided that $length
is either equal to zero or omitted. In this case the result will be an empty array.
Returns an array containing all the members of the supplied array, except for the
The function returns an array of size array:size($array) - fn:count(fn:distinct-values($positions))$array
$positions.
The order of the remaining members is preserved.
The result of the function, except in error cases, is given by the expression
array:join(for $i in (1 to array:size($array))[not(. = $positions)] return [$array($i)])
A dynamic error is raised $positions is not in the range 1 to
array:size($array) inclusive. By implication, an error occurs if $array is empty, unless $positions
is also empty.
Returns an array containing all the members of the supplied array, with one additional member at a specified position.
The function returns an array of size array:size($array) + 1 containing all members from $array
whose position is less than $position, then a new member given by $member, and
then all members from $array whose position is greater than or equal to $position.
Positions are counted from 1.
The result is equivalent to the result of the expression
array:join( (array:subarray($array, 1, $position - 1), [$member], array:subarray($array, $position)) )
A dynamic error occurs $position is not in the range 1 to
array:size($array) + 1 inclusive.
Setting $position to 1 has the effect of prepending the new member at the start of the array. Setting $position
to the value array:size($array) + 1 delivers the same result as array:append($array, $member).
Returns the first member of an array, that is $array(1).
The function returns first member of $array, that is the value of $array(1).
A dynamic error occurs $array is empty.
Returns an array containing all members except the first from a supplied array.
The function returns an array containing all members of the supplied array except the first,
that is array:remove($array, 1).
A dynamic error occurs $array is empty.
If the supplied array contains exactly one member, the result will be an empty array.
Returns an array containing all the members of a supplied array, but in reverse order.
The function returns the result of the expression:
array:join( fn:reverse(1 to array:size($array)) ! [$array(.)] )
Returns an array whose size is the same as array:size($array), in which
each member is computed by applying $function to the corresponding member of
$array.
Returns the result of the expression:
array:join( (1 to array:size($array)) ! [ $action($array(.)) ] )
Returns an array containing those members of the $array for which
$function returns true.
The effect of the function is equivalent to the following recursive definition:
As a consequence of the function signature and the function calling rules, a type error occurs if the supplied
function $function returns anything other than a single xs:boolean item; there is no conversion
to an effective boolean value.
Evaluates the supplied function cumulatively on successive members of the supplied array.
The effect of the function is equivalent to the following recursive definition:
If the supplied array is empty, the function returns $zero.
If the supplied array contains a single member $m, the function returns $zero => $function($m).
If the supplied array contains two members $m and $n, the function returns
$zero => $function($m) => $function($n); and similarly for an input array with more than two members.
true().true().Evaluates the supplied function cumulatively on successive values of the supplied array.
The effect of the function is equivalent to the following recursive definition:
If the supplied array is empty, the function returns $zero.
If the supplied array contains a single member $m, the function returns $function($m, $zero).
If the supplied array contains two members $m and $n, the function returns
$function($m, $function($n, $zero)); and similarly for an input array with more than two members.
true().true().Returns an array obtained by evaluating the supplied function once for each pair of members at the same position in the two supplied arrays.
Returns the result of the recursive expression:
if (array:size($array1) eq 0 or array:size($array2) eq 0)
then [ ]
else array:concat(
$function(array:head($array1), array:head($array2)),
array:for-each-pair(array:tail($array1), array:tail($array2), $function)
)
If the arrays have different size, excess members in the longer array are ignored.
Returns an array containing all the members of the supplied array, sorted according to the value of a sort key supplied as a function.
Calling the single-argument version of the function is equivalent to calling the two-argument form
with default-collation() as the second argument: that is, it sorts the members of an array according
to the typed value of the items, using the default collation to compare strings.
Calling the two-argument version of the function is equivalent to calling the three-argument form
with fn:data#1 as the third argument: that is, it sorts the members of an array according
to the typed value of the items, using a specified collation to compare strings.
In the case of both array:sort#2 and array:sort#3, supplying an empty
sequence as the second argument is equivalent to supplying fn:default-collation(). For more
information on collations see
The result of the function is obtained as follows:
For each member of the array $array, the function supplied as $key
is evaluated with that member as its argument.
The resulting values are the sort keys of the members of the array.
The result array contains the same members as the input array $array, but generally in a different order.
Let $C be the selected collation, or the default collation where applicable.
The order of items in the result is such that, given two items $A and $B:
If (fn:deep-equal($key($A), $key($B), $C), then the relative order of $A and $B
in the output is the same as their relative order in the input (that is, the sort is stable)
Otherwise, if (deep-less-than($key($A), $key($B), $C), then $A precedes $B in the output.
The function deep-less-than is defined as the boolean result of the expression:
if (fn:empty($A))
then fn:exists($B)
else if (fn:deep-equal($A[1], $B[1], $C))
then deep-less-than(fn:tail($A), fn:tail($B), $C)
else if ($A[1] ne $A[1] (:that is, $A[1] is NaN:))
then fn:true()
else if (is-string($A[1]) and is-string($B[1])
then fn:compare($A[1], $B[1], $C) lt 0
else $A[1] lt $B[1]where the function is-string($X) returns true if and only if $X is an instance of
xs:string, xs:anyURI, or xs:untypedAtomic.
This ordering of sequences is referred to by mathematicians as "lexicographic ordering".
If the set of computed sort keys contains values that are not comparable using the le operator then the sort
operation will fail with a dynamic error.
To sort an array of strings $in using Swedish collation:
To sort an array of maps representing employees, using last name as the major sort key and first name as the minor sort key, with the default collation:
Replaces any array appearing in a supplied sequence with the members of the array, recursively.
The function processes the items in the supplied sequence $input as follows:
An item that is an array is replaced by its members, retaining order.
Any other item is retained unchanged.
The process is then repeated so long as the sequence contains an array among its items.
The function is equivalent to the following XQuery implementation (assuming static typing is not in force):
declare function flatten ($S as item()*) {
for $s in $S return (
typeswitch($s)
case $a as array(*) return flatten($a?*)
default return $s
)}The argument to the function will often be a single array item, but this is not essential.
Unlike atomization, this function retains any nodes contained in the array.
Provides access to the public functions and global variables of a dynamically-loaded XQuery library module.
The function loads an implementation-defined set of modules having the target namespace $module-uri.
Calling the one-argument version of the function has the same effect as calling the two-argument version with an empty map as the second argument.
The $options argument can be used to control the way in which the function operates.
The
xs:string values) which may be used or ignored in an
The result of the function is a map R with two entries:
There is an entry whose key is the xs:string value "variables" and whose associated value
is a map V. This map (V) contains one entry for each public global variable declared in the library module.
The key of the
entry is the name of the variable, as an xs:QName value; the associated value is the value of the variable.
There is an entry whose key is the xs:string value "functions" and whose associated value
is a map F. This map (F) contains one entry for each public function declared in the library module, except that when two functions
have the same name (but different arity), they share the same entry. The key of the
entry is the name of the function(s), as an xs:QName value; the associated value is a map A.
This map (A) contains one entry for each function with the given name; its key is the arity of the function,
as an xs:integer value, and its associated value is the function itself, as a function item. The function
can be invoked using the rules for dynamic function invocation.
The static and dynamic context of the library module are established according to the rules in
It is
The library module that is loaded may import other modules using an import module declaration. The result of
fn:load-xquery-module does not include global variables or functions declared in such a transitively-imported module.
However, the options map supplied in the function call
The library module that is loaded may import schema declarations using an import schema declaration. It is
Where nodes are passed to or from the dynamically loaded module, for example as an argument or result of a function,
they
If $module-uri is a zero length string, a dynamic error is raised
If the implementation is not able to find a library module with the specified target namespace,
an error is raised
If a static error (including a statically-detected type error) is encountered when processing the library module,
a dynamic error is raised
If the imported module requires a value for the initial context item or for an external variable, and no value is supplied, an error is raised [FOQM0004]
If a value is supplied for the initial context item or for an external variable and the value does not conform to the required
type declared in the dynamically loaded module, a dynamic error is raised
If no suitable XQuery processor is available, a dynamic error is raised
No XQuery processor is available;
Use of the function has been disabled;
No XQuery processor supporting the requested version of XQuery is available;
No XQuery processor supporting the optional Module Feature is available.
If the supplied options are invalid according to the rules of the
If a dynamic error (including a dynamically-detected type error) is encountered when processing the module
(for example, when evaluating its global variables), the dynamic error is returned
As with all other functions in this specification, conformance requirements depend on the host language. For example, a host language might specify that provision of this function is optional, or that it is excluded entirely, or that implementations are required to support XQuery modules using a specified version of XQuery.
Even where support for this function is mandatory, it is
Invokes a transformation using a dynamically-loaded XSLT stylesheet.
This function loads an XSLT stylesheet and invokes it to perform a transformation.
The inputs to the transformation are supplied in the form of a map.
The
The function first identifies the
If the xslt-version
option is present, the requested XSLT version is the value of that option.
Otherwise, the requested XSLT version
is the value of the [xsl:]version attribute of the outermost element in the supplied stylesheet or package.
The function then attempts to locate an XSLT processor that implements the requested XSLT version.
If a processor that implements the requested XSLT version is available, then it is used.
Otherwise, if a processor that implements a version later than the requested version is available, then it is used.
Otherwise, the function fails indicating that no suitable XSLT processor is available.
The phrase
If more than one XSLT processor is available under the above rules, then the one that is chosen may be selected according to the availability of requested features: see below.
Once an XSLT processor has been selected that implements a given version of XSLT, the processor
follows the rules of that version of the XSLT specification. This includes any decision to operate in backwards or forwards
compatibility mode. For example, if an XSLT 2.0 processor is selected, and the stylesheet specifies version="1.0",
then the processor will operate in backwards compatibility mode; if the same processor is selected and the stylesheet
specifies version="3.0", the processor will operate in forwards compatibility mode.
The combinations of options that are relevant to each version of XSLT, other than xslt-version
itself, are listed below. This is followed by a table giving the meaning of each option.
For invocation of an XSLT 1.0 processor (see
The stylesheet, provided by supplying exactly one of the following:
stylesheet-locationstylesheet-nodestylesheet-textThe source tree, provided as the value of the source-node option.
Zero or more of the following additional options:
stylesheet-base-uristylesheet-params (defaults to an empty map)initial-mode (defaults to the unnamed mode)delivery-format (defaults to document)serialization-params (defaults to an empty map)enable-messages (default is implementation-defined)requested-properties (default is an empty map)vendor-options (defaults to an empty map)cache (default is implementation-defined)For invocation of an XSLT 2.0 processor (see
The stylesheet, provided by supplying exactly one of the following:
stylesheet-locationstylesheet-nodestylesheet-textInvocation details, as exactly one of the following:
For apply-templates invocation, all of the following:
source-node
Optionally, initial-mode (defaults to the unnamed mode)
For call-template invocation, all of the following:
initial-template
Optionally, source-node
Zero or more of the following additional options:
stylesheet-base-uristylesheet-params (defaults to an empty map)base-output-uri (defaults to absent)delivery-format (defaults to document)serialization-params (defaults to an empty map)enable-messages (default is implementation-defined)enable-trace (default is implementation-defined)requested-properties (default is an empty map)vendor-options (defaults to an empty map)cache (default is implementation-defined)For invocation of an XSLT 3.0 processor (see
The stylesheet, provided either by supplying exactly one of the following:
stylesheet-locationstylesheet-nodestylesheet-textOr by supplying exactly one of the following:
package-locationpackage-nodepackage-textpackage-name plus optionally package-versionInvocation details, as exactly one of the following combinations:
For apply-templates invocation, all of the following:
Exactly one of source-node or initial-match-selection
Optionally, initial-mode
Optionally, template-params
Optionally, tunnel-params
For call-template invocation using an explicit template name, all of the following:
initial-template
Optionally, template-params
Optionally, tunnel-params
Optionally, source-node
For call-template invocation using the defaulted template name xsl:initial-template, all of the following:
Optionally, template-params
Optionally, tunnel-params
If the source-node option is present and initial-template is absent,
then apply-templates invocation will be used. To use call-template invocation on the template
named xsl:initial-template while also supplying a context item for use when evaluating
global variables, either (a) supply the context item using the global-context-item option,
or (b) supply source-node, and set the initial-template option explicitly to the
QName xsl:initial-template
For call-function invocation, all of the following:
initial-function
function-params
The invocation method can be determined as the first of the following which applies:
If initial-function is present, then call-function invocation.
If initial-template is present, then call-template invocation.
If source-node or initial-match-selection
is present, then apply-templates invocation.
Otherwise, call-template invocation using
the default entry point xsl:initial-template.
Zero or more of the following additional options:
stylesheet-base-uristatic-params (defaults to an empty map)stylesheet-params (defaults to an empty map)global-context-item (defaults to absent)base-output-uri (defaults to absent)delivery-formatserialization-params (defaults to an empty map)enable-assertions (default is false)enable-messages (default is implementation-defined)enable-trace (default is implementation-defined)requested-properties (default is an empty map)vendor-options (defaults to an empty map)cache (default is implementation-defined)The meanings of each option are defined in the table below.
fn:transform
function call. true indicates an expectation that the same
stylesheet is likely to be used for more than one transformation; the value
false indicates an expectation that the stylesheet will be used once
only.xsl:result-document.document, unless the relevant
xsl:output or xsl:result-document element specifies
build-tree="no" (applies to XSLT 3.0 only), in which case the default
is raw.fn:serialize function) the final encoding stage of
serialization (which turns a sequence of characters into a sequence of
octets) is either skipped, or reversed by decoding the octet stream back
into a character stream.xsl:assert instructions in the stylesheet
are to be evaluated.xsl:message instructions in the stylesheet
are to be evaluated. The destination and formatting of any such messages is
implementation-defined.fn:trace functions in the stylesheet are to
generate diagnostic messages. The destination and formatting of any such messages is
implementation-defined.source-nodefunction-params.source-nodefn:transform function (for example, this will be the supplied
base output URI in the case of the principal result, or the string "output" if no
base output URI was supplied). The second argument is the
actual value. The value that is returned in the result of the fn:transform
function is the result of applying this post-processing.
If the implementation provides a way of writing or invoking functions
with side-effects, this post-processing function might be used to save
a copy of the result document to persistent storage. For example, if the
implementation provides access to the EXPath File library file:write function. Similar mechanisms might be used to issue
an HTTP POST request that posts the result to an HTTP server, or to send
the document to an email recipient. The semantics of calling functions
with side-effects are entirely
If the primary purpose of the post-processing function is achieved by
means of such side-effects, and if the actual results are not needed by
the caller of the fn:transform function, then it does not matter what
the post-processing function actually returns (it could be an empty
sequence, for example).
Calls to fn:transform can potentially have side-effects
even in the absence of the post-processing option, because the XSLT
specification allows a stylesheet to invoke extension functions
that have side-effects. The semantics in this case are
system-property function; the values in the map are the requested
settings of the corresponding property. The boolean values true() and
false() are equivalent to the string values yes and
no. As a special case, setting a value for xsl:version has
no effect, because of the potential for conflict with other options. For example: Setting xsl:product-name to a particular value requests a
particular XSLT software product.
Setting xsl:product-version requests a specific version of
that product.
Setting xsl:is-schema-aware to true() requests a
schema-aware processor.
Setting xsl:xsd-version to "1.1" requests a
processor that supports XML Schema version 1.1.
xsl:supports-dynamic-evaluation
to false() is interpreted as an explicit request for a processor in which
the value of the property is false. The effect if the requests cannot be precisely met
is implementation-defined. In some cases it may be appropriate to ignore the request or
to provide an alternative (for example, a later version of the product than the one
requested); in other cases it may be more appropriate to raise an error fn:serialize. When a parameter is supplied, the corresponding value overrides or augments
the value specified in the unnamed xsl:output declaration (or
its default), following the same rules as when one xsl:output
declaration overrides another with lower import precedence.
When a parameter is supplied and the corresponding value is an empty
sequence (for example, map{"standalone":()}), any value
specified in the unnamed xsl:output declaration is overridden
by the default value.
When a parameter is not supplied in serialization-params (that
is, when the key is absent) the value that applies is the value appearing in
the unnamed xsl:output declaration, or its default.
source-node is supplied then the
global-context-item (the context item for evaluating global variables)
is the root of the tree containing the supplied node. In addition, for apply-templates
invocation, the source-node acts as the
initial-match-selection, that is, stylesheet execution starts by
applying templates to this node.stylesheet-node or
stylesheet-location) then it is fn:transform function call.fn:transform function call.
The value also acts as the default for stylesheet-base-uri.[xsl:]version attribute at the outermost level of the
stylesheet.The result of the transformation is returned as a map. There is one entry in the map for the principal result document, and one
for each secondary result document. The key is a URI in the form of an xs:string value. The key for the principal
result document is the base output URI if specified, or the string "output" otherwise. The key for secondary
result documents is the URI of the document, as an absolute URI. The associated value in each entry depends on the requested
delivery format. If the delivery format is document, the value is a document node. If the delivery format is
serialized, the value is a string containing the serialized result. saved,
the value is the absolute URI of the location where the serialized result has been saved. The saved document will not be accessible
at this location within the current
Where nodes are passed to or from the transformation, for example as the value of a stylesheet parameter or the result of a function,
they
It is
The function is fn:current-dateTime is different for the two invocations,
or because the contents of external documents accessed using fn:doc or xsl:source-document change between
one invocation and the next.
The delivery format saved indicates that the transformation should modify the state of the external environment.
This has two noteworthy consequences:
It creates a potential security risk.
The fn:transform function ceases to be a pure function, because it has side-effects.
Implementations
Use of the delivery-format=saved option
The environment that the delivery-format=saved option is allowed to modify fn:doc and fn:collection to access such resources.
Creating multiple resources with the same URI
The implementation may define circumstances in which the side-effect of creating external resources is thwarted as a consequence of query optimization (for example, any situation in which a query calls fn:transform but has no functional dependency on the result of the call).
There
A dynamic error is raised
No XSLT processor is available;
No XSLT processor supporting the requested version of XSLT is available;
The XSLT processor API does not support some requested feature (for example, the ability to supply tunnel parameters externally);
A dynamic error is raised
If a static or dynamic error is reported by the XSLT processor, this function fails with a dynamic error, retaining the XSLT error code.
A dynamic error is raised fn:transform fails with a static or dynamic error, and no more specific error code is available.
XSLT 1.0 does not define any error codes, so this is the likely outcome with an XSLT 1.0 processor. XSLT 2.0 and 3.0 do
define error codes, but some APIs do not expose them. If multiple errors are signaled by the transformation (which is most likely
to happen with static errors) then the error code should where possible be that of one of these errors, chosen arbitrarily; the processor
may make details of additional errors available to the application in an
A dynamic error is raised
A dynamic error is raised delivery-format is saved
and the results cannot be saved at the specified location.
A dynamic error is raised
A dynamic error is raised delivery-format:saved
is used in a way that violates any implementation-defined restrictions on its use.
Recursive use of the fn:transform function may lead to catastrophic failures such as
non-termination or stack overflow. No error code is assigned to such conditions, since they cannot necessarily
be detected by the processor.
As with all other functions in this specification, conformance requirements depend on the host language.
For example, a host language might specify that provision of this function is optional, or that it is excluded entirely,
or that implementations are required to support a particular set of values for the xslt-version
parameter.
Even where support for this function is mandatory, it is
The following example loads a stylesheet from the location render.xsl,
applies it to a document loaded from test.xml, and uses an XPath expression
to examine the result:
Returns a random number generator, which can be used to generate sequences of random numbers.
The function returns a random number generator. A random number generator is represented as a map containing three entries. The keys of each entry are strings:
The entry with key "number" holds a random number; it is an xs:double greater than or equal
to zero (0.0e0), and less than one (1.0e0).
The entry with key "next" is a zero-arity function that can be called to return another random number
generator.
The properties of this function are as follows:
name: absent
parameter names: ()
signature: () => map(xs:string, item())
non-local variable bindings: none
implementation: implementation-dependent
The entry with key "permute" is a function with arity 1 (one), which takes an arbitrary sequence
as its argument, and returns a random permutation of that sequence.
The properties of this function are as follows:
name: absent
parameter names: ("arg")
signature: (item()*) => item()*
non-local variable bindings: none
implementation: implementation-dependent
Calling the fn:random-number-generator function with no arguments is equivalent to calling the single-argument
form of the function with an implementation-dependent seed.
Calling the fn:random-number-generator function with an empty sequence as the value of $seed
is equivalent to calling the single-argument form of the function with an implementation-dependent seed.
If a $seed is supplied, it may be an atomic value of any type.
Both forms of the function are
The value of the number entry xs:double
values are equally likely to be chosen.
The function returned in the permute entry
The map returned by the fn:random-number-generator function map(xs:string, item()). The meaning of any additional entries
is
It is not meaningful to ask whether the functions returned in the next and permute
functions resulting from two separate calls with the same seed are "the same function", but the functions must be equivalent in the sense
that calling them produces the same sequence of random numbers.
The repeatability of the results of function calls in different execution scopes is outside the scope of this
specification. It is fn:current-dateTime() as a seed.)
The specification does not place strong conformance requirements on the actual randomness of the result; this is left to the implementation. It is desirable, for example, when generating a sequence of random numbers that the sequence should not get into a repeating loop; but the specification does not attempt to dictate this.
The following example returns a random permutation of the integers in the range 1 to 100:
fn:random-number-generator()?permute(1 to 100)
The following example returns a 10% sample of the items in an input sequence $seq, chosen at random:
fn:random-number-generator()?permute($seq)[position() = 1 to (count($seq) idiv 10)]
The following code defines a function that can be called to produce a random sequence of xs:double
values in the range zero to one, of specified length: