Constructs an `xs:QName`

value given a namespace URI and a lexical
QName.

This function is

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 `$paramQName`

does
not have the correct lexical form for an instance of `xs:QName`

.

A `$paramURI`

is the
zero-length string or the empty sequence, and the value of `$paramQName`

contains a colon (`:`

).

A `$paramURI`

is not a valid URI (XML Namespaces 1.0) or
IRI (XML Namespaces 1.1).

Returns the absolute value of `$arg`

.

This function is

General rules: see

If `$arg`

is negative the function returns `-$arg`

, otherwise it
returns `$arg`

.

If the type of `$arg`

is one of the four numeric types `xs:float`

,
`xs:double`

, `xs:decimal`

or `xs:integer`

the type
of the result is the same as the type of `$arg`

. If the type of
`$arg`

is a type derived from one of the numeric types, the result is an
instance of the base numeric type.

For `xs:float`

and `xs:double`

arguments, if the argument is
positive zero or negative zero, then positive zero is returned. If the argument is
positive or negative infinity, positive infinity is returned.

For detailed type semantics, see [Formal Semantics].

The expression `fn:abs(10.5)`

returns `10.5`

.

The expression `fn:abs(-10.5)`

returns `10.5`

.

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.

The one-argument form of this function is

The two-argument form of this function is

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 `$timezone`

is less
than `-PT14H`

or greater than `PT14H`

or is not an integral number
of minutes.

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.

The one-argument form of this function is

The two-argument form of this function is

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 `$timezone`

is less
than `-PT14H`

or greater than `PT14H`

or is not an integral number
of minutes.

Adjusts an `xs:dateTime`

value to a specific timezone, or to no
timezone at all.

The one-argument form of this function is

The two-argument form of this function is

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 `$timezone`

is less
than `-PT14H`

or greater than `PT14H`

or is not an integral number
of minutes.

Adjusts an `xs:dateTime`

value to a specific timezone, or to no
timezone at all.

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

.

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

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

.

`$timezone`

is less
than `-PT14H`

or greater than `PT14H`

or is not an integral number
of minutes.

Adjusts an `xs:time`

value to a specific timezone, or to no timezone
at all.

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

.

`$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 `$timezone`

is less
than `-PT14H`

or greater than `PT14H`

or if does not contain an
integral number of minutes.

Adjusts an `xs:time`

value to a specific timezone, or to no timezone
at all.

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

`$arg`

does not have a timezone component and `$timezone`

is
the empty sequence, then the result is `$arg`

.

`$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 `$timezone`

is less
than `-PT14H`

or greater than `PT14H`

or if does not contain an
integral number of minutes.

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.

This function is

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, containing the
definitions below. The returned element and its descendants will have type annotations
obtained by validating the returned element against this schema, unless the function is
used in an environment where type annotations are not supported (for example, a Basic
XSLT Processor), in which case the elements will all be annotated as
`xs:untyped`

and the attributes as `xs:untypedAtomic`

.

A free-standing copy of this schema can be found at

A `$pattern`

is invalid according to the rules described in section

A `$flags`

is invalid according to the rules described in section

A `$pattern`

matches a zero-length string, that is, if ```
fn:matches("",
$pattern, $flags)
```

returns `true`

.

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.

This function is

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, containing the
definitions below. The returned element and its descendants will have type annotations
obtained by validating the returned element against this schema, unless the function is
used in an environment where type annotations are not supported (for example, a Basic
XSLT Processor), in which case the elements will all be annotated as
`xs:untyped`

and the attributes as `xs:untypedAtomic`

.

A free-standing copy of this schema can be found at

A `$pattern`

is invalid according to the rules described in section

A `$flags`

is invalid according to the rules described in section

A `$pattern`

matches a zero-length string, that is, if ```
fn:matches("",
$pattern, $flags)
```

returns `true`

.

Returns a list of environment variable names that are suitable for passing to
`fn:environment-variable`

, as a (possibly empty) sequence of strings.

This function is

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.

Returns the average of the values in the input sequence `$arg`

, that
is, the sum of the values divided by the number of values.

This function is

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 contain items of a single
type, which must be one of the four numeric types, `xs:yearMonthDuration`

or
`xs:dayTimeDuration`

or one if its subtypes.

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.

For detailed type semantics, see [Formal Semantics].

A type error is raised

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 other cases, `fn:boolean`

raises a type error

The static semantics of this function are described in [Formal Semantics].

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`

.

let `$abc`

:= `("a", "b", "")`

`fn:boolean($abc)`

raises a type error

The expression `fn:boolean($abc[1])`

returns `true()`

.

The expression `fn:boolean($abc[0])`

returns `false()`

.

The expression `fn:boolean($abc[3])`

returns `false()`

.

Rounds `$arg`

upwards to a whole number.

This function is

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`

.

If the type of `$arg`

is one of the four numeric types `xs:float`

,
`xs:double`

, `xs:decimal`

or `xs:integer`

the type
of the result is the same as the type of `$arg`

. If the type of
`$arg`

is a type derived from one of the numeric types, the result is an
instance of the base numeric type.

For `xs:float`

and `xs:double`

arguments, if the argument is
positive zero, then positive zero is returned. If the argument is negative zero, then
negative zero is returned. If the argument is less than zero and greater than -1,
negative zero is returned.

For detailed type semantics, see [Formal Semantics].

The expression `fn:ceiling(10.5)`

returns `11`

.

The expression `fn:ceiling(-10.5)`

returns `-10`

.

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

This function is

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.

Creates an `xs:string`

from a sequence of

This function is

The function returns the string made up from the `$arg`

. This will be the zero-length string if `$arg`

is the empty sequence.

A `$arg`

is not a permitted XML character.

Returns a sequence of nodes representing a collection of documents indentified by a collection URI; or a default collection if no URI is supplied.

This function is

This function takes an `xs:string`

as argument and returns a sequence of
nodes obtained by interpreting `$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 the nodes in
the default node collection in the dynamic context. See

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 the returned nodes should be in document order, nor is there a requirement that the result should contain no duplicates.

For detailed type semantics, see [Formal Semantics].

A

A

A `$arg`

is not a
valid `xs:anyURI`

.

Returns a sequence of nodes representing a collection of documents indentified by a collection URI; or a default collection if no URI is supplied.

This function is

This function takes an `xs:string`

as argument and returns a sequence of
nodes obtained by interpreting `$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 the nodes in
the default node collection in the dynamic context. See

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 the returned nodes should be in document order, nor is there a requirement that the result should contain no duplicates.

For detailed type semantics, see [Formal Semantics].

A

A

A `$arg`

is not a
valid `xs:anyURI`

.

Returns -1, 0, or 1, depending on whether `$comparand1`

collates
before, equal to, or after `$comparand2`

according to the rules of a selected
collation.

The two-argument form of this function is

The three-argument form of this function is

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.

The expression `fn:compare('abc', 'abc')`

returns `0`

.

The expression `fn:compare('Strasse', 'StraÃŸe')`

returns `0`

. ss

and the (German) character ÃŸ

(sharp-s

). Otherwise, the returned value depends on the
semantics of the default collation.).

The expression ```
fn:compare('Strasse', 'StraÃŸe',
'http://example.com/deutsch')
```

returns `0`

. `http://example.com/deutsch`

includes provisions that equate
ss

and the (German) character ÃŸ

(sharp-s

). Otherwise, the returned value depends on the
semantics of that collation.).

The expression `fn:compare('Strassen', 'StraÃŸe')`

returns `1`

. ss

and the (German) character ÃŸ

(sharp-s

) with less strength than the differences between the
base characters, such as the final n

. ).

Returns -1, 0, or 1, depending on whether `$comparand1`

collates
before, equal to, or after `$comparand2`

according to the rules of a selected
collation.

The two-argument form of this function is

The three-argument form of this function is

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.

The expression `fn:compare('abc', 'abc')`

returns `0`

.

The expression `fn:compare('Strasse', 'StraÃŸe')`

returns `0`

. ss

and the (German) character ÃŸ

(sharp-s

). Otherwise, the returned value depends on the
semantics of the default collation.).

The expression ```
fn:compare('Strasse', 'StraÃŸe',
'http://example.com/deutsch')
```

returns `0`

. `http://example.com/deutsch`

includes provisions that equate
ss

and the (German) character ÃŸ

(sharp-s

). Otherwise, the returned value depends on the
semantics of that collation.).

The expression `fn:compare('Strassen', 'StraÃŸe')`

returns `1`

. ss

and the (German) character ÃŸ

(sharp-s

) with less strength than the differences between the
base characters, such as the final n

. ).

Returns the concatenation of the string values of the arguments.

The two-argument form of this function defines the semantics of the "||" operator.

This function is

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

Returns true if the string `$arg1`

contains `$arg2`

as a
substring, taking collations into account.

The two-argument form of this function is

The three-argument form of this function is

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

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

Returns the number of items in a sequence.

This function is

The function returns the number of items in the value of `$arg`

.

Returns 0 if `$arg`

is the empty sequence.

Returns an `xs:dateTime`

value created by combining an
`xs:date`

and an `xs:time`

.

This function is

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

Returns the day component of an `xs:date`

.

This function is

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`

.

The expression `fn:day-from-date(xs:date("1999-05-31-05:00"))`

returns `31`

.

The expression `fn:day-from-date(xs:date("2000-01-01+05:00"))`

returns `1`

.

Returns the number of days in a duration.

This function is

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`

. The result is obtained by casting
`$arg`

to an `xs:dayTimeDuration`

(see

If `$arg`

is a negative duration then the result will be negative..

If `$arg`

is an `xs:yearMonthDuration`

the function returns 0.

The expression `fn:days-from-duration(xs:dayTimeDuration("P3DT10H"))`

returns `3`

.

The expression `fn:days-from-duration(xs:dayTimeDuration("P3DT55H"))`

returns `5`

.

The expression `fn:days-from-duration(xs:yearMonthDuration("P3Y5M"))`

returns `0`

.

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 two-argument form of this function is

The three-argument form of this function is

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,
the function returns `false`

.

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 both 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
`$i1`

is deep-equal to the typed value
of `$i2`

.

Both element nodes have a type annotation that is `$i1/*`

is
deep-equal to the sequence `$i2/*`

.

Both element nodes have a type annotation that is `$i1/(*|text())`

is
deep-equal to the sequence `$i2/(*|text())`

.

Both element nodes have a type annotation that is

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

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.

A

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 two-argument form of this function is

The three-argument form of this function is

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,
the function returns `false`

.

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 both 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
`$i1`

is deep-equal to the typed value
of `$i2`

.

Both element nodes have a type annotation that is `$i1/*`

is
deep-equal to the sequence `$i2/*`

.

Both element nodes have a type annotation that is `$i1/(*|text())`

is
deep-equal to the sequence `$i2/(*|text())`

.

Both element nodes have a type annotation that is

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

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.

A

Returns the values that appear in a sequence, with duplicates eliminated.

The one-argument form of this function is

The two-argument form of this function is

The function returns the sequence that results from removing from `$arg`

all
but one of a set of values that are equal to one another. Values are compared using the
`eq`

operator, subject to the caveats defined below.

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.

The collation used by this function is determined according to the rules in

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.

The order in which the sequence of values is returned is

Which value of a set of values that compare equal is returned is

The static type of the result is a sequence of prime types as defined in [Formal Semantics].

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.

Returns the values that appear in a sequence, with duplicates eliminated.

The one-argument form of this function is

The two-argument form of this function is

The function returns the sequence that results from removing from `$arg`

all
but one of a set of values that are equal to one another. Values are compared using the
`eq`

operator, subject to the caveats defined below.

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.

The collation used by this function is determined according to the rules in

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.

The order in which the sequence of values is returned is

Which value of a set of values that compare equal is returned is

The static type of the result is a sequence of prime types as defined in [Formal Semantics].

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.

Retrieves a document using a URI supplied as an
`xs:string`

, and returns the corresponding document node.

This function is

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

For detailed type semantics, see [Formal Semantics].

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

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.

A `$uri`

is not a valid URI.

A

A

A

The function returns true if and only if the function
call `fn:doc($uri)`

would return a document node.

This function is

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 `$uri`

is not a valid URI according to the rules applied by the
implementation of `fn:doc`

.

Otherwise, 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 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 one-argument form of this function is

The effect of this function is identical to `is-id`

property. However,
it behaves differently in respect of element nodes with the `is-id`

property. Whereas the `fn:id`

, for legacy reasons, returns the element
that has the `is-id`

property, this parent 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 `IDREF`

s. 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 `$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

absent ,dynamic error If the context item is not a node,

type error .

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 one-argument form of this function is

The effect of this function is identical to `is-id`

property. However,
it behaves differently in respect of element nodes with the `is-id`

property. Whereas the `fn:id`

, for legacy reasons, returns the element
that has the `is-id`

property, this parent 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 `IDREF`

s. 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 `$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

absent ,dynamic error If the context item is not a node,

type error .

Returns true if the argument is the empty sequence.

This function is

If the value of `$arg`

is the empty sequence, the function returns
`true`

; otherwise, the function returns `false`

.

The expression `fn:empty((1,2,3)[10])`

returns `true()`

.

The expression `fn:empty(fn:remove(("hello", "world"), 1))`

returns `false()`

.

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`

starts with a sequence of collation units that provides a
`$arg2`

according to the
collation that is used.

A

Returns true if the string `$arg1`

contains `$arg2`

as a
trailing substring, taking collations into account.

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

Returns the value of a system environment variable, if it exists.

This function is

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.

Calling the `fn:error`

function raises an application-defined
error.

This function is

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

If `fn:error`

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

If `$code`

is the empty sequence then the effective value is the
`xs:QName`

constructed by:

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.

The `$description`

is a natural-language description of the error
condition.

The `$error-object`

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

This function always raises a

Calling the `fn:error`

function raises an application-defined
error.

This function is

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

If `fn:error`

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

If `$code`

is the empty sequence then the effective value is the
`xs:QName`

constructed by:

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.

The `$description`

is a natural-language description of the error
condition.

The `$error-object`

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

This function always raises a

Calling the `fn:error`

function raises an application-defined
error.

This function is

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

If `fn:error`

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

If `$code`

is the empty sequence then the effective value is the
`xs:QName`

constructed by:

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.

The `$description`

is a natural-language description of the error
condition.

The `$error-object`

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

This function always raises a

Calling the `fn:error`

function raises an application-defined
error.

This function is

`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

If `fn:error`

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

If `$code`

is the empty sequence then the effective value is the
`xs:QName`

constructed by:

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

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

`xs:QName`

, then an error code with
namespace URI `NS`

and local part `LP`

will be returned in
the form `NS#LP`

. The namespace URI part of the error code should
therefore not include a fragment identifier.

The `$description`

is a natural-language description of the error
condition.

`$error-object`

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

This function always raises a

Returns `$arg`

if it contains exactly one item. Otherwise, raises an
error.

This function is

Except in error cases, the function returns `$arg`

unchanged.

For detailed type semantics, see [Formal Semantics].

A `$arg`

is an empty
sequence or a sequence containing more than one item.

Returns true if the argument is a non-empty sequence.

This function is

If the value of `$arg`

is a non-empty sequence, the function returns
`true`

; otherwise, the function returns `false`

.

The expression `fn:exists(fn:remove(("hello"), 1))`

returns `false()`

.

The expression `fn:exists(fn:remove(("hello", "world"), 1))`

returns `true()`

.

Returns the `xs:boolean`

value `false`

.

This function is

The result is equivalent to `xs:boolean("0")`

.

The expression `fn:false()`

returns `xs:boolean(0)`

.

Returns those items from the sequence `$seq` for which the supplied
function `$f` returns true.

This function is

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.

Rounds `$arg`

downwards to a whole number.

This function is

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`

.

If the type of `$arg`

is one of the four numeric types `xs:float`

,
`xs:double`

, `xs:decimal`

or `xs:integer`

the type
of the result is the same as the type of `$arg`

. If the type of
`$arg`

is a type derived from one of the numeric types, the result is an
instance of the base numeric type.

For `xs:float`

and `xs:double`

arguments, if the argument is
positive zero, then positive zero is returned. If the argument is negative zero, then
negative zero is returned.

For detailed type semantics, see [Formal Semantics].

The expression `fn:floor(10.5)`

returns `10`

.

The expression `fn:floor(-10.5)`

returns `-11`

.

Processes the supplied sequence from left to right, applying the supplied function repeatedly to each item in turn, together with an accumulated result value.

This function is

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 is `$seq` or
any trailing subsequence of `$seq`.

Processes the supplied sequence from right to left, applying the supplied function repeatedly to each item in turn, together with an accumulated result value.

This function is

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

Returns a string containing an `xs:date`

value formatted for display.

The two-argument form of this function is

The five-argument form of this function is

See

Returns a string containing an `xs:date`

value formatted for display.

The two-argument form of this function is

The five-argument form of this function is

See

Returns a string containing an `xs:dateTime`

value formatted for display.

The two-argument form of this function is

The five-argument form of this function is

See

Returns a string containing an `xs:dateTime`

value formatted for display.

See

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

The two-argument form of this function is

The three-argument form of this function is

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 `mandatory-digit-signs` within the format token `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

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 `mandatory-digit-sign`. There may be zero or
more `optional-digit-signs`, and (if present) these `mandatory-digit-signs`. There may be zero or more
`grouping-separator-signs`. A `grouping-separator-sign` `decimal-digit-pattern`, nor
adjacent to another `grouping-separator-sign`.

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. If `grouping-separator-signs`
appear at regular intervals within the format token, that is if the same grouping
separator appears at positions forming a sequence `N`, 2`N`,
3`N`, ... for some integer value `N` (including the case
where there is only one number in the list), then the sequence is extrapolated to
the left, so grouping separators will be used in the formatted number at every
multiple of `N`. For example, if the format token is `0'000`

then the number one million will be formatted as `1'000'000`

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

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 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 the first kind above (one that consists of decimal
digits), there `①`

(circled
digit one, â‘ ) has a range `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. `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 format modifier `^([co](\(.+\))?)?[at]?$`

.

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

For example, in some languages, ordinal numbers vary 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 `o`

may be
used to indicate the variation of the ordinal number required. The way in which the
variation is indicated will depend on the conventions of the language. For inflected
languages that vary the ending of the word, the `o(-e)`

, `o(-er)`

, `o(-es)`

, `o(-en)`

.

It is

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:

The `a`

or `t`

modifier`a`

and `i`

. In some languages, the first member of
each sequence is the same, and so the format token alone would be ambiguous. `a`

or `t`

modifier,
the default is

A

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

The two-argument form of this function is

The three-argument form of this function is

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 `mandatory-digit-signs` within the format token `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

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 `mandatory-digit-sign`. There may be zero or
more `optional-digit-signs`, and (if present) these `mandatory-digit-signs`. There may be zero or more
`grouping-separator-signs`. A `grouping-separator-sign` `decimal-digit-pattern`, nor
adjacent to another `grouping-separator-sign`.

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. If `grouping-separator-signs`
appear at regular intervals within the format token, that is if the same grouping
separator appears at positions forming a sequence `N`, 2`N`,
3`N`, ... for some integer value `N` (including the case
where there is only one number in the list), then the sequence is extrapolated to
the left, so grouping separators will be used in the formatted number at every
multiple of `N`. For example, if the format token is `0'000`

then the number one million will be formatted as `1'000'000`

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

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 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 the first kind above (one that consists of decimal
digits), there `①`

(circled
digit one, â‘ ) has a range `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. `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 format modifier `^([co](\(.+\))?)?[at]?$`

.

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

For example, in some languages, ordinal numbers vary 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 `o`

may be
used to indicate the variation of the ordinal number required. The way in which the
variation is indicated will depend on the conventions of the language. For inflected
languages that vary the ending of the word, the `o(-e)`

, `o(-er)`

, `o(-es)`

, `o(-en)`

.

It is

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:

The `a`

or `t`

modifier`a`

and `i`

. In some languages, the first member of
each sequence is the same, and so the format token alone would be ambiguous. `a`

or `t`

modifier,
the default is

A

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

The three-argument form of this function is

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

,
`EQName`

as defined in the XPath 3.0 grammar, that is one of the following

A lexical QName, which is expanded using the

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 default decimal format in the static context otherwise.

The evaluation of the

The analysis phase takes as its inputs the

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

A `$decimal-format-name`

argument is
`URIQualifiedName`

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

The three-argument form of this function is

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

,
`EQName`

as defined in the XPath 3.0 grammar, that is one of the following

A lexical QName, which is expanded using the

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 default decimal format in the static context otherwise.

The evaluation of the

The analysis phase takes as its inputs the

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

A `$decimal-format-name`

argument is
`URIQualifiedName`

Returns a string containing an `xs:time`

value formatted for display.

See

Returns a string containing an `xs:time`

value formatted for display.

See

Returns the arity of the function identified by a function item.

This function is

The `fn:function-arity`

function returns the arity (number of arguments) of
the function identified by `$func`

.

The expression `fn:function-arity(fn:substring#2)`

returns `2`

.

The expression `fn:function-arity(function($node){name($node)})`

returns `1`

.

The expression `let $initial := fn:substring(?, 1, 1) return fn:function-arity($initial)`

returns `1`

.

This function returns a string that uniquely identifies a given node.

The zero-argument form of this function is

The one-argument form of this function 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 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.

The returned identifier

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.

The following errors may be raised when `$arg`

is omitted:

If the context item is

absent ,dynamic error If the context item is not a node,

type error .

This function returns a string that uniquely identifies a given node.

The zero-argument form of this function is

The one-argument form of this function 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 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.

The returned identifier

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.

The following errors may be raised when `$arg`

is omitted:

If the context item is

absent ,dynamic error If the context item is not a node,

type error .

Returns the first item in a sequence.

This function is

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 the number of hours in a duration.

This function is

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`

. The result is obtained by casting
`$arg`

to an `xs:dayTimeDuration`

(see

If `$arg`

is a negative duration then the result will be negative..

If `$arg`

is an `xs:yearMonthDuration`

the function returns 0.

The expression `fn:hours-from-duration(xs:dayTimeDuration("P3DT10H"))`

returns `10`

.

The expression `fn:hours-from-duration(xs:dayTimeDuration("P3DT12H32M12S"))`

returns `12`

.

The expression `fn:hours-from-duration(xs:dayTimeDuration("PT123H"))`

returns `3`

.

The expression `fn:hours-from-duration(xs:dayTimeDuration("-P3DT10H"))`

returns `-10`

.

Returns the hours component of an `xs:time`

.

This function is

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`

.

The expression `fn:hours-from-time(xs:time("11:23:00"))`

returns `11`

.

The expression `fn:hours-from-time(xs:time("21:23:00"))`

returns `21`

.

The expression `fn:hours-from-time(xs:time("01:23:00+05:00"))`

returns `1`

.

The expression ```
fn:hours-from-time(fn:adjust-time-to-timezone(xs:time("01:23:00+05:00"),
xs:dayTimeDuration("PT0S")))
```

returns `20`

.

The expression `fn:hours-from-time(xs:time("24:00:00"))`

returns `0`

.

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 one-argument form of this function is

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

s. 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 `$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

absent ,dynamic error If the context item is not a node,

type error .

`ID`

value
matching the value of one or more of the `IDREF`

values supplied in
`$arg`

.

The one-argument form of this function is

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

).

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

).

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

s. 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 `$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

absent ,dynamic error If the context item is not a node,

type error .

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 one-argument form of this function is

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

s are then
included in the list of candidate `xs:ID`

s. 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 `$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

absent ,dynamic error If the context item is not a node,

type error .

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 one-argument form of this function is

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

s are then
included in the list of candidate `xs:ID`

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

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

absent ,dynamic error If the context item is not a node,

type error .

Returns the prefixes of the in-scope namespaces for an element node.

This function is

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

Returns a sequence of positive integers giving the positions within the
sequence `$seq`

of items that are equal to `$search`

.

The two-argument form of this function is

The three-argument form of this function is

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.

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

Returns a sequence constructed by inserting an item or a sequence of items at a given position within an existing sequence.

This function is

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.

For detailed type semantics, see [Formal Semantics].

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 the local part of the supplied QName.

This function is

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`

.

The expression ```
fn:local-name-from-QName(fn:QName("http://www.example.com/example",
"person"))
```

returns `"person"`

.

Converts a string to lower case.

This function is

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 is introduced in Unicode 5.1.

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

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

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

Applies the function item `$f` to every item from the sequence
`$seq` in turn, returning the concatenation of the resulting sequences in
order.

This function is

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

`ordered`

.

Applies the function item `$f` to successive pairs of items taken one
from `$seq1` and one from `$seq2`, returning the concatenation of the
resulting sequences in order.

This function is

The effect of the function is equivalent to the following implementation in XQuery:

or its equivalent in XSLT:

The expression `fn:for-each-pair(("a", "b", "c"), ("x", "y", "z"), concat#2)`

returns `("ax", "by", "cz")`

.

The expression `fn:for-each-pair(1 to 5, 1 to 5, function($a, $b){10*$a + $b}`

returns `(11, 22, 33, 44, 55)`

.

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

This function is

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 `$pattern`

is invalid according to the rules described in

A `$flags`

is invalid according to the rules described in

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

This function is

`$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 `$pattern`

is invalid according to the rules described in

A `$flags`

is invalid according to the rules described in

Returns a value that is equal to the highest value appearing in the input sequence.

The zero-argument form of this function is

The one-argument form of this function is

The following rules are applied to the input sequence `$arg`

:

Values of type `xs:untypedAtomic`

in `$arg`

are cast to
`xs:double`

.

Numeric and `xs:anyURI`

values are converted to
the least common type reachable by a combination of type promotion and subtype
substitution. See

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

If the items in the `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 `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.

For detailed type semantics, see [Formal Semantics].

A type error is raised

Returns a value that is equal to the highest value appearing in the input sequence.

The zero-argument form of this function is

The one-argument form of this function is

The following rules are applied to the input sequence `$arg`

:

Values of type `xs:untypedAtomic`

in `$arg`

are cast to
`xs:double`

.

Numeric and `xs:anyURI`

values are converted to
the least common type reachable by a combination of type promotion and subtype
substitution. See

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

If the items in the `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 `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.

For detailed type semantics, see [Formal Semantics].

A type error is raised

Returns a value that is equal to the lowest value appearing in the input sequence.

The zero-argument form of this function is

The one-argument form of this function is

The following rules are applied to the input sequence:

Values of type `xs:untypedAtomic`

in `$arg`

are cast to
`xs:double`

.

Numeric and `xs:anyURI`

values are converted to
the least common type reachable by a combination of type promotion and subtype
substitution. See

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

If the items in the `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 `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.

For detailed type semantics, see [Formal Semantics].

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`

.

`xs:anyURI`

values are converted to
the least common type reachable by a combination of type promotion and subtype
substitution. See

If the converted sequence is empty, the empty sequence is returned.

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

`$collation`

as the default collation if specified, and with
`$c`

as the converted sequence.

For detailed type semantics, see [Formal Semantics].

Returns the minute component of an `xs:dateTime`

.

This function is

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`

.

The expression `fn:minutes-from-dateTime(xs:dateTime("1999-05-31T13:20:00-05:00"))`

returns `20`

.

The expression `fn:minutes-from-dateTime(xs:dateTime("1999-05-31T13:30:00+05:30"))`

returns `30`

.

Returns the number of minutes in a duration.

This function is

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`

. The result is obtained by casting
`$arg`

to an `xs:dayTimeDuration`

(see

If `$arg`

is a negative duration then the result will be negative..

If `$arg`

is an `xs:yearMonthDuration`

the function returns 0.

The expression `fn:minutes-from-duration(xs:dayTimeDuration("P3DT10H"))`

returns `0`

.

The expression `fn:minutes-from-duration(xs:dayTimeDuration("-P5DT12H30M"))`

returns `-30`

.

Returns the minutes component of an `xs:time`

.

This function is

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`

.

The expression `fn:minutes-from-time(xs:time("13:00:00Z"))`

returns `0`

.

Returns the month component of an `xs:date`

.

This function is

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`

.

The expression `fn:month-from-date(xs:date("1999-05-31-05:00"))`

returns `5`

.

The expression `fn:month-from-date(xs:date("2000-01-01+05:00"))`

returns `1`

.

Returns the number of months in a duration.

This function is

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`

. The result is obtained by casting
`$arg`

to an `xs:yearMonthDuration`

(see

If `$arg`

is a negative duration then the result will be negative..

If `$arg`

is an `xs:dayTimeDuration`

the function returns 0.

The expression `fn:months-from-duration(xs:yearMonthDuration("P20Y15M"))`

returns `3`

.

The expression `fn:months-from-duration(xs:yearMonthDuration("-P20Y18M"))`

returns `-6`

.

The expression `fn:months-from-duration(xs:dayTimeDuration("-P2DT15H0M0S"))`

returns `0`

.

Returns the namespace URI of one of the in-scope namespaces for
`$element`

, identified by its namespace prefix.

This function is

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.

let `$e`

:=

The expression `fn:namespace-uri-for-prefix("z", $e)`

returns `"http://example.org/two"`

.

The expression `fn:namespace-uri-for-prefix("", $e)`

returns `"http://example.org/one"`

.

The expression `fn:namespace-uri-for-prefix((), $e)`

returns `"http://example.org/one"`

.

The expression `fn:namespace-uri-for-prefix("xml", $e)`

returns `"http://www.w3.org/XML/1998/namespace"`

.

The expression `fn:namespace-uri-for-prefix("xml", $e)`

returns `"http://www.w3.org/XML/1998/namespace"`

.

Returns the namespace URI part of the supplied QName.

This function is

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`

.

The expression ```
fn:namespace-uri-from-QName(fn:QName("http://www.example.com/example",
"person"))
```

returns `xs:anyURI("http://www.example.com/example")`

.

Returns the value of `$arg`

with leading and trailing whitespace
removed, and sequences of internal whitespace reduced to a single space character.

The zero-argument form of this function is

The one-argument form of this function is

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

Returns the value of `$arg`

with leading and trailing whitespace
removed, and sequences of internal whitespace reduced to a single space character.

The zero-argument form of this function is

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

Returns the value of `$arg`

after applying Unicode
normalization.

This function is

If the value of `$arg`

is the empty sequence, the function returns the
zero-length string.

If the single-argument version of the function is used, the result is the same as
calling the two-argument version with `$normalizationForm`

set to the string
"NFC".

Otherwise, the function returns the value of `$arg`

normalized according to
the rules of the normalization form identified by the value of
`$normalizationForm`

.

The effective value of `$normalizationForm`

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

.

See

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.

Returns the value of `$arg`

after applying Unicode
normalization.

This function is

If the value of `$arg`

is the empty sequence, the function returns the
zero-length string.

If the single-argument version of the function is used, the result is the same as
calling the two-argument version with `$normalizationForm`

set to the string
"NFC".

Otherwise, the function returns the value of `$arg`

normalized according to
the rules of the normalization form identified by the value of
`$normalizationForm`

.

The effective value of `$normalizationForm`

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

.

See

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.

Returns `true`

if the effective boolean value of `$arg`

is `false`

, or `false`

if it is `true`

.

This function is

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`

.

The expression `fn:not(fn:true())`

returns `false()`

.

The expression `fn:not("false")`

returns `false()`

.

Returns `$arg`

if it contains one or more items. Otherwise, raises
an error.

This function is

Except in error cases, the function returns `$arg`

unchanged.

For detailed type semantics, see [Formal Semantics].

A `$arg`

is an empty
sequence.

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.

This function is

If `$arg`

is the empty sequence, the function returns the
empty sequence.

The precise process used to construct the XDM instance is

The Static Base URI property from the static context of 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 `$arg`

is not a well-formed and namespace-well-formed XML document.

A `$arg`

is not valid against its
DTD.

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.

This function is

If `$arg`

is the empty sequence, the function returns the
empty sequence.

The precise process used to construct the XDM instance is

The Static Base URI property from the static context of 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 `$arg`

is not a well-formed and namespace-well-formed XML document.

A `$arg`

is not valid against its
DTD.

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.

This function is

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 Static Base URI from the static context of 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 `$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.

Returns the prefix component of the supplied QName.

This function is

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 a new sequence containing all the items of `$target`

except
the item at position `$position`

.

This function is

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`

.

For detailed type semantics, see [Formal Semantics].

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 a string produced from the input string by replacing any substrings that match a given regular expression with a supplied replacement string.

This function is

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

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

and there are 5 substrings, the result contains the value of the substring that
matches the second sub-expression, followed by the digit `$23`

.`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 `$pattern`

is invalid according to the rules described in section

A `$flags`

is invalid according to the rules described in section

A ```
fn:matches("", $pattern,
$flags)
```

returns `true`

. It is not an error, however, if a captured
substring is zero-length.

A `$replacement`

contains a "`$`

" character that is not
immediately followed by a digit `0-9`

and not immediately preceded by a
"\".

A `$replacement`

contains a "`\`

" character that is not part of a
"`\\`

" pair, unless it is immediately followed by a "`$`

"
character.

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

This function is

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

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

and there are 5 substrings, the result contains the value of the substring that
matches the second sub-expression, followed by the digit `$23`

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

`$pattern`

is invalid according to the rules described in section

`$flags`

is invalid according to the rules described in section

A ```
fn:matches("", $pattern,
$flags)
```

returns `true`

. It is not an error, however, if a captured
substring is zero-length.

A `$replacement`

contains a "`$`

" character that is not
immediately followed by a digit `0-9`

and not immediately preceded by a
"\".

A `$replacement`

contains a "`\`

" character that is not part of a
"`\\`

" pair, unless it is immediately followed by a "`$`

"
character.

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.

This function is

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 constructs an expanded-QName whose local name is taken
from the supplied `$qname`

, and whose namespace URI is taken from the string
value of the namespace 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 discussed in

A `$qname`

does not
have the correct lexical form for an instance of `xs:QName`

.

A `$qname`

has a
prefix and there is no namespace binding for `$element`

that matches this
prefix.

Reverses the order of items in a sequence.

This function is

The function returns a sequence containing the items in `$arg`

in reverse
order.

For detailed type semantics, see [Formal Semantics].

If `$arg`

is the empty sequence, the empty sequence is returned.

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

This function is

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.

`$arg`

is one of the four numeric types `xs:float`

,
`xs:double`

, `xs:decimal`

or `xs:integer`

the type
of the result is the same as the type of `$arg`

. If the type of
`$arg`

is a type derived from one of the numeric types, the result is an
instance of the base numeric type.

The single-argument version of this function produces the same result as the
two-argument version with `$precision=0`

(that is, it rounds to a whole
number).

When `$arg`

is of type `xs:float`

and `xs:double`

:

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`

.

For detailed type semantics, see [Formal Semantics].

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.

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

This function is

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.

`$arg`

is one of the four numeric types `xs:float`

,
`xs:double`

, `xs:decimal`

or `xs:integer`

the type
of the result is the same as the type of `$arg`

. If the type of
`$arg`

is a type derived from one of the numeric types, the result is an
instance of the base numeric type.

The single-argument version of this function produces the same result as the
two-argument version with `$precision=0`

(that is, it rounds to a whole
number).

When `$arg`

is of type `xs:float`

and `xs:double`

:

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`

.

For detailed type semantics, see [Formal Semantics].

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.

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

This function is

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.

`$arg`

is one of the four numeric types `xs:float`

,
`xs:double`

, `xs:decimal`

or `xs:integer`

the type
of the result is the same as the type of `$arg`

. If the type of
`$arg`

is a type derived from one of the numeric types, the result is an
instance of the base numeric type.

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

.

For arguments of type `xs:float`

and `xs:double`

:

If the argument is `NaN`

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

In all other cases, the argument is cast to `xs:decimal`

`xs:decimal`

value, and the resulting
`xs:decimal`

is cast back to `xs:float`

or
`xs:double`

as appropriate to form the function result. If the
resulting `xs:decimal`

value is zero, then positive or negative zero is
returned according to the sign of the original argument.

For detailed type semantics, see [Formal Semantics].

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.

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

This function is

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.

`$arg`

is one of the four numeric types `xs:float`

,
`xs:double`

, `xs:decimal`

or `xs:integer`

the type
of the result is the same as the type of `$arg`

. If the type of
`$arg`

is a type derived from one of the numeric types, the result is an
instance of the base numeric type.

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

.

For arguments of type `xs:float`

and `xs:double`

:

If the argument is `NaN`

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

In all other cases, the argument is cast to `xs:decimal`

`xs:decimal`

value, and the resulting
`xs:decimal`

is cast back to `xs:float`

or
`xs:double`

as appropriate to form the function result. If the
resulting `xs:decimal`

value is zero, then positive or negative zero is
returned according to the sign of the original argument.

For detailed type semantics, see [Formal Semantics].

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.

Returns the seconds component of an `xs:dateTime`

.

This function is

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`

.

The expression `fn:seconds-from-dateTime(xs:dateTime("1999-05-31T13:20:00-05:00"))`

returns `0`

.

Returns the number of seconds in a duration.

This function is

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`

. The result is obtained by casting
`$arg`

to an `xs:dayTimeDuration`

(see

If `$arg`

is a negative duration then the result will be negative..

If `$arg`

is an `xs:yearMonthDuration`

the function returns 0.

The expression `fn:seconds-from-duration(xs:dayTimeDuration("P3DT10H12.5S"))`

returns `12.5`

.

The expression `fn:seconds-from-duration(xs:dayTimeDuration("-PT256S"))`

returns `-16.0`

.

Returns the seconds component of an `xs:time`

.

This function is

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`

.

The expression `fn:seconds-from-time(xs:time("13:20:10.5"))`

returns `10.5`

.

This function serializes the supplied `$arg`

as described in

This function is

The value of `$arg`

acts as the input sequence to the serialization process,
which starts with sequence normalization.

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 `$params`

argument is used to identify a set of
serialization parameters. These are supplied in the form of an
`output:serialization-parameters`

element, having the format described in

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

If any serialization error occurs, including the detection of an invalid value for a
serialization parameter, this results in the `fn:serialize`

call failing with
a dynamic error.

This function serializes the supplied `$arg`

as described in

This function is

The value of `$arg`

acts as the input sequence to the serialization process,
which starts with sequence normalization.

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 `$params`

argument is used to identify a set of
serialization parameters. These are supplied in the form of an
`output:serialization-parameters`

element, having the format described in

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

If any serialization error occurs, including the detection of an invalid value for a
serialization parameter, this results in the `fn:serialize`

call failing with
a dynamic error.

Returns true if the string `$arg1`

contains `$arg2`

as a
leading substring, taking collations into account.

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

Returns true if the string `$arg1`

contains `$arg2`

as a
leading substring, taking collations into account.

`$arg1`

or `$arg2`

is the empty sequence, or
contains only ignorable collation units, it is interpreted as the zero-length
string.

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

`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

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

This function is

The effect of calling the single-argument version of this function is
the same as calling the two-argument version with `$arg2`

set to a
zero-length string.

The function returns an `xs:string`

created by concatenating the items in the
sequence `$arg1`

, in order, using the value of `$arg2`

as a
separator between adjacent items. If the value of `$arg2`

is the zero-length
string, then the members of `$arg1`

are concatenated without a separator.

If the value of `$arg1`

is the empty sequence, the function returns the
zero-length string.

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

This function is

The effect of calling the single-argument version of this function is
the same as calling the two-argument version with `$arg2`

set to a
zero-length string.

The function returns an `xs:string`

created by concatenating the items in the
sequence `$arg1`

, in order, using the value of `$arg2`

as a
separator between adjacent items. If the value of `$arg2`

is the zero-length
string, then the members of `$arg1`

are concatenated without a separator.

If the value of `$arg1`

is the empty sequence, the function returns the
zero-length string.

Returns the number of

The zero-argument form of this function is

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

Returns the number of

The zero-argument form of this function is

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

Returns the sequence of `xs:string`

value.

This function is

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.

The expression `fn:string-to-codepoints("ThÃ©rÃ¨se")`

returns `(84, 104, 233, 114, 232, 115, 101)`

.

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`

.

This function is

In the two-argument case, returns:

In the three-argument case, returns:

For detailed type semantics, see [Formal Semantics].

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.

If `$startingLoc`

is zero or negative, the subsequence includes items from
the beginning of the `$sourceSeq`

.

If `$length`

is not specified, the subsequence includes items to the end of
`$sourceSeq`

.

If `$length`

is greater than the number of items in the value of
`$sourceSeq`

following `$startingLoc`

, the subsequence includes
items to the end of `$sourceSeq`

.

As an exception to the previous two notes, 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 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`

.

This function is

In the two-argument case, returns:

In the three-argument case, returns:

For detailed type semantics, see [Formal Semantics].

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.

If `$startingLoc`

is zero or negative, the subsequence includes items from
the beginning of the `$sourceSeq`

.

If `$length`

is not specified, the subsequence includes items to the end of
`$sourceSeq`

.

If `$length`

is greater than the number of items in the value of
`$sourceSeq`

following `$startingLoc`

, the subsequence includes
items to the end of `$sourceSeq`

.

As an exception to the previous two notes, 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 portion of the value of `$sourceString`

beginning at the
position indicated by the value of `$start`

and continuing for the number of
`$length`

.

This function is

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

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`

.

This function is

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

Returns the part of `$arg1`

that follows the first occurrence of
`$arg2`

, taking collations into account.

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

Returns the part of `$arg1`

that follows the first occurrence of
`$arg2`

, taking collations into account.

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

Returns the part of `$arg1`

that precedes the first occurrence of
`$arg2`

, taking collations into account.

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

Returns the part of `$arg1`

that precedes the first occurrence of
`$arg2`

, taking collations into account.

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

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

Returns a value obtained by adding together the values in
`$arg`

.

This function is

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

.

For detailed type semantics, see [Formal Semantics].

Returns a value obtained by adding together the values in
`$arg`

.

This function is

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

.

For detailed type semantics, see [Formal Semantics].

Returns all but the first item in a sequence.

This function is

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.

Returns the timezone component of an `xs:date`

.

This function is

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.

The expression `fn:timezone-from-date(xs:date("1999-05-31-05:00"))`

returns `xs:dayTimeDuration("-PT5H")`

.

The expression `fn:timezone-from-date(xs:date("2000-06-12Z"))`

returns `xs:dayTimeDuration("PT0S")`

.

Returns the timezone component of an `xs:dateTime`

.

This function is

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.

The expression `fn:timezone-from-dateTime(xs:dateTime("1999-05-31T13:20:00-05:00"))`

returns `xs:dayTimeDuration("-PT5H")`

.

The expression `fn:timezone-from-dateTime(xs:dateTime("2000-06-12T13:20:00Z"))`

returns `xs:dayTimeDuration("PT0S")`

.

The expression `fn:timezone-from-dateTime(xs:dateTime("2004-08-27T00:00:00"))`

returns `()`

.

Returns the timezone component of an `xs:time`

.

This function is

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.

The expression `fn:timezone-from-time(xs:time("13:20:00-05:00"))`

returns `xs:dayTimeDuration("-PT5H")`

.

The expression `fn:timezone-from-time(xs:time("13:20:00"))`

returns `()`

.

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.

This function is

`$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, or if `$input`

is the
zero-length string, the function returns the empty sequence.

The function returns a sequence of strings formed by breaking the `$input`

string into a sequence of strings, treating any substring that matches
`$pattern`

as a separator. The separators themselves are not returned.

If a separator occurs at the start of the `$input`

string, the result
sequence will start with a zero-length string. Zero-length strings will also occur in
the result sequence if a separator occurs at the end of the `$input`

string,
or if two adjacent substrings match the supplied `$pattern`

.

If two alternatives within the supplied `$pattern`

both match at the same
position in the `$input`

string, then the match that is chosen is the first.
For example:

`$pattern`

is invalid according to the rules described in section

`$flags`

is invalid according to the rules described in section

A `$pattern`

matches a zero-length string, that is, if ```
fn:matches("",
$pattern, $flags)
```

returns `true`

.

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.

This function is

`$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, or if `$input`

is the
zero-length string, the function returns the empty sequence.

The function returns a sequence of strings formed by breaking the `$input`

string into a sequence of strings, treating any substring that matches
`$pattern`

as a separator. The separators themselves are not returned.

If a separator occurs at the start of the `$input`

string, the result
sequence will start with a zero-length string. Zero-length strings will also occur in
the result sequence if a separator occurs at the end of the `$input`

string,
or if two adjacent substrings match the supplied `$pattern`

.

If two alternatives within the supplied `$pattern`

both match at the same
position in the `$input`

string, then the match that is chosen is the first.
For example:

`$pattern`

is invalid according to the rules described in section

`$flags`

is invalid according to the rules described in section

`$pattern`

matches a zero-length string, that is, if ```
fn:matches("",
$pattern, $flags)
```

returns `true`

.

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

This function is

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

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 value of `$arg`

modified by replacing or removing
individual characters.

This function is

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.

Returns the `xs:boolean`

value `true`

.

This function is

The result is equivalent to `xs:boolean("1")`

.

The expression `fn:true()`

returns `xs:boolean(1)`

.

Returns the items of `$sourceSeq`

in an

This function is

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.

The `fn:unparsed-text`

function reads an external resource (for example, a
file) and returns

This function is

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

A `$href`

contains a fragment identifier, or if it cannot be used to retrieve the

A `$encoding`

argument is not a valid encoding name,

A `$encoding`

is absent and the

The `fn:unparsed-text`

function reads an external resource (for example, a
file) and returns

This function is

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

A `$href`

contains a fragment identifier, or if it cannot be used to retrieve the

A `$encoding`

argument is not a valid encoding name,

A `$encoding`

is absent and the

Because errors in evaluating the

This function is

The

If the first argument is an empty sequence, the function returns false.

In other cases, the function returns true if a call on

The functions `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

This requires that the `if (unparsed-text-available(A)) then unparsed-text(A) else ...`

to
generate a single call internally.

Because errors in evaluating the

The

If the first argument is an empty sequence, the function returns false.

In other cases, the function returns true if a call on

The functions `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

This requires that the `if (unparsed-text-available(A)) then unparsed-text(A) else ...`

to
generate a single call internally.

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

The `unparsed-text-lines`

function reads an external resource (for example, a
file) and returns its

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 a 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 a newline sequence, no zero-length string will be returned as the last item in the result.

Error conditions are the same as for the `fn:unparsed-text`

function.

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

The `unparsed-text-lines`

function reads an external resource (for example, a
file) and returns its

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 a 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 a newline sequence, no zero-length string will be returned as the last item in the result.

Error conditions are the same as for the `fn:unparsed-text`

function.

Converts a string to upper case.

This function is

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 is introduced in Unicode 5.1.

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

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

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

Returns a sequence of `xs:anyURI`

values representing the URIs in a resource collection.

This function is

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

A

A

A `$arg`

is not a
valid `xs:anyURI`

.

Returns a sequence of `xs:anyURI`

values representing the URIs in a resource collection.

This function is

The zero-argument form of the function returns the URIs in the

`$arg`

is a relative `xs:anyURI`

, it is resolved
against the value of the base-URI property from the static context.

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

A

A

A `$arg`

is not a
valid `xs:anyURI`

.

Returns the year component of an `xs:date`

.

This function is

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 expression `fn:year-from-date(xs:date("1999-05-31"))`

returns `1999`

.

The expression `fn:year-from-date(xs:date("2000-01-01+05:00"))`

returns `2000`

.

Returns the number of years in a duration.

This function is

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`

. The result is obtained by casting
`$arg`

to an `xs:yearMonthDuration`

(see

If `$arg`

is a negative duration then the result will be negative..

If `$arg`

is an `xs:dayTimeDuration`

the function returns 0.

The expression `fn:years-from-duration(xs:yearMonthDuration("P20Y15M"))`

returns `21`

.

The expression `fn:years-from-duration(xs:yearMonthDuration("-P15M"))`

returns `-1`

.

The expression `fn:years-from-duration(xs:dayTimeDuration("-P2DT15H"))`

returns `0`

.

Returns `$arg`

if it contains zero or one items. Otherwise, raises
an error.

This function is

Except in error cases, the function returns `$arg`

unchanged.

For detailed type semantics, see [Formal Semantics].

A `$arg`

contains more
than one item.

Creates an `xs:string`

from a sequence of

This function is

The function returns the string made up from the `$arg`

. This will be the zero-length string if `$arg`

is the empty sequence.

A `$arg`

is not a permitted XML character.

Returns the sequence of `xs:string`

value.

This function is

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.

The expression `fn:string-to-codepoints("ThÃ©rÃ¨se")`

returns `(84, 104, 233, 114, 232, 115, 101)`

.

Returns the base URI of a node.

The zero-argument form of this function is

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

absent ,dynamic error If the context item is not a node,

type error .

Returns the base URI of a node.

The zero-argument form of this function is

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

absent ,dynamic error If the context item is not a node,

type error .

Returns the current date.

This function is

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

Returns the current date and time (with timezone).

This function is

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

Returns the current time.

This function is

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

Returns the result of atomizing a sequence, that is, replacing all nodes in the sequence by their typed values.

The zero-argument form of this function 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.

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

A `$arg`

is a node that does not have a typed value.

A `$arg`

is a function item.

A `$arg`

is omitted
and the context item is

Returns the result of atomizing a sequence, that is, replacing all nodes in the sequence by their typed values.

The zero-argument form of this function is

`.`

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

A `$arg`

is a node that does not have a typed value.

A `$arg`

is a function item.

A `$arg`

is omitted
and the context item is

Returns the value of the default collation property from the static context.

This function is

Returns the value of the default collation property from the static context. Components
of the static context are discussed 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 URI of a resource where a document can be found, if available.

The zero-argument form of this function is

`.`

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

absent ,dynamic error If the context item is not a node,

type error .

Returns the URI of a resource where a document can be found, if available.

The zero-argument form of this function is

`.`

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

absent ,dynamic error If the context item is not a node,

type error .

Encodes reserved characters in a string that is intended to be used in the path segment of a URI.

This function is

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`

.

Escapes a URI in the same way that HTML user agents handle attribute values expected to contain URIs.

This function is

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 supplied node has one or more child nodes (of any kind).

The zero-argument form of this function is

`.`

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

`$node`

matches the expected
type `node()?`

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

absent ,dynamic error If the context item is not a node,

type error .

Returns true if the supplied node has one or more child nodes (of any kind).

The zero-argument form of this function is

`.`

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

`$node`

matches the expected
type `node()?`

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

absent ,dynamic error If the context item is not a node,

type error .

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

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.

This function is

The effect of the function call `fn:innermost($nodes)`

is defined to be
equivalent to the result of the expression ```
$nodes except
$nodes/ancestor::node()
```

.

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.

Converts a string containing an IRI into a URI according to the rules of

This function is

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-

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

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 one-argument form of this function is

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

absent ,dynamic error If the context item is not a node,

type error .

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 one-argument form of this function is

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

absent ,dynamic error If the context item is not a node,

type error .

Returns the context size from the dynamic context.

This function is

Returns the context size from the dynamic context. (See

A

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`

.

The zero-argument form of this function is

`.`

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

absent ,dynamic error If the context item is not a node,

type error .

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`

.

The zero-argument form of this function is

`.`

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

absent ,dynamic error If the context item is not a node,

type error .

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`

.

The zero-argument form of this function is

`.`

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

absent ,dynamic error If the context item is not a node,

type error .

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`

.

The zero-argument form of this function is

`.`

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

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

absent ,dynamic error 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.

The zero-argument form of this function is

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

absent ,dynamic error 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.

The zero-argument form of this function is

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

absent ,dynamic error If the context item is not a node,

type error .

Returns true for an element that is

The zero-argument form of this function is

`.`

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

absent ,dynamic error If the context item is not a node,

type error .

Returns true for an element that is

The zero-argument form of this function is

`.`

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

absent ,dynamic error If the context item is not a node,

type error .

Returns the name of a node, as an `xs:QName`

.

The zero-argument form of this function is

`.`

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

absent ,dynamic error If the context item is not a node,

type error .

Returns the name of a node, as an `xs:QName`

.

The zero-argument form of this function is

`.`

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

absent ,dynamic error 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`

.

The zero-argument form of this function is

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`

`xs:double`

, the `xs:double`

value
`NaN`

is returned.

Otherwise, `$arg`

`xs:double`

following the rules of `xs:double`

fails, the `xs:double`

value
`NaN`

is returned.

A `$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.

Returns the value indicated by `$arg`

or, if `$arg`

is
not specified, the context item after atomization, converted to an
`xs:double`

.

The zero-argument form of this function is

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`

`xs:double`

, the `xs:double`

value
`NaN`

is returned.

Otherwise, `$arg`

`xs:double`

following the rules of `xs:double`

fails, the `xs:double`

value
`NaN`

is returned.

A `$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.

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.

This function is

The effect of the function call `fn:outermost($nodes)`

is defined to be
equivalent to the result of the expression ```
$nodes[not(ancestor::node() intersect
$nodes)]/.
```

.

That is, the function takes as input a sequence of nodes, and returns every node within
the sequence that

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.

Returns the context position from the dynamic context.

This function is

Returns the context position from the dynamic context. (See

A

Resolves a relative IRI reference against an absolute IRI.

The one-argument form of this function is

If the second argument is absent, the effect is the same as calling the two-argument
function with the value of `fn:static-base-uri()`

as the second argument.

The function is defined to operate on IRI references as defined in

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.

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

A `$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 `$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

Resolves a relative IRI reference against an absolute IRI.

The one-argument form of this function is

If the second argument is absent, the effect is the same as calling the two-argument
function with the value of `fn:static-base-uri()`

as the second argument.

The function is defined to operate on IRI references as defined in

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.

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

A `$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 `$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

Returns the root of the tree to which `$arg`

belongs. This will
usually, but not necessarily, be a document node.

The zero-argument form of this function is

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

absent ,dynamic error 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.

The zero-argument form of this function is

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

absent ,dynamic error If the context item is not a node,

type error .

This function returns the value of the Static Base URI property from the static context.

The function returns the value of the Static Base URI property from the static context. If the property is absent, the empty sequence is returned.

Components of the static context are discussed 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.
In this situation, the `fn:static-base-uri`

function should return a URI suitable for locating resources needed
during dynamic evaluation.

Returns the value of `$arg`

represented as an
`xs:string`

.

The zero-argument form of this function is

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

A

A `$arg`

is a function item.

Returns the value of `$arg`

represented as an
`xs:string`

.

The zero-argument form of this function is

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

A

A `$arg`

is a function item.

Returns a list of environment variable names that are suitable for passing to
`fn:environment-variable`

, as a (possibly empty) sequence of strings.

This function is

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.

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.

The `fn:unparsed-text`

function reads an external resource (for example, a
file) and returns

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

A `$href`

contains a fragment identifier, or if it cannot be used to retrieve the

A `$encoding`

argument is not a valid encoding name,

A `$encoding`

is absent and the

`fn:unparsed-text`

function reads an external resource (for example, a
file) and returns

`$href`

argument

If the value of the `$href`

argument is an empty sequence, the function
returns an empty sequence.

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

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

`$href`

contains a fragment identifier, or if it cannot be used to retrieve the

`$encoding`

argument is not a valid encoding name,

`$encoding`

is absent and the

Because errors in evaluating the

The

If the first argument is an empty sequence, the function returns false.

In other cases, the function returns true if a call on

The functions `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

This requires that the `if (unparsed-text-available(A)) then unparsed-text(A) else ...`

to
generate a single call internally.

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

The `unparsed-text-lines`

function reads an external resource (for example, a
file) and returns its

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 a 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 a newline sequence, no zero-length string will be returned as the last item in the result.

Error conditions are the same as for the `fn:unparsed-text`

function.

`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

`if (unparsed-text-available(A)) then unparsed-text(A) else ...`

to
generate a single call internally.

Returns a sequence of `xs:anyURI`

values representing the URIs in a resource collection.

This function is

The zero-argument form of the function returns the URIs in the

`$arg`

is a relative `xs:anyURI`

, it is resolved
against the value of the base-URI property from the static context.

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

A

A

A `$arg`

is not a
valid `xs:anyURI`

.

Returns a sequence of `xs:anyURI`

values representing the URIs in a resource collection.

`$arg`

is a relative `xs:anyURI`

, it is resolved
against the value of the base-URI property from the static context.

`$arg`

is the empty sequence, the function behaves as if it had been
called without an argument. See above.

A `$arg`

is not a
valid `xs:anyURI`

.