Please
refer
to
the
errata
for
this
document,
which
may
include
some
normative
corrections.
See
also
translations
.
This
document
is
also
available
in
these
nonnormative
formats:
XML
and
Recent
revisions
Change
markings
relative
to
first
edition
.
Copyright
© 2007
© 2009
W3C
^{
®
}
(
MIT
,
ERCIM
,
Keio
),
All
Rights
Reserved.
W3C
liability
,
trademark
and
document
use
rules
apply.
This
document
defines
constructor
functions,
operators
operators,
and
functions
on
the
datatypes
defined
in
[XML
Schema
Part
2:
Datatypes
Second
Edition]
and
the
datatypes
defined
in
[XQuery
1.0
and
XPath
2.0
Data
Model]
Model
(XDM)
1.1]
.
It
also
discusses
defines
functions
and
operators
on
nodes
and
node
sequences
as
defined
in
the
[XQuery
1.0
and
XPath
2.0
Data
Model]
Model
(XDM)
1.1]
.
These
functions
and
operators
are
defined
for
use
in
[XML
Path
Language
(XPath)
2.0]
2.1]
,
[XQuery
1.0:
1.1:
An
XML
Query
Language]
and
[XSL
Transformations
(XSLT)
Version
2.0]
2.1]
and
other
related
XML
standards.
The
signatures
and
summaries
of
functions
defined
in
this
document
are
available
at:
http://www.w3.org/2005/xpathfunctions
.
This is the third version of the specification of this function library. The first version was included as an intrinsic part of the [XML Path Language (XPath) Version 1.0] specification published on 16 November 1999. The second version was published under the title XQuery 1.0 and XPath 2.0 Functions and Operators on 23 January 2007. This third version is the first to carry its own version number, which has been arbitrarily set at 1.1 to align with version numbering for XQuery.
This section describes the status of this document at the time of its publication. Other documents may supersede this document. A list of current W3C publications and the latest revision of this technical report can be found in the W3C technical reports index at http://www.w3.org/TR/.
This
is
one
document
in
a
set
of
eight
documents
that
have
progressed
to
Recommendation
together
(XQuery
1.0,
1.1,
XQueryX
1.0,
1.1,
XSLT
2.0,
2.1,
Data
Model,
Model
1.1,
Functions
and
Operators,
Operators
1.1,
Formal
Semantics,
Serialization,
Semantics
1.1,
Serialization
1.1,
XPath
2.0).
2.1).
This
is
a
Recommendation
First
Public
Working
Draft
of
as
described
in
the
W3C.
Process
Document
.
It
has
been
jointly
developed
by
the
W3C
XML
Query
Working
Group
and
the
W3C
XSL
Working
Group
,
each
of
which
is
part
of
the
XML
Activity
.
The
Working
Groups
expect
to
advance
this
specification
to
Recommendation
Status.
This
document
has
been
reviewed
by
W3C
Members,
by
software
developers,
and
by
other
W3C
groups
and
interested
parties,
and
is
endorsed
by
the
Director
as
a
W3C
Recommendation.
It
is
a
stable
document
first
public
Working
Draft
of
XQuery
and
may
be
used
as
reference
material
or
cited
from
another
document.
W3C's
role
in
making
the
Recommendation
XPath
Functions
and
Operators
1.1
(XDM).
It
is
intended
to
draw
attention
to
the
specification
be
fully
"upwards
compatible"
with
XQuery
1.0
and
XPath
2.0
Data
Model
(XDM)
.
Failures
to
promote
its
widespread
deployment.
This
enhances
the
functionality
and
interoperability
achieve
that
goal
will
be
corrected
in
future
versions
of
the
Web.
Working
Drafts
of
this
document.
This
document
incorporates
minor
changes
made
against
the
Proposed
Recommendation
of
21
November
2006;
please
see
the
public
disposition
of
comments
A
Test
Suite
has
been
created
for
details.
Changes
to
this
document
since
the
Proposed
Recommendation
document.
Implementors
are
detailed
in
the
B
Change
Log
for
encouraged
to
run
this
Version
of
the
Document
test
suite
and
report
their
results.
The
Test
Suite
can
be
found
at
http://dev.w3.org/cvsweb/2006/xquerytestsuite/
.
An
implementation
report
is
available
at
http://www.w3.org/XML/Query/testsuite/XQTSReport.html
.
Please
report
errors
in
this
document
using
W3C's
public
Bugzilla
system
(instructions
can
be
found
at
http://www.w3.org/XML/2005/04/qtbugzilla
).
If
access
to
that
system
is
not
feasible,
you
may
send
your
comments
to
the
W3C
XSLT/XPath/XQuery
public
comments
mailing
list,
publicqtcomments@w3.org
.
It
will
be
very
helpful
if
you
include
the
string
“[FO]”
“[FO11]”
in
the
subject
line
of
your
report,
whether
made
in
Bugzilla
or
in
email.
Each
Please
use
multiple
Bugzilla
entry
and
entries
(or,
if
necessary,
multiple
email
message
should
contain
only
messages)
if
you
have
more
than
one
error
report.
comment
to
make.
Archives
of
the
comments
and
responses
are
available
at
http://lists.w3.org/Archives/Public/publicqtcomments/
.
Publication as a Working Draft does not imply endorsement by the W3C Membership. This is a draft document and may be updated, replaced or obsoleted by other documents at any time. It is inappropriate to cite this document as other than work in progress.
This document was produced by groups operating under the 5 February 2004 W3C Patent Policy . W3C maintains a public list of any patent disclosures made in connection with the deliverables of the XML Query Working Group and also maintains a public list of any patent disclosures made in connection with the deliverables of the XSL Working Group; those pages also include instructions for disclosing a patent. An individual who has actual knowledge of a patent which the individual believes contains Essential Claim(s) must disclose the information in accordance with section 6 of the W3C Patent Policy .
abs acos adddayTimeDurations adddayTimeDurationtodate adddayTimeDurationtodateTime adddayTimeDurationtotime addyearMonthDurations addyearMonthDurationtodate addyearMonthDurationtodateTime adjustdateTimetotimezone adjustdatetotimezone adjusttimetotimezone analyzestring asin atan avg
base64Binaryequal baseuri boolean booleanequal booleangreaterthan booleanlessthan
ceiling codepointequal codepointstostring collection compare concat concatenate contains cos count currentdate currentdateTime currenttime
data dateequal dategreaterthan datelessthan dateTime dateTimeequal dateTimegreaterthan dateTimelessthan dayfromdate dayfromdateTime daysfromduration dayTimeDurationgreaterthan dayTimeDurationlessthan deepequal defaultcollation distinctvalues dividedayTimeDuration dividedayTimeDurationbydayTimeDuration divideyearMonthDuration divideyearMonthDurationbyyearMonthDuration doc docavailable documenturi durationequal
elementwithid empty encodeforuri endswith error escapehtmluri exactlyone except exists
false floor formatdate formatdateTime formatinteger formatnumber formattime functionarity functionname
gDayequal generateid gMonthDayequal gMonthequal gYearequal gYearMonthequal
hexBinaryequal hoursfromdateTime hoursfromduration hoursfromtime
id idref implicittimezone indexof inscopeprefixes insertbefore intersect iritouri issamenode
matches max min minutesfromdateTime minutesfromduration minutesfromtime monthfromdate monthfromdateTime monthsfromduration multiplydayTimeDuration multiplyyearMonthDuration
name namespaceuri namespaceuriforprefix namespaceurifromQName nilled nodeafter nodebefore nodename normalizespace normalizeunicode not NOTATIONequal number numericadd numericdivide numericequal numericgreaterthan numericintegerdivide numericlessthan numericmod numericmultiply numericsubtract numericunaryminus numericunaryplus
remove replace resolveQName resolveuri reverse root round roundhalftoeven
secondsfromdateTime secondsfromduration secondsfromtime serialize sin sqrt startswith staticbaseuri string stringjoin stringlength stringtocodepoints subsequence substring substringafter substringbefore subtractdates subtractdateTimes subtractdayTimeDurationfromdate subtractdayTimeDurationfromdateTime subtractdayTimeDurationfromtime subtractdayTimeDurations subtracttimes subtractyearMonthDurationfromdate subtractyearMonthDurationfromdateTime subtractyearMonthDurations sum
tan timeequal timegreaterthan timelessthan timezonefromdate timezonefromdateTime timezonefromtime to tokenize trace translate true
yearfromdate yearfromdateTime yearMonthDurationgreaterthan yearMonthDurationlessthan yearsfromduration
1
Introduction
1.1
Conformance
1.2
Namespaces
and
Prefixes
1.3
Function
Overloading
1.4
Function
Signatures
and
Descriptions
1.5
Namespace
Terminology
1.6
Type
Hierarchy
System
1.7
1.6
Terminology
1.6.1
Namespaces
and
URIs
1.6.2
Conformance
terminology
1.6.3
Properties
of
functions
2
Accessors
2.1
fn:nodename
2.2
fn:nilled
2.3
fn:string
2.4
fn:data
2.5
fn:baseuri
2.6
fn:documenturi
3
The
Error
Function
Errors
and
Diagnostics
3.1
Examples
4
The
Trace
Function
4.1
Examples
5
Constructor
Functions
5.1
Constructor
Functions
for
XML
Schema
Builtin
Types
5.2
A
Special
Constructor
Function
for
xs:dateTime
Raising
Errors
5.2.1
Examples
3.1.1
fn:error
5.3
Constructor
Functions
for
xs:QName
and
xs:NOTATION
3.2
Diagnostic
Tracing
5.4
Constructor
Functions
for
UserDefined
Types
3.2.1
fn:trace
6
4
Functions
and
Operators
on
Numerics
6.1
4.1
Numeric
Types
6.2
4.2
Arithmetic
Operators
on
Numeric
Values
6.2.1
4.2.1
op:numericadd
6.2.2
4.2.2
op:numericsubtract
6.2.3
4.2.3
op:numericmultiply
6.2.4
4.2.4
op:numericdivide
6.2.5
4.2.5
op:numericintegerdivide
6.2.6
4.2.6
op:numericmod
6.2.7
4.2.7
op:numericunaryplus
6.2.8
4.2.8
op:numericunaryminus
6.3
4.3
Comparison
Operators
on
Numeric
Values
6.3.1
4.3.1
op:numericequal
6.3.2
4.3.2
op:numericlessthan
6.3.3
4.3.3
op:numericgreaterthan
6.4
4.4
Functions
on
Numeric
Values
6.4.1
4.4.1
fn:abs
6.4.2
4.4.2
fn:ceiling
6.4.3
4.4.3
fn:floor
6.4.4
4.4.4
fn:round
6.4.5
4.4.5
fn:roundhalftoeven
7
4.5
Formatting
Integers
4.5.1
fn:formatinteger
4.6
Formatting
Numbers
4.6.1
Defining
a
Decimal
Format
4.6.2
fn:formatnumber
4.6.3
Syntax
of
the
Picture
String
4.6.4
Analysing
the
Picture
String
4.6.5
Formatting
the
Number
4.7
Trigonometrical
Functions
4.7.1
math:pi
4.7.2
math:sqrt
4.7.3
math:sin
4.7.4
math:cos
4.7.5
math:tan
4.7.6
math:asin
4.7.7
math:acos
4.7.8
math:atan
5
Functions
on
Strings
7.1
5.1
String
Types
7.2
5.2
Functions
to
Assemble
and
Disassemble
Strings
7.2.1
5.2.1
fn:codepointstostring
7.2.2
5.2.2
fn:stringtocodepoints
7.3
5.3
Equality
and
Comparison
of
Strings
7.3.1
5.3.1
Collations
7.3.2
5.3.2
The
Unicode
Codepoint
Collation
5.3.3
Choosing
a
Collation
5.3.4
fn:compare
7.3.3
5.3.5
fn:codepointequal
7.4
5.4
Functions
on
String
Values
7.4.1
5.4.1
fn:concat
7.4.2
5.4.2
fn:stringjoin
7.4.3
5.4.3
fn:substring
7.4.4
5.4.4
fn:stringlength
7.4.5
5.4.5
fn:normalizespace
7.4.6
5.4.6
fn:normalizeunicode
7.4.7
5.4.7
fn:uppercase
7.4.8
5.4.8
fn:lowercase
7.4.9
5.4.9
fn:translate
7.4.10
fn:encodeforuri
7.4.11
fn:iritouri
7.4.12
fn:escapehtmluri
7.5
5.5
Functions
Based
on
Substring
Matching
7.5.1
5.5.1
fn:contains
7.5.2
5.5.2
fn:startswith
7.5.3
5.5.3
fn:endswith
7.5.4
5.5.4
fn:substringbefore
7.5.5
5.5.5
fn:substringafter
7.6
5.6
String
Functions
that
Use
Pattern
Matching
use
Regular
Expressions
7.6.1
5.6.1
Regular
Expression
Syntax
7.6.2
5.6.2
fn:matches
7.6.3
5.6.3
fn:replace
7.6.4
5.6.4
fn:tokenize
8
5.6.5
fn:analyzestring
6
Functions
on
anyURI
that
manipulate
URIs
8.1
6.1
fn:resolveuri
9
6.2
fn:encodeforuri
6.3
fn:iritouri
6.4
fn:escapehtmluri
7
Functions
and
Operators
on
Boolean
Values
9.1
Additional
7.1
Boolean
Constructor
Constant
Functions
9.1.1
7.1.1
fn:true
9.1.2
7.1.2
fn:false
9.2
7.2
Operators
on
Boolean
Values
9.2.1
7.2.1
op:booleanequal
9.2.2
7.2.2
op:booleanlessthan
9.2.3
7.2.3
op:booleangreaterthan
9.3
7.3
Functions
on
Boolean
Values
9.3.1
7.3.1
fn:boolean
7.3.2
fn:not
10
8
Functions
and
Operators
on
Durations,
Dates
and
Times
10.1
Duration,
Date
and
Time
Types
Durations
10.1.1
8.1
Limits
and
Precision
10.2
Date/time
datatype
values
10.2.1
Examples
10.3
8.2
Two
Totally
Ordered
Subtypes
of
Duration
10.3.1
8.2.1
xs:yearMonthDuration
10.3.2
8.2.2
xs:dayTimeDuration
10.4
8.3
Comparison
Operators
on
Duration,
Date
and
Time
Values
Durations
10.4.1
8.3.1
op:yearMonthDurationlessthan
10.4.2
8.3.2
op:yearMonthDurationgreaterthan
10.4.3
8.3.3
op:dayTimeDurationlessthan
10.4.4
8.3.4
op:dayTimeDurationgreaterthan
10.4.5
8.3.5
op:durationequal
10.4.6
8.4
Component
Extraction
Functions
on
Durations
8.4.1
fn:yearsfromduration
8.4.2
fn:monthsfromduration
8.4.3
fn:daysfromduration
8.4.4
fn:hoursfromduration
8.4.5
fn:minutesfromduration
8.4.6
fn:secondsfromduration
8.5
Arithmetic
Operators
on
Durations
8.5.1
op:addyearMonthDurations
8.5.2
op:subtractyearMonthDurations
8.5.3
op:multiplyyearMonthDuration
8.5.4
op:divideyearMonthDuration
8.5.5
op:divideyearMonthDurationbyyearMonthDuration
8.5.6
op:adddayTimeDurations
8.5.7
op:subtractdayTimeDurations
8.5.8
op:multiplydayTimeDuration
8.5.9
op:dividedayTimeDuration
8.5.10
op:dividedayTimeDurationbydayTimeDuration
9
Functions
and
Operators
on
Dates
and
Times
9.1
Date
and
Time
Types
9.1.1
Limits
and
Precision
9.2
Date/time
datatype
values
9.2.1
Examples
9.3
Constructing
a
dateTime
9.3.1
fn:dateTime
9.4
Comparison
Operators
on
Duration,
Date
and
Time
Values
9.4.1
op:dateTimeequal
10.4.7
9.4.2
op:dateTimelessthan
10.4.8
9.4.3
op:dateTimegreaterthan
10.4.9
9.4.4
op:dateequal
10.4.10
9.4.5
op:datelessthan
10.4.11
9.4.6
op:dategreaterthan
10.4.12
9.4.7
op:timeequal
10.4.13
9.4.8
op:timelessthan
10.4.14
9.4.9
op:timegreaterthan
10.4.15
9.4.10
op:gYearMonthequal
10.4.16
9.4.11
op:gYearequal
10.4.17
9.4.12
op:gMonthDayequal
10.4.18
9.4.13
op:gMonthequal
10.4.19
9.4.14
op:gDayequal
10.5
9.5
Component
Extraction
Functions
on
Durations,
Dates
and
Times
10.5.1
fn:yearsfromduration
10.5.2
fn:monthsfromduration
10.5.3
fn:daysfromduration
10.5.4
fn:hoursfromduration
10.5.5
fn:minutesfromduration
10.5.6
fn:secondsfromduration
10.5.7
9.5.1
fn:yearfromdateTime
10.5.8
9.5.2
fn:monthfromdateTime
10.5.9
9.5.3
fn:dayfromdateTime
10.5.10
9.5.4
fn:hoursfromdateTime
10.5.11
9.5.5
fn:minutesfromdateTime
10.5.12
9.5.6
fn:secondsfromdateTime
10.5.13
9.5.7
fn:timezonefromdateTime
10.5.14
9.5.8
fn:yearfromdate
10.5.15
9.5.9
fn:monthfromdate
10.5.16
9.5.10
fn:dayfromdate
10.5.17
9.5.11
fn:timezonefromdate
10.5.18
9.5.12
fn:hoursfromtime
10.5.19
9.5.13
fn:minutesfromtime
10.5.20
9.5.14
fn:secondsfromtime
10.5.21
9.5.15
fn:timezonefromtime
10.6
Arithmetic
Operators
on
Durations
10.6.1
op:addyearMonthDurations
10.6.2
op:subtractyearMonthDurations
10.6.3
op:multiplyyearMonthDuration
10.6.4
op:divideyearMonthDuration
10.6.5
op:divideyearMonthDurationbyyearMonthDuration
10.6.6
op:adddayTimeDurations
10.6.7
op:subtractdayTimeDurations
10.6.8
op:multiplydayTimeDuration
10.6.9
op:dividedayTimeDuration
10.6.10
op:dividedayTimeDurationbydayTimeDuration
10.7
9.6
Timezone
Adjustment
Functions
on
Dates
and
Time
Values
10.7.1
9.6.1
fn:adjustdateTimetotimezone
10.7.2
9.6.2
fn:adjustdatetotimezone
10.7.3
9.6.3
fn:adjusttimetotimezone
10.8
9.7
Arithmetic
Operators
on
Durations,
Dates
and
Times
10.8.1
9.7.1
op:subtractdateTimes
10.8.2
9.7.2
op:subtractdates
10.8.3
9.7.3
op:subtracttimes
10.8.4
9.7.4
op:addyearMonthDurationtodateTime
10.8.5
9.7.5
op:adddayTimeDurationtodateTime
10.8.6
9.7.6
op:subtractyearMonthDurationfromdateTime
10.8.7
9.7.7
op:subtractdayTimeDurationfromdateTime
10.8.8
9.7.8
op:addyearMonthDurationtodate
10.8.9
9.7.9
op:adddayTimeDurationtodate
10.8.10
9.7.10
op:subtractyearMonthDurationfromdate
10.8.11
9.7.11
op:subtractdayTimeDurationfromdate
10.8.12
9.7.12
op:adddayTimeDurationtotime
10.8.13
9.7.13
op:subtractdayTimeDurationfromtime
11
9.8
Formatting
Dates
and
Times
9.8.1
fn:formatdateTime
9.8.2
fn:formatdate
9.8.3
fn:formattime
9.8.4
The
date/time
formatting
functions
9.8.5
Examples
of
Date
and
Time
Formatting
10
Functions
Related
to
QNames
11.1
10.1
Additional
Constructor
Functions
for
to
create
a
QNames
11.1.1
10.1.1
fn:resolveQName
11.1.2
10.1.2
fn:QName
11.2
10.2
Functions
and
Operators
Related
to
QNames
11.2.1
10.2.1
op:QNameequal
11.2.2
10.2.2
fn:prefixfromQName
11.2.3
10.2.3
fn:localnamefromQName
11.2.4
10.2.4
fn:namespaceurifromQName
11.2.5
10.2.5
fn:namespaceuriforprefix
11.2.6
10.2.6
fn:inscopeprefixes
12
11
Operators
on
base64Binary
and
hexBinary
12.1
11.1
Comparisons
of
base64Binary
and
hexBinary
Values
12.1.1
11.1.1
op:hexBinaryequal
12.1.2
11.1.2
op:base64Binaryequal
13
12
Operators
on
NOTATION
13.1
Operators
on
NOTATION
13.1.1
12.1
op:NOTATIONequal
14
13
Functions
and
Operators
on
Nodes
14.1
13.1
fn:name
14.2
13.2
fn:localname
14.3
13.3
fn:namespaceuri
14.4
13.4
fn:number
14.4.1
Examples
14.5
13.5
fn:lang
14.5.1
Examples
14.6
13.6
op:issamenode
14.6.1
Examples
14.7
13.7
op:nodebefore
14.7.1
Examples
14.8
13.8
op:nodeafter
14.8.1
Examples
14.9
13.9
fn:root
14.9.1
Examples
15
14
Functions
and
Operators
on
Sequences
15.1
14.1
General
Functions
and
Operators
on
Sequences
15.1.1
fn:boolean
15.1.2
14.1.1
op:concatenate
15.1.3
fn:indexof
14.1.2
fn:distinctvalues
15.1.4
14.1.3
fn:empty
15.1.5
14.1.4
fn:exists
15.1.6
fn:distinctvalues
14.1.5
fn:indexof
15.1.7
14.1.6
fn:insertbefore
15.1.8
14.1.7
fn:remove
15.1.9
14.1.8
fn:reverse
15.1.10
14.1.9
fn:subsequence
15.1.11
14.1.10
fn:unordered
15.2
14.2
Functions
That
Test
the
Cardinality
of
Sequences
15.2.1
14.2.1
fn:zeroorone
15.2.2
14.2.2
fn:oneormore
15.2.3
14.2.3
fn:exactlyone
15.3
14.3
Equals,
Union,
Intersection
and
Except
15.3.1
14.3.1
fn:deepequal
15.3.2
14.3.2
op:union
15.3.3
14.3.3
op:intersect
15.3.4
14.3.4
op:except
15.4
14.4
Aggregate
Functions
15.4.1
14.4.1
fn:count
15.4.2
14.4.2
fn:avg
15.4.3
14.4.3
fn:max
15.4.4
14.4.4
fn:min
15.4.5
14.4.5
fn:sum
15.5
14.5
Functions
and
Operators
that
Generate
Sequences
15.5.1
14.5.1
op:to
15.5.2
14.5.2
fn:id
15.5.3
14.5.3
fn:elementwithid
14.5.4
fn:idref
15.5.4
14.5.5
fn:doc
15.5.5
14.5.6
fn:docavailable
15.5.6
14.5.7
fn:collection
16
14.5.8
fn:uricollection
14.5.9
fn:generateid
14.5.10
fn:parse
14.5.11
fn:serialize
15
Context
Functions
16.1
15.1
fn:position
16.2
15.2
fn:last
16.3
15.3
fn:currentdateTime
16.3.1
Examples
16.4
15.4
fn:currentdate
16.4.1
Examples
16.5
15.5
fn:currenttime
16.5.1
Examples
16.6
15.6
fn:implicittimezone
16.7
15.7
fn:defaultcollation
16.8
15.8
fn:staticbaseuri
16
Functions
on
Functions
16.1
fn:functionname
16.2
fn:functionarity
16.3
fn:partialapply
17
Constructor
Functions
17.1
Constructor
Functions
for
XML
Schema
Builtin
Types
17.2
Constructor
Functions
for
xs:QName
and
xs:NOTATION
17.3
Constructor
Functions
for
UserDefined
Types
18
Casting
17.1
18.1
Casting
from
primitive
types
to
primitive
types
17.1.1
18.1.1
Casting
from
xs:string
and
xs:untypedAtomic
17.1.2
18.1.2
Casting
to
xs:string
and
xs:untypedAtomic
17.1.3
18.1.3
Casting
to
numeric
types
17.1.4
18.1.4
Casting
to
duration
types
17.1.5
18.1.5
Casting
to
date
and
time
types
17.1.6
18.1.6
Casting
to
xs:boolean
17.1.7
18.1.7
Casting
to
xs:base64Binary
and
xs:hexBinary
17.1.8
18.1.8
Casting
to
xs:anyURI
17.2
18.1.9
Casting
to
xs:QName
and
xs:NOTATION
18.2
Casting
to
derived
types
17.3
18.3
Casting
from
derived
types
to
parent
types
17.4
18.4
Casting
within
a
branch
of
the
type
hierarchy
17.4.1
18.4.1
Casting
to
xs:ENTITY
17.5
18.5
Casting
across
the
type
hierarchy
A
References
A.1
Normative
References
A.2
Nonnormative
References
B
Change
Log
for
this
Version
of
the
Document
C
Error
Summary
D
C
Compatibility
with
XPath
1.0
(NonNormative)
E
D
Illustrative
Userwritten
Functions
(NonNormative)
E.1
D.1
eg:ifempty
and
eg:ifabsent
E.1.1
D.1.1
eg:ifempty
E.1.2
D.1.2
eg:ifabsent
E.2
D.2
union,
intersect
and
except
on
sequences
of
values
E.2.1
D.2.1
eg:valueunion
E.2.2
D.2.2
eg:valueintersect
E.2.3
D.2.3
eg:valueexcept
E.3
D.3
eg:indexofnode
E.4
D.4
eg:stringpad
E.5
D.5
eg:distinctnodesstable
F
E
Checklist
of
ImplementationDefined
Features
(NonNormative)
F
Changes
since
previous
Recommendation
(NonNormative)
F.1
Substantive
changes
F.2
Editorial
changes
G
Function
and
Operator
Quick
Reference
(NonNormative)
G.1
Functions
and
Operators
by
Section
G.2
Functions
and
Operators
Alphabetically
The
purpose
of
this
document
is
to
catalog
the
functions
and
operators
required
for
XPath
2.0,
XML
Query
1.0
and
XSLT
2.0.
The
exact
syntax
used
to
invoke
call
these
functions
and
operators
is
specified
in
[XML
Path
Language
(XPath)
2.0]
,
[XQuery
1.0:
An
XML
Query
Language]
and
[XSL
Transformations
(XSLT)
Version
2.0]
.
This document defines constructor functions and functions that take typed values as arguments. Some of the functions define the semantics of operators discussed in [XQuery 1.0: An XML Query Language] .
[XML
Schema
Part
2:
Datatypes
Second
Edition]
defines
a
number
of
primitive
and
derived
datatypes,
collectively
known
as
builtin
datatypes.
This
document
defines
functions
and
operations
on
these
datatypes
as
well
as
the
datatypes
defined
in
Section
2.6
Types
^{
DM
}
of
the
[XQuery
1.0
and
XPath
2.0
Data
Model]
Model
(XDM)
1.1]
.
These
functions
and
operations
are
defined
for
use
in
[XML
Path
Language
(XPath)
2.0]
,
[XQuery
1.0:
An
XML
Query
Language]
and
[XSL
Transformations
(XSLT)
Version
2.0]
and
related
XML
standards.
This
document
also
discusses
defines
functions
and
operators
on
nodes
and
node
sequences
as
defined
in
the
[XQuery
1.0
and
XPath
2.0
Data
Model]
Model
(XDM)
1.1]
for
use
in
[XML
Path
Language
(XPath)
2.0]
,
[XQuery
1.0:
An
XML
Query
Language]
and
[XSL
Transformations
(XSLT)
Version
2.0]
and
other
related
XML
standards.
References
to
specific
sections
of
some
of
the
above
documents
are
indicated
by
crossdocument
links
in
this
document.
Each
such
link
consists
of
a
pointer
to
a
specific
section
followed
a
superscript
specifying
the
linked
document.
The
superscripts
have
the
following
meanings:
'XQ'
[XQuery
1.0:
An
XML
Query
Language]
,
'XT'
[XSL
Transformations
(XSLT)
Version
2.0]
,
'XP'
[XML
Path
Language
(XPath)
2.0]
,
'DM'
[XQuery
1.0
and
XPath
2.0
Data
Model]
Model
(XDM)
1.1]
and
'FS'
[XQuery
1.0
and
XPath
2.0
Formal
Semantics]
.
The Functions and Operators specification is intended primarily as a component that can be used by other specifications. Therefore, Functions and Operators relies on specifications that use it (such as [XML Path Language (XPath) 2.0] , [XSL Transformations (XSLT) Version 2.0] and [XQuery 1.0: An XML Query Language] ) to specify conformance criteria for their respective environments.
Authors of conformance criteria for the use of the Functions and Operators should pay particular attention to the following features:
It is · implementationdefined · which version of Unicode is supported, but it is recommended that the most recent version of Unicode be used.
It is · implementationdefined · whether the type system is based on XML Schema 1.0 or XML Schema 1.1.
Support for XML 1.0 and XML 1.1 by the datatypes used in Functions and Operators.
Note:
At
the
time
of
writing
there
is
no
published
version
a
Candidate
Recommendation
of
XML
Schema
that
references
the
XML
1.1
specifications.
This
means
that
datatypes
such
as
introduces
some
new
data
types
including
and
xs:NCName
xs:precisionDecimal
.
This
specification
provides
some
limited
support
for
the
xs:ID
are
constrained
by
the
XML
1.0
rules.
Authors
of
conformance
requirements
xs:dateTimeStamp
use
latter,
but
does
not
yet
include
support
for
xs:precisionDecimal
.
This
is
likely
to
come
in
a
later
draft
of
Functions
and
Operators
should
state
clearly
this
specification.
Furthermore,
XSD
1.1
includes
the
implications
for
conformance
option
of
any
changes
to
supporting
revised
definitions
of
types
such
as
xs:NCName
based
on
the
rules
in
XML
1.1
rather
than
1.0.
The
rules
affecting
support
for
XSD
1.0
versus
XSD
1.1
and
XML
1.0
versus
XML
1.1
are
likely
to
be
refined
in
later
versions
drafts
of
XML
Schema.
this
specification.
In this document, text labeled as an example or as a Note is provided for explanatory purposes and is not normative.
The
functions
and
operators
discussed
in
this
document
are
contained
in
one
of
three
several
namespaces
(see
[Namespaces
in
XML]
)
and
referenced
using
an
xs:QName
.
This
document
uses
conventional
prefixes
to
refer
to
these
namespaces.
Userwritten
applications
can
choose
a
different
prefix
to
refer
to
the
namespace,
so
long
as
it
is
bound
to
the
correct
URI.
The
host
language
may
also
define
a
default
namespace
for
function
calls,
in
which
case
function
names
in
that
namespace
need
not
be
prefixed
at
all.
In
many
cases
the
default
namespace
will
be
http://www.w3.org/2005/xpathfunctions
,
allowing
a
call
on
the
fn:name
function
(for
example)
to
be
written
as
name()
rather
than
fn:name()
;
in
this
document,
however,
all
example
function
calls
are
explicitly
prefixed.
The URIs of the namespaces and the conventional prefixes associated with them are:
http://www.w3.org/2001/XMLSchema
for
constructors

associated
with
xs
.
The
datatypes
and
constructor
functions
for
the
builtin
datatypes
defined
in
[XML
Schema
Part
2:
Datatypes
Second
Edition]
and
in
Section
2.6
Types
^{
DM
}
of
[XQuery
1.0
and
XPath
2.0
Data
Model]
Model
(XDM)
1.1]
and
discussed
in
5
17
Constructor
Functions
are
in
the
XML
Schema
namespace,
http://www.w3.org/2001/XMLSchema
,
and
named
in
this
document
using
the
xs
prefix.
http://www.w3.org/2005/xpathfunctions
for
functions
—
associated
with
fn
.
The
namespace
prefix
used
in
this
document
for
most
functions
that
are
available
to
users
is
fn
.
Operator
http://www.w3.org/2005/xpathfunctions/math
for
functions
are
named
—
associated
with
the
math
.
This
namespace
is
used
for
some
mathematical
functions.
The
namespace
prefix
used
in
this
document
for
these
functions
is
.
These
functions
are
available
to
users
in
exactly
the
same
way
as
those
in
the
op
math
fn
namespace.
http://www.w3.org/2005/xqterrors
—
associated
with
err
.
There are no functions in this namespace; it is used for error codes.
This
document
uses
the
prefix
err
to
represent
the
namespace
URI
http://www.w3.org/2005/xqterrors
,
which
is
the
namespace
for
all
XPath
and
XQuery
error
codes
and
messages.
This
namespace
prefix
is
not
predeclared
and
its
use
in
this
document
is
not
normative.
Note:
The
namespace
URI
associated
with
the
err
prefix
is
not
expected
to
change
from
one
version
of
this
document
to
another.
The
contents
of
this
namespace
may
be
extended
to
allow
additional
errors
to
be
returned.
The
functions
defined
with
an
fn
prefix
are
callable
by
the
user.
Functions
defined
with
the
op
prefix
are
described
here
to
underpin
the
definitions
of
the
operators
in
[XML
Path
Language
(XPath)
2.0]
,
[XQuery
1.0:
An
XML
Query
Language]
and
[XSL
Transformations
(XSLT)
Version
2.0]
.
These
functions
are
not
available
directly
to
users,
and
there
is
no
requirement
that
implementations
should
actually
provide
these
functions.
For
this
reason,
no
namespace
is
associated
with
the
op
prefix.
For
example,
multiplication
is
generally
associated
with
the
*
operator,
but
it
is
described
as
a
function
in
this
document:
op:numericmultiply
(
$arg1
as
numeric
,
$arg2
as
numeric
)
as
numeric
In
general,
the
specifications
named
above
do
not
support
function
overloading
in
the
sense
that
functions
that
have
multiple
signatures
with
the
same
name
and
the
same
number
of
parameters
are
not
supported.
Consequently,
there
are
no
such
overloaded
functions
in
this
document
except
for
legacy
[XML
Path
Language
(XPath)
Version
1.0]
functions
such
as
,
which
accepts
a
single
parameter
of
a
variety
of
types.
In
addition,
it
should
be
noted
that
the
functions
defined
in
fn:string()
fn:string
6
4
Functions
and
Operators
on
Numerics
that
accept
numeric
parameters
accept
arguments
of
type
xs:integer
,
xs:decimal
,
xs:float
or
xs:double
.
See
1.4
Function
Signatures
and
Descriptions
.
Operators
such
as
"+"
may
be
overloaded.
This
document
does
define
some
functions
with
more
than
one
signature
with
the
same
name
and
different
number
of
parameters.
Userdefined
functions
with
more
than
one
signature
with
the
same
name
and
different
number
of
parameters
are
also
supported.
Each function is defined by specifying its signature, a description of the return type and each of the parameters and its semantics. For many functions, examples are included to illustrate their use.
Each function's signature is presented in a form like this:
fn:functionname
(
$parametername
as
parametertype
,
...
)
as
returntype
In
this
notation,
functionname
,
in
boldface,
is
the
name
of
the
function
whose
signature
is
being
specified.
If
the
function
takes
no
parameters,
then
the
name
is
followed
by
an
empty
parameter
list:
"
()
";
otherwise,
the
name
is
followed
by
a
parenthesized
list
of
parameter
declarations,
each
declaration
specifies
the
static
type
of
the
parameter,
in
italics,
and
a
descriptive,
but
nonnormative,
name.
If
there
are
two
or
more
parameter
declarations,
they
are
separated
by
a
comma.
The
returntype
,
also
in
italics,
specifies
the
static
type
of
the
value
returned
by
the
function.
The
dynamic
type
returned
by
the
function
is
the
same
as
its
static
type
or
derived
from
the
static
type.
All
parameter
types
and
return
types
are
specified
using
the
SequenceType
notation
defined
in
Section
2.5.3
SequenceType
Syntax
^{
XP
}.
One
function,
fn:concat
,
has
a
variable
number
of
arguments
(two
or
more).
More
strictly,
there
is
an
infinite
set
of
functions
having
the
name
fn:concat
,
with
arity
ranging
from
2
to
infinity.
For
this
special
case,
a
single
function
signature
is
given,
with
an
ellipsis
indicating
an
indefinite
number
of
arguments.
In
some
cases
the
word
"
numeric
"
is
used
in
function
signatures
as
a
shorthand
to
indicate
the
four
numeric
types:
xs:integer
,
xs:decimal
,
xs:float
and
xs:double
.
For
example,
a
function
with
the
signature
signature:
fn:numericfunction
(
$arg
as
numeric
)
as
...
represents the following four function signatures:
fn:numericfunction
(
$arg
as
xs:integer
)
as
...
fn:numericfunction
(
$arg
as
xs:decimal
)
as
...
fn:numericfunction
(
$arg
as
xs:float
)
as
...
fn:numericfunction
(
$arg
as
xs:double
)
as
...
For most functions there is an initial paragraph describing what the function does followed by semantic rules. These rules are meant to be followed in the order that they appear in this document.
In some cases, the static type returned by a function depends on the type(s) of its argument(s). These special functions are indicated by using bold italics for the return type. The semantic rules specifying the type of the value returned are documented in the function definition. The rules are described more formally in Section 7.2 Standard functions with specific static typing rules ^{ FS }.
The
function
name
is
a
QName
as
defined
in
[XML
Schema
Part
2:
Datatypes
Second
Edition]
and
must
adhere
to
its
syntactic
conventions.
Following
[XML
Path
Language
(XPath)
Version
1.0]
,
function
names
are
composed
of
English
words
separated
by
hyphens,"".
If
a
function
name
contains
a
[XML
Schema
Part
2:
Datatypes
Second
Edition]
datatype
name,
it
may
have
intercapitalized
spelling
and
is
used
in
the
function
name
as
such.
For
example,
fn:timezonefromdateTime
.
Rules
for
passing
parameters
to
operators
are
described
in
the
relevant
sections
of
[XQuery
1.0:
An
XML
Query
Language]
and
[XML
Path
Language
(XPath)
2.0]
.
For
example,
the
rules
for
passing
parameters
to
arithmetic
operators
are
described
in
Section
3.4
Arithmetic
Expressions
^{
XP
}.
Specifically,
rules
for
parameters
of
type
xs:untypedAtomic
and
the
empty
sequence
are
specified
in
this
section.
As
is
customary,
the
parameter
type
name
indicates
that
the
function
or
operator
accepts
arguments
of
that
type,
or
types
derived
from
it,
in
that
position.
This
is
called
subtype
substitution
(See
Section
2.5.4
SequenceType
Matching
^{
XP
}
).
In
addition,
numeric
type
instances
and
instances
of
type
xs:anyURI
can
be
promoted
to
produce
an
argument
of
the
required
type.
(See
Section
B.1
Type
Promotion
^{
XP
}
).
Subtype
Substitution
:
A
derived
type
may
substitute
for
its
base
type.
In
particular,
xs:integer
may
be
used
where
xs:decimal
is
expected.
Numeric
Type
Promotion
:
xs:decimal
may
be
promoted
to
xs:float
or
xs:double
.
Promotion
to
xs:double
should
be
done
directly,
not
via
xs:float
,
to
avoid
loss
of
precision.
anyURI
Type
Promotion
:
A
value
of
type
xs:anyURI
can
be
promoted
to
the
type
xs:string
.
Some
functions
accept
a
single
value
or
the
empty
sequence
as
an
argument
and
some
may
return
a
single
value
or
the
empty
sequence.
This
is
indicated
in
the
function
signature
by
following
the
parameter
or
return
type
name
with
a
question
mark:
"
?
",
indicating
that
either
a
single
value
or
the
empty
sequence
must
appear.
See
below.
fn:functionname
(
$parametername
as
parametertype?
)
as
returntype?
Note
that
this
function
signature
is
different
from
a
signature
in
which
the
parameter
is
omitted.
See,
for
example,
the
two
signatures
for
.
In
the
first
signature,
the
parameter
is
omitted
and
the
argument
defaults
to
the
context
item,
referred
to
as
".".
In
the
second
signature,
the
argument
must
be
present
but
may
be
the
empty
sequence,
referred
to
as
"()."
fn:string()
fn:string
Some
functions
accept
a
sequence
of
zero
or
more
values
as
an
argument.
This
is
indicated
by
following
the
name
of
type
of
the
items
in
the
sequence
with
*
.
The
sequence
may
contain
zero
or
more
items
of
the
named
type.
For
example,
the
function
below
accepts
a
sequence
of
xs:double
and
returns
a
xs:double
or
the
empty
sequence.
fn:median
(
$arg
as
xs:double*
)
as
xs:double?
This
document
uses
the
phrase
"namespace
URI"
to
identify
the
concept
identified
in
[Namespaces
in
XML]
as
"namespace
name",
The
diagrams
below
show
how
nodes,
function
items,
primitive
simple
types,
and
the
phrase
"local
name"
to
identify
the
concept
identified
in
[Namespaces
in
XML]
as
"local
part".
It
also
uses
the
term
"expandedQName"
user
defined
below.
[Definition]
ExpandedQName
An
expandedQName
is
a
pair
of
values
consisting
of
a
namespace
URI
and
types
fit
together
into
a
local
name.
They
belong
to
the
value
space
of
type
system.
This
type
system
comprises
two
distinct
hierarchies
that
both
include
the
[XML
Schema
Part
2:
Datatypes
Second
Edition]
datatype
xs:QName
.
When
this
document
refers
to
xs:QName
we
always
mean
primitive
simple
types.
In
the
value
space,
i.e.
a
namespace
URI,
local
name
pair
(and
not
diagrams,
connecting
lines
represent
relationships
between
derived
types
and
the
lexical
space
referring
to
constructs
of
types
from
which
they
are
derived;
the
form
prefix:localname).
1.6
Type
Hierarchy
The
diagram
below
shows
arrowheads
point
toward
the
types
for
type
from
which
functions
they
are
defined
derived.
The
dashed
line
represents
relationships
not
present
in
this
document.
These
include
the
builtin
types
defined
by
[XML
Schema
Part
2:
Datatypes
Second
Edition]
(shown
on
the
right)
as
well
as
types
defined
diagram,
but
that
appear
in
[XQuery
1.0
and
XPath
2.0
Data
Model]
(shown
on
one
of
the
left).
Solid
other
diagrams.
Dotted
lines
connect
a
base
datatype
above
to
a
derived
datatype.
represent
additional
relationships
that
follow
an
evident
pattern.
The
information
that
appears
in
each
diagram
is
recapitulated
in
tabular
form.
The
xs:IDREFS
,
xs:NMTOKENS
,
and
xs:ENTITIES
types
and
the
userdefined
list
and
union
types
are
special
types
in
that
these
types
are
lists
or
unions
rather
than
true
subtypes.
Dashed
lines
connect
a
union
type
above
with
its
component
types
below.
derived
by
extension
or
restriction.
The
information
in
the
above
first
diagram
is
reproduced
below
in
tabular
form.
For
ease
of
presentation
and
its
corresponding
table
illustrate
the
information
"item"
type
hierarchy.
In
XDM,
items
include
node
types,
function
types,
and
builtin
atomic
types.
In
the
table,
each
type
whose
name
is
divided
into
three
tables.
The
first
table
shows
indented
is
derived
from
the
top
three
layers
type
whose
name
appears
nearest
above
it
with
one
less
level
of
the
hierarchy
starting
at
xs:anyType
.
indentation.
item  
xs:anyAtomicType  
node  
attribute  
userdefined attribute types  
comment  
document  
userdefined document types  
element  
userdefined element types  
processinginstruction  
text 
The
second
next
diagram
and
table
shows
illustrate
the
"any
type"
type
hierarchy,
in
which
all
types
are
derived
from
distinguished
type
.
xs:anyAtomicType
xs:anyType
The
third
table
shows
the
types
defined
in
[XQuery
1.0
and
XPath
2.0
Data
Model]
Each
In
the
table,
each
type
whose
name
is
indented
is
derived
from
the
type
whose
name
appears
nearest
above
it
with
one
less
level
of
indentation.
xs:anyType  
userdefined complex types  
xs:untyped  
xs:anySimpleType  
userdefined list and union types  
xs:IDREFS  
xs:NMTOKENS  
xs:ENTITIES  
xs:anyAtomicType 
The
final
diagram
and
table
below
shows
show
all
of
the
datatypes
atomic
types,
including
the
primitive
simple
types
and
the
builtin
types
derived
from
xs:anyAtomicType
.
the
primitive
simple
types.
This
includes
all
the
builtin
datatypes
defined
in
[XML
Schema
Part
2:
Datatypes
Second
Edition]
builtin
datatypes
as
well
as
the
two
totally
ordered
subtypes
of
duration
defined
in
Section
2.6
Types
DM
.
.
Each
In
the
table,
each
type
whose
name
is
indented
is
derived
from
the
type
whose
name
appears
nearest
above
it
with
one
less
level
of
indentation.
xs:untypedAtomic  
xs:dateTime  
xs:dateTimeStamp  
xs:date  
xs:time  
xs:duration  
xs:yearMonthDuration  
xs:dayTimeDuration  
xs:float  
xs:double  
xs:precisionDecimal  
xs:decimal  
xs:integer  
xs:nonPositiveInteger  
xs:negativeInteger  
xs:long  
xs:int  
xs:short  
xs:byte  
xs:nonNegativeInteger  
xs:unsignedLong  
xs:unsignedInt  
xs:unsignedShort  
xs:unsignedByte  
xs:positiveInteger  
xs:gYearMonth  
xs:gYear  
xs:gMonthDay  
xs:gDay  
xs:gMonth  
xs:string  
xs:normalizedString  
xs:token  
xs:language  
xs:NMTOKEN  
xs:Name  
xs:NCName  
xs:ID  
xs:IDREF  
xs:ENTITY  
xs:boolean  
xs:base64Binary  
xs:hexBinary  
xs:anyURI  
xs:QName  
xs:NOTATION 
The
terminology
used
to
describe
the
functions
and
operators
on
[XML
Schema
Part
2:
Datatypes
Second
Edition]
is
defined
in
the
body
of
this
specification.
The
terms
defined
in
the
following
list
this
section
are
used
in
building
those
definitions:
definitions
This document uses the phrase "namespace URI" to identify the concept identified in [Namespaces in XML] as "namespace name", and the phrase "local name" to identify the concept identified in [Namespaces in XML] as "local part".
It also uses the term "expandedQName" defined below.
[Definition]
An
expandedQName
is
a
pair
of
values
consisting
of
a
namespace
URI
and
a
local
name.
They
belong
to
the
value
space
of
the
[XML
Schema
Part
2:
Datatypes
Second
Edition]
datatype
xs:QName
.
When
this
document
refers
to
xs:QName
we
always
mean
the
value
space,
i.e.
a
namespace
URI,
local
name
pair
(and
not
the
lexical
space
referring
to
constructs
of
the
form
prefix:localname).
The term URI is used as follows:
[Definition]
Within
this
specification,
the
term
URI
refers
to
Universal
Resource
Identifiers
as
defined
in
[RFC
3986]
and
extended
in
[RFC
3987]
with
a
new
name
IRI
.
The
term
URI
Reference
,
unless
otherwise
stated,
refers
to
a
string
in
the
lexical
space
of
the
xs:anyURI
datatype
as
defined
in
[XML
Schema
Part
2:
Datatypes
Second
Edition]
.
Note:
Note
that
this
means,
in
practice,
that
where
this
specification
requires
a
"URI
Reference",
an
IRI
as
defined
in
[RFC
3987]
will
be
accepted,
provided
that
other
relevant
specifications
also
permit
an
IRI.
The
term
URI
has
been
retained
in
preference
to
IRI
to
avoid
introducing
new
names
for
concepts
such
as
"Base
URI"
that
are
defined
or
referenced
across
the
whole
family
of
XML
specifications.
Note
also
that
the
definition
of
xs:anyURI
is
a
wider
definition
than
the
definition
in
[RFC
3987]
;
for
example
it
does
not
require
nonASCII
characters
to
be
escaped.
A feature of this specification included to ensure that implementations that use this feature remain compatible with [XML Path Language (XPath) Version 1.0]
Conforming documents and processors are permitted to, but need not, behave as described.
Conforming documents and processors are required to behave as described; otherwise, they are either nonconformant or else in error.
Possibly differing between implementations, but specified and documented by the implementor for each particular implementation.
Possibly differing between implementations, but not specified by this or other W3C specification, and not required to be specified by the implementor for any particular implementation.
The
scope
over
which
any
This
section
is
concerned
with
the
question
of
whether
two
calls
on
a
function,
with
the
same
arguments,
may
produce
different
results.
[Definition]
Two
function
would
calls
are
said
to
be
executed.
within
the
same
execution
scope
if
the
host
environment
defines
them
as
such.
In
XSLT,
it
applies
to
any
two
calls
on
the
function
executed
during
the
same
transformation.
transformation
are
in
the
same
execution
scope.
In
XQuery,
it
applies
to
any
two
calls
executed
during
the
evaluation
of
a
toplevel
expression
i.e.
an
expression
not
contained
are
in
any
other
expression.
the
same
execution
scope.
In
other
contexts,
the
execution
scope
is
specified
by
the
host
environment
that
invokes
the
function
library.
The following definition explains more precisely what it means for two function calls to return the same result:
[Definition]
Two
values
are
defined
to
be
stable
identical
if
they
contain
the
same
number
of
items
and
the
items
are
pairwise
identical.
Two
items
are
identical
if
and
only
if
one
of
the
following
conditions
applies:
Most
Both
items
are
atomic
values,
of
precisely
the
functions
in
same
type,
and
the
core
library
have
values
are
equal
as
defined
using
the
property
that
calling
eq
operator,
using
the
Unicode
codepoint
collation
when
comparing
strings
Both items are nodes, and represent the same node
Both
items
are
function
twice
within
an
items,
and
have
the
same
name
(or
absence
of
a
name),
arity,
function
signature,
and
closure
Some functions produce results that depend not only on their explicit arguments, but also on the static and dynamic context.
·
execution
scope
·
with
[Definition]
A
function
may
have
the
same
arguments
returns
property
of
being
contextual
:
the
same
result:
these
result
of
such
a
function
depends
on
the
values
of
properties
in
the
static
and
dynamic
evaluation
context
as
well
as
on
the
actual
supplied
arguments
(if
any).
Contextual
functions
are
said
to
be
stable
.
This
category
includes
fall
into
a
number
of
categories:
The
functions
such
as
,
fn:doc()
fn:currentdate
,
fn:collection()
fn:currentdateTime
,
fn:currentdateTime()
fn:currenttime
,
fn:currentdate
fn:implicittimezone
fn:adjustdatetotimezone
,
fn:adjustdateTimetotimezone
,
and
fn:currenttime()
fn:adjusttimetotimezone
whose
result
depends
depend
on
properties
of
the
external
environment.
Where
the
function
returns
nodes,
stability
means
dynamic
context
that
the
returned
nodes
are
identical,
not
merely
equal
and
are
returned
fixed
within
the
·
execution
scope
·
.
The
same
applies
to
a
number
of
functions
in
the
op:
namespace
that
manipulate
dates
and
times
and
that
make
use
of
the
implicit
timezone.
These
functions
will
return
the
same
order.
result
if
called
repeatedly
during
a
single
Note:
·
execution
scope
·
.
in
the
case
of
The
functions
fn:collection()
fn:position
and
,
,fn:doc()
fn:last
fn:id
,
fn:idref
,
fn:elementwithid
,
fn:lang
,
fn:localname
,
fn:name
,
fn:namespaceuri
,
fn:normalizespace
,
fn:number
,
fn:root
,
fn:string
,
and
fn:stringlength
depend
on
the
requirement
for
stability
may
be
relaxed:
see
focus.
These
functions
will
in
general
return
different
results
on
different
calls
if
the
function
definitions
for
details.
focus
is
different.
Some
other
functions,
for
example
The
function
and
many
stringhandling
operators
and
functions
depend
on
the
default
collation
and
the
inscope
collations,
which
are
both
properties
of
the
static
context.
If
a
particular
call
of
one
of
these
functions
is
evaluated
twice
with
the
same
arguments
then
it
will
return
the
same
result
each
time
(because
the
static
context,
by
definition,
does
not
change
at
run
time).
However,
two
distinct
calls
(that
is,
two
calls
on
the
function
appearing
in
different
places
in
the
source
code)
may
produce
different
results
even
if
the
explicit
arguments
are
the
same.
fn:position()
fn:defaultcollation
Functions
such
as
,
fn:last()
fn:staticbaseuri
fn:doc
,
and
fn:collection
depend
on
other
aspects
of
the
dynamic
context
and
may,
therefore,
static
context.
As
with
functions
that
depend
on
collations,
a
single
call
will
produce
different
the
same
results
on
each
time
they
call
if
the
explicit
arguments
are
called.
These
functions
the
same,
but
two
calls
appearing
in
different
places
in
the
source
code
may
produce
different
results.
[Definition]
For
a
·
contextual
·
function,
the
parts
of
the
context
on
which
it
depends
are
said
referred
to
be
as
contextual
implicit
arguments
.
[Definition]
URI
and
URI
reference
A
function
that
is
guaranteed
to
produce
·
identical
·
Within
this
specification,
results
from
repeated
calls
if
the
term
"URI"
refers
explicit
and
implicit
arguments
are
identical
is
referred
to
Universal
Resource
Identifiers
as
stable
.
All
functions
defined
in
[RFC
3986]
and
extended
in
[RFC
3987]
this
specification
are
·
stable
·
with
a
new
name
"IRI".
The
term
"URI
Reference",
unless
otherwise
stated,
refers
to
a
string
in
the
lexical
space
of
stated.
Exceptions
include
the
following:
Some
functions
(such
as
xs:anyURI
fn:distinctvalues
datatype
as
defined
in
[XML
Schema
Part
2:
Datatypes
Second
Edition]
.
Note
that
this
means,
and
fn:unordered
)
produce
results
in
practice,
that
where
this
specification
requires
a
"URI
Reference",
an
IRI
as
defined
in
[RFC
3987]
·
implementationdefined
·
or
·
implementationdependent
·
order.
In
such
cases
there
is
no
guarantee
that
the
order
of
results
from
different
calls
will
be
accepted,
provided
that
other
relevant
specifications
also
permit
an
IRI.
The
term
URI
has
been
retained
in
preference
the
same.
These
functions
are
said
to
IRI
be
orderingunstable
.
The
function
fn:analyzestring
constructs
an
element
node
to
avoid
introducing
new
names
for
concepts
such
as
"Base
URI"
represent
its
results.
There
is
no
guarantee
that
are
defined
or
referenced
across
repeated
calls
with
the
whole
family
of
XML
specifications.
Note
also
that
same
arguments
will
return
the
definition
same
identical
node
(in
the
sense
of
the
operator).
Such
a
function
is
said
to
be
identityunstable
.xs:anyURI
is
Some
functions
(such
as
fn:doc
and
fn:collection
)
create
new
nodes
by
reading
external
documents.
Such
functions
are
guaranteed
to
be
·
stable
·
with
the
exception
that
an
implementation
is
allowed
to
make
them
unstable
as
a
wider
definition
than
user
option.
Where
the
definition
in
[RFC
3987]
results
of
a
function
are
described
as
being
(to
a
greater
or
lesser
extent)
·
implementationdefined
·
;
for
example
it
or
·
implementationdependent
·
,
this
does
not
require
nonASCII
characters
to
by
itself
remove
the
requirement
that
the
results
should
be
escaped.
stable:
that
is,
that
repeated
calls
with
the
same
explicit
and
implicit
arguments
must
return
identical
results.
Accessors
and
their
semantics
are
described
in
[XQuery
1.0
and
XPath
2.0
Data
Model]
Model
(XDM)
1.1]
.
Some
of
these
accessors
are
exposed
to
the
user
through
the
functions
described
below.
Function  Accessor  Accepts  Returns 

fn:nodename

nodename

an optional node 
zero
or
one
xs:QName

fn:nilled

nilled

a node 
an
optional
xs:boolean

fn:string

stringvalue

an optional item or no argument 
xs:string

fn:data

typedvalue

zero or more items  a sequence of atomic values 
fn:baseuri

baseuri

an optional node or no argument 
zero
or
one
xs:anyURI

fn:documenturi

documenturi

an optional node 
zero
or
one
xs:anyURI

Returns
the
name
of
a
node,
as
an
xs:QName
.
fn:nodename
(
$arg
as
node()?
)
as
xs:QName?
Summary:
Returns
an
expandedQName
for
node
kinds
that
can
have
names.
For
other
kinds
of
nodes
it
returns
the
empty
sequence.
If
$arg
is
the
empty
sequence,
the
empty
sequence
is
returned.
Otherwise,
the
function
returns
the
result
of
the
dm:nodename
accessor
as
defined
in
[xpathdatamodel]
(see
Section
5.11
nodename
Accessor
^{
DM
}
).
For
element
and
attribute
nodes,
the
name
of
the
node
is
returned
as
an
xs:QName
,
retaining
the
prefix,
namespace
URI,
and
local
part.
For
processing
instructions,
the
name
of
the
node
is
returned
as
an
xs:QName
in
which
the
prefix
and
namespace
URI
are
absent.
For
a
namespace
node,
the
function
returns
an
empty
sequence
if
the
node
represents
the
default
namespace;
otherwise
it
returns
an
xs:QName
in
which
prefix
and
namespace
URI
are
absent
and
the
local
part
is
the
the
namespace
prefix
being
bound).
For all other kinds of node, the function returns the empty sequence.
Returns true for an element that is nilled .
fn:nilled
(
$arg
as
node()?
)
as
xs:boolean?
Summary:
Returns
an
If
xs:boolean
$arg
indicating
whether
the
argument
node
is
"nilled".
If
the
argument
empty
sequence,
the
function
returns
the
empty
sequence.
Otherwise
the
function
returns
the
result
of
the
dm:nilled
accessor
as
defined
in
[xpathdatamodel]
(see
Section
5.9
nilled
Accessor
^{
DM
}
).
If
$arg
is
not
an
element
node,
the
function
returns
the
empty
sequence.
If
the
argument
$arg
is
an
untyped
element
node,
the
empty
sequence,
function
returns
false.
In
practice,
the
empty
sequence.
function
returns
true
only
for
an
element
node
that
has
the
attribute
xsi:nil="true"
and
that
is
successfully
validated
against
a
schema
that
defines
the
element
to
be
nillable;
the
detailed
rules,
however,
are
defined
in
[xpathdatamodel]
.
Returns
the
value
of
$arg
represented
as
an
xs:string
.
fn:string
()
as
xs:string
fn:string
(
$arg
as
item()?
)
as
xs:string
Summary:
Returns
In
the
value
zeroargument
version
of
the
function,
$arg
represented
as
a
xs:string
.
If
no
argument
is
supplied,
defaults
to
the
context
item
(
.
item.
That
is,
calling
fn:string()
)
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.
If
the
context
item
is
undefined,
error
[
err:XPDY0002
]
XP
is
raised.
equivalent
to
calling
fn:string(.)
.
If
$arg
is
the
empty
sequence,
the
function
returns
the
zerolength
string
is
returned.
string.
If
$arg
is
a
node,
the
function
returns
the
stringvalue
of
the
node,
as
obtained
using
the
dm:stringvalue
accessor
defined
in
the
[xpathdatamodel]
(see
Section
5.13
stringvalue
Accessor
^{
DM
.
}
).
If
$arg
is
an
atomic
value,
then
the
function
returns
the
same
string
as
is
returned
by
result
of
the
expression
"
$arg
cast
as
xs:string
"
(see
17
18
Casting
).
In the zeroargument version of the function, if the context item is undefined, error [ err:XPDY0002 ] ^{ XP } is raised.
If
$arg
is
a
function
item,
error
[
err:FOTY0014
]
is
raised.
Returns the result of atomizing a sequence, that is, replacing all nodes in the sequence by their typed values.
fn:data
(
$arg
as
item()*
)
as
xs:anyAtomicType*
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
returned.
appended
to
the
result
sequence.
If
the
item
is
a
node:
If
node,
the
node
does
not
have
a
typed
value
an
error
of
the
node
is
raised
[
err:FOTY0012
].
Otherwise,
fn:data()
returns
appended
to
the
result
sequence.
The
typed
value
is
a
sequence
of
zero
or
more
atomic
values:
specifically,
the
node
as
defined
by
result
of
the
accessor
function
dm:typedvalue
accessor
as
defined
in
[xpathdatamodel]
(See
Section
5.15
typedvalue
Accessor
^{
DM
.
}
).
If
an
item
in
the
sequence
$arg
is
a
node
that
does
not
have
a
typed
value
then
an
error
is
raised
[
err:FOTY0012
].
If
an
item
in
the
sequence
$arg
is
a
function
item
then
an
error
is
raised
[
err:FOTY0013
].
The
process
of
applying
the
fn:data
function
to
a
sequence
is
referred
to
as
atomization
.
In
many
cases
an
explicit
call
on
fn:data
is
not
required,
because
atomization
is
invoked
implicitly
when
a
node
or
sequence
of
nodes
is
supplied
in
a
context
where
an
atomic
value
or
sequence
of
atomic
values
is
required.
Returns the base URI of a node.
fn:baseuri
()
as
xs:anyURI?
fn:baseuri
(
$arg
as
node()?
)
as
xs:anyURI?
Summary:
Returns
the
value
The
zeroargument
version
of
the
baseuri
URI
property
for
$arg
as
defined
by
the
accessor
function
dm:baseuri()
for
that
kind
returns
the
base
URI
of
node
in
Section
5.2
baseuri
Accessor
DM
.
If
$arg
is
not
specified,
the
behavior
context
node:
it
is
identical
equivalent
to
calling
the
function
with
the
context
item
(
.
)
as
argument.
The
following
errors
fn:baseuri(.)
.
This
may
be
result
in
an
error
being
raised:
if
the
context
item
is
undefined
[
err:XPDY0002
]
^{
XP
}
;
if
the
context
item
is
not
a
node
[
err:XPTY0004
]
^{
XP
}.
The singleargument version of the function behaves as follows:
$arg
is
the
empty
sequence,
the
function
returns
the
empty
dm:baseuri
accessor
applied
to
the
node
$arg
.
This
accessor
is
Note:
See
also
fn:staticbaseuri
.
If
$arg
is
not
specified,
the
following
errors
may
be
raised:
if
the
context
item
is
undefined
[
err:XPDY0002
]
^{
XP
}
;
if
the
context
item
is
not
a
node
[
err:XPTY0004
]
^{
XP
}.
Returns the URI of a resource where a document can be found, if available.
fn:documenturi
(
$arg
as
node()?
)
as
xs:anyURI?
Summary:
Returns
the
value
of
the
documenturi
property
for
If
$arg
as
defined
by
is
the
empty
sequence,
the
dm:documenturi
accessor
function
defined
in
Section
6.1.2
Accessors
DM
.
returns
the
empty
sequence.
If
$arg
is
not
a
document
node,
the
empty
sequence,
function
returns
the
empty
sequence
is
returned.
sequence.
Returns
the
empty
sequence
if
the
node
is
not
a
document
node.
Otherwise,
the
function
returns
the
value
of
the
accessor
dm:documenturi
documenturi
of
the
document
node.
applied
to
$arg
,
as
defined
in
[xpathdatamodel]
(See
Section
6.1.2
Accessors
^{
DM
}
).
In
the
case
of
a
document
node
$D
returned
by
the
fn:doc
function,
or
a
document
node
at
the
root
of
a
tree
containing
a
node
returned
by
the
fn:collection
function,
it
will
always
be
true
that
either
fn:documenturi($D)
returns
the
empty
sequence,
or
that
the
following
expression
is
true:
fn:doc(fn:documenturi($D))
is
$D
.
It
is
implementationdefined
whether
this
guarantee
also
holds
for
document
nodes
obtained
by
other
means,
for
example
a
document
node
passed
as
the
initial
context
node
of
a
query
or
transformation.
In
this
document,
as
well
as
in
[XQuery
1.0:
An
XML
Query
Language]
,
[XML
Path
Language
(XPath)
2.0]
,
and
[XQuery
1.0
and
XPath
2.0
Formal
Semantics]
,
the
phrase
"an
error
is
raised"
is
used.
Raising
an
error
is
equivalent
to
invoking
calling
the
fn:error
function
defined
in
this
section
with
the
provided
error
code.
The
above
phrase
is
normally
accompanied
by
specification
of
a
specific
error,
to
wit:
"an
error
is
raised
[
error
code
]".
Each
error
defined
in
this
document
is
identified
by
an
xs:QName
that
is
in
the
http://www.w3.org/2005/xqterrors
namespace,
represented
in
this
document
by
the
err
prefix.
It
is
this
xs:QName
that
is
actually
passed
as
an
argument
to
the
fn:error
function
invocation.
Invocation
of
function.
Calling
this
function
raises
an
error.
For
a
more
detailed
treatment
of
error
handing,
see
Section
2.3.3
Handling
Dynamic
Errors
^{
XP
}
and
Section
7.2.9
The
fn:error
function
^{
FS
}.
The
fn:error
function
is
a
general
function
that
may
be
invoked
called
as
above
but
may
also
be
invoked
called
from
[XQuery
1.0:
An
XML
Query
Language]
or
[XML
Path
Language
(XPath)
2.0]
applications
with,
for
example,
an
xs:QName
argument.
Calling
the
fn:error
function
raises
an
applicationdefined
error.
fn:error
()
as
none
fn:error
(
$error
$code
as
xs:QName
)
as
none
fn:error
(
$error
$code
as
xs:QName?
,
$description
as
xs:string
)
as
none
fn:error
(


as
xs:QName?
,

$description

as
xs:string
,


$errorobject

as
item()*
)
as
none

Summary:
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
raises
an
supply
information
that
is
associated
with
the
error
condition
and
that
is
made
available
to
a
caller
that
asks
for
information
about
the
error.
While
this
function
never
returns
The
error
may
be
caught
either
by
the
host
language
(using
a
value,
an
try/catch
construct
in
XSLT
or
XQuery,
for
example),
or
by
the
calling
application
or
external
processing
environment.
The
way
in
which
error
information
is
returned
to
the
external
processing
environment
is
·
implementation
dependent
·
If
fn:error
is
called
with
no
arguments,
then
its
behavior
is
the
same
as
an
the
function
call:
fn:error(fn:QName('http://www.w3.org/2005/xqterrors', 'err:FOER0000'))
If
xs:anyURI
$code
or
an
is
the
empty
sequence
then
the
effective
value
is
the
xs:QName
constructed
by:
.
fn:QName('http://www.w3.org/2005/xqterrors', 'err:FOER0000')
There are three pieces of information that may be associated with an error:
The
error
is
xs:anyURI
$code
derived
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
is
used
for
errors
defined
in
this
specification;
other
namespace
URIs
may
be
used
for
errors
defined
by
the
application.
xs:QName
.
An
http://www.w3.org/2005/xqterrors
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
as
in
the
form
.
The
xs:anyURI
NS#LP.
NS#LP
method
by
which
namespace
URI
part
of
the
error
code
should
therefore
not
include
a
fragment
identifier.
The
is
xs:anyURI
or
xs:QName
$description
returned
to
a
naturallanguage
description
of
the
external
processing
environment
is
·
implementation
dependent
·
.
error
condition.
If
an
invocation
provides
The
is
an
arbitrary
value
used
to
convey
additional
information
about
the
error,
and
$description
$errorobject
$errorobject
,
then
these
values
may
also
be
returned
to
the
external
processing
environment.
The
method
by
which
these
values
are
provided
to
used
in
any
way
the
external
environment
is
·
implementation
dependent
·
.
application
chooses.
This function always raises an error.
The
value
of
the
$description
parameter
may
need
to
be
localized.
Note
that
The
type
"none"
is
a
special
type
defined
in
[XQuery
1.0
and
XPath
2.0
Formal
Semantics]
and
is
not
available
to
the
user.
It
indicates
that
the
function
never
returns
and
ensures
that
it
has
the
correct
static
type.
fn:error()
returns
http://www.w3.org/2005/xqterrors#FOER0000
(or
the
corresponding
xs:QName
)
to
the
external
processing
environment.
environment,
unless
the
error
is
caught
using
a
try/catch
construct
in
the
host
language.
fn:error(fn:QName('http://www.example.com/HR',
'myerr:toohighsal'),
'Does
not
apply
because
salary
is
too
high')
returns
http://www.example.com/HR#toohighsal
and
the
xs:string
"Does
not
apply
because
salary
is
too
high"
(or
the
corresponding
xs:QName
)
to
the
external
processing
environment.
environment,
unless
the
error
is
caught
using
a
try/catch
construct
in
the
host
language.
Provides an execution trace intended to be used in debugging queries.
fn:trace
(
$value
as
item()*
,
$label
as
xs:string
)
as
item()*
The
input
$value
is
returned,
unchanged,
as
function
returns
the
result
value
of
the
function.
$value
,
unchanged.
In
addition,
the
inputs
values
of
$value
,
converted
to
an
xs:string
,
and
$label
may
be
directed
to
a
trace
data
set.
The
destination
of
the
trace
output
is
·
implementationdefined
·
.
The
format
of
the
trace
output
is
·
implementation
dependent
·
.
The
ordering
of
output
from
invocations
calls
of
the
function
is
·
implementation
dependent
·
.
fn:trace()
fn:trace
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.
This
section
discusses
specifies
arithmetic
operators
on
the
numeric
datatypes
defined
in
[XML
Schema
Part
2:
Datatypes
Second
Edition]
.
It
uses
an
approach
that
permits
lightweight
implementation
whenever
possible.
The operators described in this section are defined on the following numeric types. Each type whose name is indented is derived from the type whose name appears nearest above with one less level of indentation.
xs:decimal  
xs:integer  
xs:float  
xs:double 
They also apply to types derived by restriction from the above types.
Note:
This
specification
uses
[IEEE
7541985]
arithmetic
for
xs:float
and
xs:double
values.
This
differs
from
[XML
Schema
Part
2:
Datatypes
Second
Edition]
which
defines
NaN
as
being
equal
to
itself
and
defines
only
a
single
zero
in
the
value
space
while
[IEEE
7541985]
arithmetic
treats
NaN
as
unequal
to
all
other
values
including
itself
and
can
produce
distinct
results
of
positive
zero
and
negative
zero.
(These
are
two
different
machine
representations
for
the
same
[XML
Schema
Part
2:
Datatypes
Second
Edition]
value.)
The
text
accompanying
several
functions
discusses
behaviour
defines
behavior
for
both
positive
and
negative
zero
inputs
and
outputs
in
the
interest
of
alignment
with
[IEEE
7541985]
.
XML Schema 1.1, however, introduces support for positive and negative zero as distinct values.
The following functions define the semantics of arithmetic operators defined in [XQuery 1.0: An XML Query Language] and [XML Path Language (XPath) 2.0] on these numeric types.
Operators  Meaning 

op:numericadd

Addition 
op:numericsubtract

Subtraction 
op:numericmultiply

Multiplication 
op:numericdivide

Division 
op:numericintegerdivide

Integer division 
op:numericmod

Modulus 
op:numericunaryplus

Unary plus 
op:numericunaryminus

Unary minus (negation) 
The
parameters
and
return
types
for
the
above
operators
are
the
basic
numeric
types:
xs:integer
,
xs:decimal
,
xs:float
and
xs:double
,
and
types
derived
from
them.
The
word
"
numeric
"
in
function
signatures
signifies
these
four
types.
For
simplicity,
each
operator
is
defined
to
operate
on
operands
of
the
same
type
and
return
the
same
type.
The
exceptions
are
op:numericdivide
,
which
returns
an
xs:decimal
if
called
with
two
xs:integer
operands
and
op:numericintegerdivide
which
always
returns
an
xs:integer
.
If the two operands are not of the same type, subtype substitution and numeric type promotion are used to obtain two operands of the same type. Section B.1 Type Promotion ^{ XP } and Section B.2 Operator Mapping ^{ XP } describe the semantics of these operations in detail.
The result type of operations depends on their argument datatypes and is defined in the following table:
Operator  Returns 

op:operation(xs:integer,
xs:integer)

xs:integer
(except
for
op:numericdivide(integer,
integer)
,
which
returns
xs:decimal
)

op:operation(xs:decimal,
xs:decimal)

xs:decimal

op:operation(xs:float,
xs:float)

xs:float

op:operation(xs:double,
xs:double)

xs:double

op:operation(xs:integer)

xs:integer

op:operation(xs:decimal)

xs:decimal

op:operation(xs:float)

xs:float

op:operation(xs:double)

xs:double

These rules define any operation on any pair of arithmetic types. Consider the following example:
op:operation(xs:int, xs:double) => op:operation(xs:double, xs:double)
For
this
operation,
xs:int
must
be
converted
to
xs:double
.
This
can
be
done,
since
by
the
rules
above:
xs:int
can
be
substituted
for
xs:integer
,
xs:integer
can
be
substituted
for
xs:decimal
,
xs:decimal
can
be
promoted
to
xs:double
.
As
far
as
possible,
the
promotions
should
be
done
in
a
single
step.
Specifically,
when
an
xs:decimal
is
promoted
to
an
xs:double
,
it
should
not
be
converted
to
an
xs:float
and
then
to
xs:double
,
as
this
risks
loss
of
precision.
As
another
example,
a
user
may
define
height
as
a
derived
type
of
xs:integer
with
a
minimum
value
of
20
and
a
maximum
value
of
100.
He
may
then
derive
fenceHeight
using
an
enumeration
to
restrict
the
permitted
set
of
values
to,
say,
36,
48
and
60.
op:operation(fenceHeight, xs:integer) => op:operation(xs:integer, xs:integer)
fenceHeight
can
be
substituted
for
its
base
type
height
and
height
can
be
substituted
for
its
base
type
xs:integer
.
The
basic
rules
for
addition,
subtraction,
and
multiplication
of
ordinary
numbers
are
not
set
out
in
this
specification;
they
are
taken
as
given.
In
the
case
of
xs:double
and
xs:float
the
rules
are
as
defined
in
[IEEE
7541985]
.
The
rules
for
handling
division
and
modulus
operations,
as
well
as
the
rules
for
handling
special
values
such
as
infinity
and
NaN
,
and
exception
conditions
such
as
overflow
and
underflow,
are
described
more
explicitly
since
they
are
not
necessarily
obvious.
On overflow and underflow situations during arithmetic operations conforming implementations · must · behave as follows:
For
xs:float
and
xs:double
operations,
overflow
behavior
·
must
·
be
conformant
with
[IEEE
7541985]
.
This
specification
allows
the
following
options:
Raising an error [ err:FOAR0002 ] via an overflow trap.
Returning
INF
or
INF
.
Returning the largest (positive or negative) noninfinite number.
For
xs:float
and
xs:double
operations,
underflow
behavior
·
must
·
be
conformant
with
[IEEE
7541985]
.
This
specification
allows
the
following
options:
Raising an error [ err:FOAR0002 ] via an underflow trap.
Returning
0.0E0
or
+/
2**Emin
or
a
denormalized
value;
where
Emin
is
the
smallest
possible
xs:float
or
xs:double
exponent.
For
xs:decimal
operations,
overflow
behavior
·
must
·
raise
an
error
[
err:FOAR0002
].
On
underflow,
0.0
must
be
returned.
For
xs:integer
operations,
implementations
that
support
limitedprecision
integer
operations
·
must
·
select
from
the
following
options:
They · may · choose to always raise an error [ err:FOAR0002 ].
They · may · provide an · implementationdefined · mechanism that allows users to choose between raising an error and returning a result that is modulo the largest representable integer value. See [ISO 10967] .
The
functions
op:numericadd
,
op:numericsubtract
,
op:numericmultiply
,
op:numericdivide
,
op:numericintegerdivide
and
op:numericmod
are
each
defined
for
pairs
of
numeric
operands,
each
of
which
has
the
same
type:
xs:integer
,
xs:decimal
,
xs:float
,
or
xs:double
.
The
functions
op:numericunaryplus
and
op:numericunaryminus
are
defined
for
a
single
operand
whose
type
is
one
of
those
same
numeric
types.
For
xs:float
and
xs:double
arguments,
if
either
argument
is
NaN
,
the
result
is
NaN
.
For
xs:decimal
values
the
number
of
digits
of
precision
returned
by
the
numeric
operators
is
·
implementationdefined
·
.
If
the
number
of
digits
in
the
result
exceeds
the
number
of
digits
that
the
implementation
supports,
the
result
is
truncated
or
rounded
in
an
·
implementationdefined
·
manner.
Returns
the
arithmetic
sum
of
its
operands:
(
$arg1
+
$arg2
).
Defines the semantics of the "+" operator applied to numeric values
op:numericadd
(
$arg1
as
numeric
,
$arg2
as
numeric
)
as
numeric
Summary:
Backs
up
the
"+"
operator
and
returns
the
arithmetic
sum
of
its
operands:
(
$arg1
+
$arg2
).
General
rules:
see
Note:
4.2
Arithmetic
Operators
on
Numeric
Values
.
For
xs:float
or
xs:double
values,
if
one
of
the
operands
is
a
zero
or
a
finite
number
and
the
other
is
INF
or
INF
,
INF
or
INF
is
returned.
If
both
operands
are
INF
,
INF
is
returned.
If
both
operands
are
INF
,
INF
is
returned.
If
one
of
the
operands
is
INF
and
the
other
is
INF
,
NaN
is
returned.
Returns
the
arithmetic
difference
of
its
operands:
(
$arg1

$arg2
).
Defines the semantics of the "" operator applied to numeric values.
op:numericsubtract
(
$arg1
as
numeric
,
$arg2
as
numeric
)
as
numeric
Summary:
Backs
up
the
""
operator
and
returns
the
arithmetic
difference
of
its
operands:
(
$arg1

$arg2
).
General
rules:
see
Note:
4.2
Arithmetic
Operators
on
Numeric
Values
.
For
xs:float
or
xs:double
values,
if
one
of
the
operands
is
a
zero
or
a
finite
number
and
the
other
is
INF
or
INF
,
an
infinity
of
the
appropriate
sign
is
returned.
If
both
operands
are
INF
or
INF
,
NaN
is
returned.
If
one
of
the
operands
is
INF
and
the
other
is
INF
,
an
infinity
of
the
appropriate
sign
is
returned.
Returns
the
arithmetic
product
of
its
operands:
(
$arg1
*
$arg2
).
Defines the semantics of the "*" operator applied to numeric values.
op:numericmultiply
(
$arg1
as
numeric
,
$arg2
as
numeric
)
as
numeric
Summary:
Backs
up
the
"*"
operator
and
returns
the
arithmetic
product
of
its
operands:
(
$arg1
*
$arg2
).
General
rules:
see
Note:
4.2
Arithmetic
Operators
on
Numeric
Values
.
For
xs:float
or
xs:double
values,
if
one
of
the
operands
is
a
zero
and
the
other
is
an
infinity,
NaN
is
returned.
If
one
of
the
operands
is
a
nonzero
number
and
the
other
is
an
infinity,
an
infinity
with
the
appropriate
sign
is
returned.
Returns
the
arithmetic
quotient
of
its
operands:
(
$arg1
div
$arg2
).
Defines the semantics of the "div" operator applied to numeric values.
op:numericdivide
(
$arg1
as
numeric
,
$arg2
as
numeric
)
as
numeric
Summary:
Backs
up
the
"div"
operator
and
returns
the
arithmetic
quotient
of
its
operands:
(
$arg1
div
$arg2
).
General
rules:
see
4.2
Arithmetic
Operators
on
Numeric
Values
.
As
a
special
case,
if
the
types
of
both
$arg1
and
$arg2
are
xs:integer
,
then
the
return
type
is
xs:decimal
.
For
xs:decimal
and
xs:integer
operands,
if
the
divisor
is
(positive
or
negative)
zero,
an
error
is
raised
[
err:FOAR0001
].
For
xs:float
and
xs:double
operands,
floating
point
division
is
performed
as
specified
in
[IEEE
7541985]
.
For
xs:float
or
xs:double
values,
a
A
positive
number
divided
by
positive
zero
returns
INF
.
A
negative
number
divided
by
positive
zero
returns
INF
.
Division
by
negative
zero
returns
INF
and
INF
,
respectively.
Positive
or
negative
zero
divided
by
positive
or
negative
zero
returns
NaN
.
Also,
INF
or
INF
divided
by
INF
or
INF
returns
NaN
.
Performs an integer division.
Defines the semantics of the "idiv" operator applied to numeric values.
op:numericintegerdivide
(
$arg1
as
numeric
,
$arg2
as
numeric
)
as
xs:integer
Summary:
This
function
backs
up
the
"idiv"
operator
and
performs
an
integer
division:
that
is,
it
divides
the
first
argument
by
the
second,
and
returns
the
integer
obtained
by
truncating
the
fractional
part
of
the
result.
The
division
is
performed
so
that
the
sign
of
the
fractional
part
is
the
same
as
the
sign
of
the
dividend.
General
rules:
see
4.2
Arithmetic
Operators
on
Numeric
Values
.
If
the
dividend,
$arg2
is
INF
or
INF,
and
$arg1
,
is
not
evenly
divided
by
the
divisor,
$arg2
,
INF
or
INF,
then
the
quotient
result
is
zero.
Otherwise,
subject
to
limits
of
precision
and
overflow/underflow
conditions,
the
result
is
the
largest
(furthest
from
zero)
xs:integer
value
obtained,
ignoring
(truncating)
any
remainder
$N
such
that
results
from
the
division
(that
is,
no
rounding
is
performed).
Thus,
the
semantics
"
$a
idiv
$b
fn:abs($N
*
$arg2)
le
fn:abs($arg1)
and
fn:compare($N
*
$arg2,
0)
eq
fn:compare($arg1,
0)
"
are
.
Note:
The second term in this condition ensures that the result has the correct sign.
The
implementation
may
adopt
a
different
algorithm
provided
that
it
is
equivalent
to
"
this
formulation
in
all
cases
where
·
implementationdependent
·
or
·
implementationdefined
·
behavior
does
not
affect
the
outcome,
for
example,
the
implementationdefined
precision
of
the
result
of
($a
div
$b)
cast
as
xs:integer
xs:decimal
"
except
for
error
situations.
division.
If the divisor is (positive or negative) zero, then an error is raised [ err:FOAR0001 ].
If
either
operand
is
NaN
or
if
$arg1
is
INF
or
INF
then
an
error
is
raised
[
err:FOAR0002
].
Except
in
situations
involving
errors,
loss
of
precision,
or
overflow/underflow,
the
result
of
$a
idiv
$b
is
the
same
as
($a
div
$b)
cast
as
xs:integer
.
The semantics of this function are different from integer division as defined in programming languages such as Java and C++.
The
expression
op:numericintegerdivide(10,3)
returns
3
.
The
expression
op:numericintegerdivide(3,2)
returns
1
.
The
expression
op:numericintegerdivide(3,2)
returns
1
.
The
expression
op:numericintegerdivide(3,2)
returns
1
.
The
expression
op:numericintegerdivide(9.0,3)
returns
3
.
The
expression
op:numericintegerdivide(3.5,3)
returns
1
.
The
expression
op:numericintegerdivide(3.0,4)
returns
0
.
The
expression
op:numericintegerdivide(3.1E1,6)
returns
5
.
The
expression
op:numericintegerdivide(3.1E1,7)
returns
4
.
Returns
the
remainder
resulting
from
dividing
$arg1
,
the
dividend,
by
$arg2
,
the
divisor.
Defines the semantics of the "mod" operator applied to numeric values.
op:numericmod
(
$arg1
as
numeric
,
$arg2
as
numeric
)
as
numeric
General rules: see 4.2 Arithmetic Operators on Numeric Values .
Summary:
Backs
up
the
"mod"
operator.
Informally,
this
function
returns
the
remainder
resulting
from
dividing
$arg1
,
the
dividend,
by
$arg2
,
the
divisor.
The
operation
a
mod
b
for
operands
that
are
xs:integer
or
xs:decimal
,
or
types
derived
from
them,
produces
a
result
such
that
(a
idiv
b)*b+(a
mod
b)
is
equal
to
a
and
the
magnitude
of
the
result
is
always
less
than
the
magnitude
of
b
.
This
identity
holds
even
in
the
special
case
that
the
dividend
is
the
negative
integer
of
largest
possible
magnitude
for
its
type
and
the
divisor
is
1
(the
remainder
is
0).
It
follows
from
this
rule
that
the
sign
of
the
result
is
the
sign
of
the
dividend.
For
and
xs:integer
and
xs:decimal
operands,
if
$arg2
is
zero,
then
an
error
is
raised
[
err:FOAR0001
].
For
xs:float
xs:double
operands
the
following
rules
apply:
If
either
operand
is
NaN
,
the
result
is
NaN
.
If
the
dividend
is
positive
or
negative
infinity,
or
the
divisor
is
positive
or
negative
zero
(0),
or
both,
the
result
is
NaN
.
If the dividend is finite and the divisor is an infinity, the result equals the dividend.
If the dividend is positive or negative zero and the divisor is finite, the result is the same as the dividend.
In
the
remaining
cases,
where
neither
positive
or
negative
infinity,
nor
positive
or
negative
zero,
nor
NaN
is
involved,
the
result
obeys
(a
idiv
b)*b+(a
mod
b)
=
a
.
Division
is
truncating
division,
analogous
to
integer
division,
not
[IEEE
7541985]
rounding
division
i.e.
additional
digits
are
truncated,
not
rounded
to
the
required
precision.
For
xs:integer
and
xs:decimal
operands,
if
$arg2
is
zero,
then
an
error
is
raised
[
err:FOAR0001
6.2.6.1
].
The
expression
op:numericmod(10,3)
returns
1
.
The
expression
op:numericmod(6,2)
returns
0
.
The
expression
op:numericmod(4.5,1.2)
returns
0.9
.
The
expression
op:numericmod(1.23E2,
0.6E1)
returns
3.0E0
.
Returns
its
operand
with
the
sign
unchanged:
(
+
$arg
).
Defines the semantics of the unary "+" operator applied to numeric values.
op:numericunaryplus
(
$arg
as
numeric
)
as
numeric
Summary:
Backs
up
the
unary
"+"
operator
General
rules:
see
4.2
Arithmetic
Operators
on
Numeric
Values
.
The
returned
value
is
equal
to
$arg
,
and
returns
its
operand
with
is
an
instance
of
xs:integer
,
xs:decimal
,
xs:double
,
or
xs:float
depending
on
the
sign
unchanged:
(+
type
of
$arg
.
).
Semantically,
this
operation
performs
no
operation.
Returns
its
operand
with
the
sign
reversed:
(

$arg
).
Defines the semantics of the unary "" operator applied to numeric values.
op:numericunaryminus
(
$arg
as
numeric
)
as
numeric
Summary:
Backs
up
the
unary
""
operator
and
returns
its
operand
with
the
sign
reversed:
(
General
rules:
see
4.2
Arithmetic
Operators
on
Numeric
Values
.
The
returned
value
is
an
instance
of
,$arg
xs:integer
xs:decimal
,
xs:double
,
or
xs:float
).
If
depending
on
the
type
of
$arg
.
is
positive,
its
negative
is
returned;
if
it
is
negative,
its
positive
is
returned.
For
xs:integer
and
xs:decimal
arguments,
0
and
0.0
return
0
and
0.0
,
respectively.
For
xs:float
and
xs:double
arguments,
NaN
returns
NaN
,
0.0E0
returns
0.0E0
and
vice
versa.
INF
returns
INF
.
INF
returns
INF
.
This
specification
defines
the
following
comparison
operators
on
numeric
values.
Comparisons
take
two
arguments
of
the
same
type.
If
the
arguments
are
of
different
types,
one
argument
is
promoted
to
the
type
of
the
other
as
described
above
in
6.2
4.2
Arithmetic
Operators
on
Numeric
Values
.
Each
comparison
operator
returns
a
boolean
value.
If
either,
or
both,
operands
are
NaN
,
false
is
returned.

Meaning 

op:numericequal

$arg1
is
equal
to
the
value
of
$arg2
.

op:numericlessthan

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

op:numericgreaterthan

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

Returns
true
if
and
only
if
the
value
of
$arg1
is
equal
to
the
value
of
$arg2
.
Defines the semantics of the "eq" operator on numeric values, and is also used in defining the semantics of "ne", "le" and "ge".
op:numericequal
(
$arg1
as
numeric
,
$arg2
as
numeric
)
as
xs:boolean
Summary:
Returns
true
if
General
rules:
see
4.2
Arithmetic
Operators
on
Numeric
Values
and
only
if
the
value
of
$arg1
is
equal
to
the
value
of
$arg2
.
4.3
Comparison
Operators
on
Numeric
Values
.
For
xs:float
and
xs:double
values,
positive
zero
and
negative
zero
compare
equal.
INF
equals
INF
,
and
INF
equals
INF
.
NaN
does
not
equal
itself.
Returns
true
if
and
only
if
$arg1
is
numerically
less
than
$arg2
.
Defines the semantics of the "lt" operator on numeric values, and is also used in defining the semantics of "le".
op:numericlessthan
(
$arg1
as
numeric
,
$arg2
as
numeric
)
as
xs:boolean
Summary:
Returns
true
if
General
rules:
see
4.2
Arithmetic
Operators
on
Numeric
Values
and
only
if
$arg1
is
less
than
$arg2
.
4.3
Comparison
Operators
on
Numeric
Values
.
For
xs:float
and
xs:double
values,
positive
infinity
is
greater
than
all
other
non
NaN
values;
negative
infinity
is
less
than
all
other
non
NaN
values.
If
$arg1
or
$arg2
is
NaN
,
the
function
returns
false
.
Returns
true
if
and
only
if
$arg1
is
numerically
greater
than
$arg2
.
Defines the semantics of the "gt" operator on numeric values, and is also used in defining the semantics of "ge".
op:numericgreaterthan
(
$arg1
as
numeric
,
$arg2
as
numeric
)
as
xs:boolean
Summary:
Returns
true
if
and
only
if
$arg1
is
greater
than
$arg2
.
For
xs:float
and
xs:double
values,
positive
infinity
is
greater
than
all
other
non
NaN
values;
negative
infinity
is
less
than
all
other
non
NaN
values.
If
$arg1
or
The
function
call
is
$arg2
op:numericgreaterthan($A,
$B)
NaN
,
defined
to
return
the
function
returns
same
result
as
false
.
This
function
backs
up
the
"gt"
and
"ge"
operators
on
numeric
values.
op:numericlessthan($B,
$A)
The following functions are defined on numeric types. Each function returns a value of the same type as the type of its argument.
If the argument is the empty sequence, the empty sequence is returned.
For
xs:float
and
xs:double
arguments,
if
the
argument
is
"NaN",
"NaN"
is
returned.
Except
for
,
for
fn:abs()
fn:abs
xs:float
and
xs:double
arguments,
if
the
argument
is
positive
or
negative
infinity,
positive
or
negative
infinity
is
returned.
Function  Meaning 

fn:abs

Returns
the
absolute
value
of
$arg
.

fn:ceiling

$arg
upwards
to

fn:floor

$arg
downwards
to

fn:round

Rounds
a
value
to

fn:roundhalftoeven


Note:
fn:round
and
fn:roundhalftoeven
produce
the
same
result
in
all
cases
except
when
the
argument
is
exactly
midway
between
two
values
with
the
required
precision.
Other ways of rounding midway values can be achieved as follows:
Towards
negative
infinity:
fn:round($x)
Away
from
zero:
fn:round(fn:abs($x))*fn:compare($x,0)
Towards
zero:
fn:abs(fn:round($x))*fn:compare($x,0)
Returns
the
absolute
value
of
$arg
.
fn:abs
(
$arg
as
numeric?
)
as
numeric?
General rules: see 4.4 Functions on Numeric Values .
Summary:
Returns
the
absolute
value
of
$arg
.
If
$arg
is
negative
the
function
returns
$arg
,
otherwise
it
returns
$arg
.
If
the
type
of
$arg
is
one
of
the
four
numeric
types
xs:float
,
xs:double
,
xs:decimal
or
xs:integer
the
type
of
the
result
is
the
same
as
the
type
of
$arg
.
If
the
type
of
$arg
is
a
type
derived
from
one
of
the
numeric
types,
the
result
is
an
instance
of
the
base
numeric
type.
For
xs:float
and
xs:double
arguments,
if
the
argument
is
positive
zero
or
negative
zero,
then
positive
zero
is
returned.
If
the
argument
is
positive
or
negative
infinity,
positive
infinity
is
returned.
For detailed type semantics, see Section 7.2.3 The fn:abs, fn:ceiling, fn:floor, fn:round, and fn:roundhalftoeven functions ^{ FS }
The
expression
fn:abs(10.5)
returns
10.5
.
The
expression
fn:abs(10.5)
returns
10.5
.
Rounds
$arg
upwards
to
a
whole
number.
fn:ceiling
(
$arg
as
numeric?
)
as
numeric?
Summary:
Returns
General
rules:
see
4.4
Functions
on
Numeric
Values
.
The
function
returns
the
smallest
(closest
to
negative
infinity)
number
with
no
fractional
part
that
is
not
less
than
the
value
of
$arg
.
If
the
type
of
$arg
is
one
of
the
four
numeric
types
xs:float
,
xs:double
,
xs:decimal
or
xs:integer
the
type
of
the
result
is
the
same
as
the
type
of
$arg
.
If
the
type
of
$arg
is
a
type
derived
from
one
of
the
numeric
types,
the
result
is
an
instance
of
the
base
numeric
type.
For
xs:float
and
xs:double
arguments,
if
the
argument
is
positive
zero,
then
positive
zero
is
returned.
If
the
argument
is
negative
zero,
then
negative
zero
is
returned.
If
the
argument
is
less
than
zero
and
greater
than
1,
negative
zero
is
returned.
For detailed type semantics, see Section 7.2.3 The fn:abs, fn:ceiling, fn:floor, fn:round, and fn:roundhalftoeven functions ^{ FS }
The
expression
fn:ceiling(10.5)
returns
11
.
The
expression
fn:ceiling(10.5)
returns
10
.
Rounds
$arg
downwards
to
a
whole
number.
fn:floor
(
$arg
as
numeric?
)
as
numeric?
Summary:
Returns
General
rules:
see
4.4
Functions
on
Numeric
Values
.
The
function
returns
the
largest
(closest
to
positive
infinity)
number
with
no
fractional
part
that
is
not
greater
than
the
value
of
$arg
.
If
the
type
of
$arg
is
one
of
the
four
numeric
types
xs:float
,
xs:double
,
xs:decimal
or
xs:integer
the
type
of
the
result
is
the
same
as
the
type
of
$arg
.
If
the
type
of
$arg
is
a
type
derived
from
one
of
the
numeric
types,
the
result
is
an
instance
of
the
base
numeric
type.
For
and
float
xs:float
arguments,
if
the
argument
is
positive
zero,
then
positive
zero
is
returned.
If
the
argument
is
negative
zero,
then
negative
zero
is
returned.
double
xs:double
For detailed type semantics, see Section 7.2.3 The fn:abs, fn:ceiling, fn:floor, fn:round, and fn:roundhalftoeven functions ^{ FS }
The
expression
fn:floor(10.5)
returns
10
.
The
expression
fn:floor(10.5)
returns
11
.
Rounds a value to a specified number of decimal places, rounding upwards if two such values are equally near.
fn:round
(
$arg
as
numeric?
)
as
numeric?
fn:round
(
$arg
as
numeric?
,
$precision
as
xs:integer
)
as
numeric?
Summary:
Returns
General
rules:
see
4.4
Functions
on
Numeric
Values
.
The
function
returns
the
number
with
no
fractional
part
nearest
(that
is,
numerically
closest)
value
to
$arg
that
is
closest
a
multiple
of
ten
to
the
argument.
power
of
minus
$precision
.
If
there
are
two
such
numbers,
then
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
is
returned.
infinity.
If
the
type
of
$arg
is
one
of
the
four
numeric
types
xs:float
,
xs:double
,
xs:decimal
or
xs:integer
the
type
of
the
result
is
the
same
as
the
type
of
$arg
.
If
the
type
of
$arg
is
a
type
derived
from
one
of
the
numeric
types,
the
result
is
an
instance
of
the
base
numeric
type.
For
The
singleargument
version
of
this
function
produces
the
same
result
as
the
twoargument
version
with
$precision=0
(that
is,
it
rounds
to
a
whole
number).
When
$arg
is
of
type
xs:float
and
xs:double
:
If
$arg
arguments,
if
the
argument
is
NaN,
positive
infinity,
then
or
negative
zero,
or
positive
infinity
is
returned.
If
the
argument
is
or
negative
infinity,
then
negative
infinity
the
result
is
returned.
If
the
same
as
the
argument.
For
other
values,
the
argument
is
positive
zero,
then
positive
zero
is
returned.
If
cast
to
xs:decimal
using
an
implementation
of
xs:decimal
that
imposes
no
limits
on
the
argument
number
of
digits
that
can
be
represented.
The
function
is
negative
zero,
then
negative
zero
applied
to
this
xs:decimal
value,
and
the
resulting
xs:decimal
is
returned.
cast
back
to
xs:float
or
xs:double
as
appropriate
to
form
the
function
result.
If
the
argument
resulting
xs:decimal
value
is
less
than
zero,
but
greater
than
or
equal
to
0.5,
then
negative
zero
is
returned.
In
the
cases
where
positive
zero
or
negative
zero
is
returned,
negative
zero
or
positive
zero
may
be
returned
as
[XML
Schema
Part
2:
Datatypes
Second
Edition]
does
not
distinguish
between
the
values
positive
zero
and
negative
zero.
For
the
last
two
cases,
note
that
the
result
is
not
according
to
the
same
as
sign
of
.
fn:floor(x+0.5)
.
$arg
For detailed type semantics, see Section 7.2.3 The fn:abs, fn:ceiling, fn:floor, fn:round, and fn:roundhalftoeven functions ^{ FS }
This
function
is
typically
used
with
a
nonzero
$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
counterintuitive.
For
example,
consider
round(35.425e0,
2)
.
The
result
is
not
35.43,
as
might
be
expected,
but
35.42.
This
is
because
the
conversion
of
35.425e0
to
xs:decimal
produces
the
decimal
value
35.42499999999...,
which
is
closer
to
35.42
than
to
35.43.
The
expression
fn:round(2.5)
returns
.
3.
3.0
The
expression
fn:round(2.4999)
returns
.
2
2.0
The
expression
fn:round(2.5)
returns
.
(Not
the
possible
alternative,
2
(not
2.0
3
).
The
expression
fn:round(1.125,
2)
returns
1.13
.
The
expression
fn:round(8452,
2)
returns
8500
.
The
expression
fn:round(3.1415e0,
2)
returns
3.14e0
.
Rounds a value to a specified number of decimal places, rounding to make the last digit even if two such values are equally near.
fn:roundhalftoeven
(
$arg
as
numeric?
)
as
numeric?
fn:roundhalftoeven
(
$arg
as
numeric?
,
$precision
as
xs:integer
)
as
numeric?
General rules: see 4.4 Functions on Numeric Values .
Summary:
The
value
returned
is
function
returns
the
nearest
(that
is,
numerically
closest)
value
to
$arg
that
is
a
multiple
of
ten
to
the
power
of
minus
$precision
.
If
two
such
values
are
equally
near
(e.g.
if
the
fractional
part
in
$arg
is
exactly
.500...),
the
function
returns
the
one
whose
least
significant
digit
is
even.
If
the
type
of
$arg
is
one
of
the
four
numeric
types
xs:float
,
xs:double
,
xs:decimal
or
xs:integer
the
type
of
the
result
is
the
same
as
the
type
of
$arg
.
If
the
type
of
$arg
is
a
type
derived
from
one
of
the
numeric
types,
the
result
is
an
instance
of
the
base
numeric
type.
The
first
signature
of
this
function
produces
the
same
result
as
the
second
signature
with
$precision=0
.
For
arguments
of
type
xs:float
and
xs:double
:
,
if
If
the
argument
is
NaN
,
positive
or
negative
zero,
or
positive
or
negative
infinity,
then
the
result
is
the
same
as
the
argument.
In
all
other
cases,
the
argument
is
cast
to
xs:decimal
using
an
implementation
of
xs:decimal
that
imposes
no
limits
on
the
number
of
digits
that
can
be
represented.
The
function
is
applied
to
this
,
xs:decimal
value,
and
the
resulting
xs:decimal
is
cast
back
to
xs:float
or
xs:double
as
appropriate
to
form
the
function
result.
If
the
resulting
xs:decimal
value
is
zero,
then
positive
or
negative
zero
is
returned
according
to
the
sign
of
the
original
argument.
For detailed type semantics, see Section 7.2.3 The fn:abs, fn:ceiling, fn:floor, fn:round, and fn:roundhalftoeven functions ^{ FS }
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
counterintuitive.
counterintuitive.
For
example,
consider
.
The
result
is
not
150.02
as
might
be
expected,
but
150.01.
This
is
because
the
conversion
of
the
roundhalftoeven(xs:float(150.0150),
roundhalftoeven(xs:float(150.015),
2)
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.
The
expression
fn:roundhalftoeven(0.5)
returns
0.0
.
The
expression
fn:roundhalftoeven(1.5)
returns
2.0
.
The
expression
fn:roundhalftoeven(2.5)
returns
2.0
.
The
expression
fn:roundhalftoeven(3.567812e+3,
2)
returns
3567.81e0
.
The
expression
fn:roundhalftoeven(4.7564e3,
2)
returns
0.0e0
.
The
expression
fn:roundhalftoeven(35612.25,
2)
returns
35600
.
formats an integer according to a given picture string, using the conventions of a given natural language if specified.
fn:formatinteger
(
$value
as
xs:integer?
,
$picture
as
xs:string
)
as
xs:string
fn:formatinteger
(

$value

as
xs:integer?
, 
$picture

as
xs:string
,  
$language

as
xs:language
)
as
xs:string

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

If
$value
is
an
empty
sequence,
the
function
returns
a
zerolength
string.
In
all
other
cases,
the
$picture
argument
describes
the
format
in
which
$value
is
output.
The
rules
that
follow
describe
how
nonnegative
numbers
are
output.
If
the
value
of
$value
is
negative,
the
rules
below
are
applied
to
the
absolute
value
of
$value
,
and
the
result
is
prepended
with
a
minus
sign.
A picture consists of a primary format token, followed by an optional format modifier.
The primary format token is one of the following:
Any
sequence
of
Unicode
digits
drawn
from
the
same
digit
family,
where
a
digit
family
is
a
sequence
of
ten
consecutive
Unicode
characters
in
category
Nd,
having
digit
values
0
through
9.
The
corresponding
output
format
is
a
decimal
number,
using
this
digit
family,
with
at
least
as
many
digits
as
there
are
in
the
format
token.
Thus,
a
format
token
1
generates
the
sequence
0
1
2
...
10
11
12
...
,
and
a
format
token
01
(or
equivalently,
00
or
99
)
generates
the
sequence
00
01
02
...
09
10
11
12
...
99
100
101
.
A
format
token
of
١
(ArabicIndic
digit
one)
generates
the
sequence
١
then
٢
then
٣
...
Any
sequence
of
Unicode
digits
drawn
from
the
same
digit
family,
interspersed
by
grouping
separators.
The
digits
are
handled
as
above,
and
the
grouping
separators
are
handled
as
follows.
A
character
is
recognized
as
a
grouping
separator
if
it
is
nonalphanumeric,
that
is,
if
its
Unicode
character
category
is
other
than
Nd,
Nl,
No,
Lu,
Ll,
Lt,
Lm
or
Lo.
The
position
of
grouping
separators
within
the
format
token,
counting
backwards
from
the
last
digit,
indicates
the
position
of
grouping
separators
to
appear
within
the
formatted
number,
and
the
character
used
as
the
grouping
separator
within
the
format
token
indicates
the
character
to
be
used
as
the
corresponding
grouping
separator
in
the
formatted
number.
If
grouping
separators
appear
at
regular
intervals
within
the
format
token,
that
is
if
the
same
grouping
separator
appears
at
positions
forming
a
sequence
N,
2N,
3N,
...
for
some
integer
value
N
(including
the
case
where
there
is
only
one
number
in
the
list),
then
the
sequence
is
extrapolated
to
the
left,
so
grouping
separators
will
be
used
in
the
formatted
number
at
every
multiple
of
N.
For
example,
if
the
format
token
is
0'000
then
the
number
one
million
will
be
formatted
as
1'000'000
.
A
format
token
A
generates
the
sequence
A
B
C
...
Z
AA
AB
AC...
.
A
format
token
a
generates
the
sequence
a
b
c
...
z
aa
ab
ac...
.
A
format
token
i
generates
the
sequence
i
ii
iii
iv
v
vi
vii
viii
ix
x
...
.
A
format
token
I
generates
the
sequence
I
II
III
IV
V
VI
VII
VIII
IX
X
...
.
A
format
token
w
generates
numbers
written
as
lowercase
words,
for
example
in
English,
one
two
three
four
...
A
format
token
W
generates
numbers
written
as
uppercase
words,
for
example
in
English,
ONE
TWO
THREE
FOUR
...
A
format
token
Ww
generates
numbers
written
as
titlecase
words,
for
example
in
English,
One
Two
Three
Four
...
Any
other
format
token
indicates
a
numbering
sequence
in
which
that
token
represents
the
number
1
(one)
(but
see
the
note
below).
It
is
·
implementationdefined
·
which
numbering
sequences,
additional
to
those
listed
above,
are
supported.
If
an
implementation
does
not
support
a
numbering
sequence
represented
by
the
given
token,
it
must
use
a
format
token
of
1
.
Note:
In some traditional numbering sequences additional signs are added to denote that the letters should be interpreted as numbers; these are not included in the format token. An example, see also the example below, is classical Greek where a dexia keraia and sometimes an aristeri keraia is added.
For
all
format
tokens
other
than
the
first
kind
above
(one
that
consists
of
decimal
digits),
there
may
be
·
implementationdefined
·
lower
and
upper
bounds
on
the
range
of
numbers
that
can
be
formatted
using
this
format
token;
indeed,
for
some
numbering
sequences
there
may
be
intrinsic
limits.
For
example,
the
format
token
①
(circled
digit
one,
①)
has
a
range
of
1
to
20
imposed
by
the
Unicode
character
repertoire.
For
the
numbering
sequences
described
above
any
upper
bound
imposed
by
the
implementation
must
not
be
less
than
1000
(one
thousand)
and
any
lower
bound
must
not
be
greater
than
1.
Numbers
that
supports
18
fall
outside
this
range
must
be
formatted
using
the
format
token
1
.
The
above
expansions
of
numbering
sequences
for
format
tokens
such
as
a
and
i
are
indicative
but
not
prescriptive.
There
are
various
conventions
in
use
for
how
alphabetic
sequences
continue
when
the
alphabet
is
exhausted,
and
differing
conventions
for
how
roman
numerals
are
written
(for
example,
IV
versus
IIII
as
the
representation
of
the
number
4).
Sometimes
alphabetic
sequences
are
used
that
omit
letters
such
as
i
and
o
.
This
specification
does
not
prescribe
the
detail
of
any
sequence
other
than
those
sequences
consisting
entirely
of
decimal
digits.
Many
numbering
sequences
are
languagesensitive.
This
applies
especially
to
the
sequence
selected
by
the
tokens
w
,
W
and
Ww
.
It
also
applies
to
other
sequences,
for
example
different
languages
using
the
Cyrillic
alphabet
use
different
sequences
of
characters,
each
starting
with
the
letter
#x410
(Cyrillic
capital
letter
A).
In
such
cases,
the
$language
argument
specifies
which
language's
conventions
are
to
be
used;
it
has
the
same
range
of
values
as
xml:lang
(see
[RECxml]
).
If
no
$language
argument
is
specified,
the
language
that
is
used
is
·
implementationdefined
·
.
The
set
of
languages
for
which
numbering
is
supported
is
·
implementationdefined
·
.
If
a
language
is
requested
that
is
not
supported,
the
processor
uses
the
language
that
it
would
use
if
the
$language
argument
were
omitted.
The format modifier, if present, is one of:
o
,
optionally
followed
by
a
sequence
of
characters
enclosed
between
parentheses,
to
indicate
ordinal
numbering
t
to
indicate
traditional
numbering
If
the
o
modifier
is
present,
this
indicates
a
request
to
output
ordinal
numbers
rather
than
cardinal
numbers.
For
example,
in
English,
when
used
with
the
format
token
1
,
this
outputs
the
sequence
1st
2nd
3rd
4th
...
,
and
when
used
with
the
format
token
w
outputs
the
sequence
first
second
third
fourth
...
.
In
some
languages,
ordinal
numbers
vary
depending
on
the
grammatical
context,
for
example
they
may
have
different
genders
and
may
decline
with
the
noun
that
they
qualify.
In
such
cases
the
string
appearing
in
parentheses
after
the
letter
o
may
be
used
to
indicate
the
variation
of
the
ordinal
number
required.
The
way
in
which
the
variation
is
indicated
will
depend
on
the
conventions
of
the
language.
For
inflected
languages
that
vary
the
ending
of
the
word,
the
preferred
approach
is
to
indicate
the
required
ending,
preceded
by
a
hyphen:
for
example
in
German,
appropriate
values
are
o(e)
,
o(er)
,
o(es)
,
o(en)
.
It
is
·
implementationdefined
·
what
combinations
of
values
of
the
format
token,
the
language,
and
the
ordinal
attribute
are
supported.
If
ordinal
numbering
is
not
supported
for
the
combination
of
the
format
token,
the
language,
and
the
string
appearing
in
parentheses,
the
request
is
ignored
and
cardinal
numbers
are
generated
instead.
The
specification
"1o(º)"
with
$language
equal
to
it
,
if
supported,
should
produce
the
sequence:
1º 2º 3º 4º ...
The
specification
"Wwo"
with
$language
equal
to
it
,
if
supported,
should
produce
the
sequence:
Primo Secondo Terzo Quarto Quinto ...
The
t
modifier
disambiguates
between
numbering
sequences
that
use
letters.
In
many
languages
there
are
two
commonly
used
numbering
sequences
that
use
letters.
One
numbering
sequence
assigns
numeric
values
to
letters
in
alphabetic
sequence,
and
the
other
assigns
numeric
values
to
each
letter
in
some
other
manner
traditional
in
that
language.
In
English,
these
would
correspond
to
the
numbering
sequences
specified
by
the
format
tokens
a
and
i
.
In
some
languages,
the
first
member
of
each
sequence
is
the
same,
and
so
the
format
token
alone
would
be
ambiguous.
By
default
the
alphabetic
sequence
is
used;
the
t
modifier
requests
the
other
sequence.
The
expression
formatinteger(123,
'0000')
returns
"0123"
.
formatinteger(123,
'w')
might
return
"one
hundred
and
twentythree"
The
expression
formatinteger(21,
'1o',
'en')
returns
"21st"
.
formatinteger(14,
'Wwo(e)',
'de')
might
return
"Vierzehnte"
The
expression
formatinteger(7,
'a')
returns
"g"
.
The
expression
formatinteger(57,
'I')
returns
"LVII"
.
Editorial note  
This section has been created by the editor in response to a WG decision in principle; the detailed text needs to be reviewed and approved. 
This section defines a function for formatting decimal and floating point numbers.
Function  Meaning 

fn:formatnumber
 Returns a string containing a number formatted according to a given picture string, taking account of decimal formats specified in the static context. 
Note:
This
function
can
be
used
to
format
any
numeric
quantity,
including
an
integer.
For
integers,
however,
the
fn:formatinteger
function
offers
additional
possibilities.
Note
also
that
the
picture
strings
used
by
the
two
functions
are
not
100%
compatible,
though
they
share
some
options
in
common.
Decimal formats are defined in the static context, and the way they are defined is therefore outside the scope of this specification. XSLT and XQuery both provide custom syntax for creating a decimal format.
The static context provides a set of decimal formats. One of the decimal formats is unnamed, the others (if any) are identified by a QName. There is always an unnamed decimal format available, but its contents are implementationdefined.
Each decimal format provides a set of named variables, described in the following table:
Name  Type  Usage (nonnormative) 

decimalseparatorsign  A single character  Defines the character used to represent the decimal point (typically ".") both in the picture string and in the formatted number 
groupingseparatorsign  A single character  Defines the character used to separate groups of digits (typically ",") both in the picture string and in the formatted number 
infinity  A string  Defines the string used to represent the value positive or negative infinity in the formatted number (typically "Infinity") 
valign="top"minussign  A single character  Defines the character used as a minus sign in the formatted number if there is no subpicture for formatting negative numbers (typically "", x2D) 
NaN  valign="top"A string 
Defines
the
string
used
to
represent
the
value
NaN
in
the
formatted
number

percentsign  A single character  Defines the character used as a percent sign (typically "%") both in the picture string and in the formatted number 
permillesign  Defines the character used as a permille sign (typically "‰", x2030) both in the picture string and in the formatted number  
mandatorydigitsign  A single character, which must be defined in Unicode as a digit with the value zero  Defines the character (typically "0") used in the picture string to represent a mandatory digit, and in the formatted number to represent the digit zero; by implication, this also defines the characters used to represent the digits one to nine. 
optionaldigitsign  A single character  Defines the character used in the picture string to represent an optional digit (typically "#") 
patternseparatorsign  valign="top"A single character  Defines the character used in the picture string to separate the positive and negative subpictures (typically ";") 
[Definition] The decimal digit family of a decimal format is the sequence of ten digits with consecutive Unicode codepoints starting with the mandatorydigitsign .
It is a constraint that, for any named or unnamed decimal format, the variables representing characters used in a · picture string · must have distinct values. These variables are decimalseparatorsign , groupingseparatorsign , percentsign , permillesign , optionaldigitsign , and patternseparatorsign . Furthermore, none of these variables may be equal to any character in the · decimal digit family · .
Returns a string containing a number formatted according to a given picture string, taking account of decimal formats specified in the static context.
fn:formatnumber
(
$value
as
numeric?
,
$picture
as
xs:string
)
as
xs:string
fn:formatnumber
(

$value

as
numeric?
, 
$picture

as
xs:string
,  
$decimalformatname

as
xs:string
)
as
xs:string

The
function
formats
$value
as
a
string
using
the
·
picture
string
·
specified
by
the
$picture
argument
and
the
decimalformat
named
by
the
$decimalformatname
argument,
or
the
default
decimalformat,
if
there
is
no
$decimalformatname
argument.
The
syntax
of
the
picture
string
is
described
in
4.6.3
Syntax
of
the
Picture
String
.
The
$value
argument
may
be
of
any
numeric
data
type
(
xs:double
,
xs:float
,
xs:decimal
,
or
their
subtypes
including
xs:integer
).
Note
that
if
an
xs:decimal
will
convert
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
$decimalformatname
must
be
a
lexical
QName,
which
is
expanded
using
the
inscope
namespaces
from
the
static
context.
The
default
namespace
is
not
used
(no
prefix
means
no
namespace).
The
evaluation
of
the
formatnumber
function
takes
place
in
two
phases,
an
analysis
phase
described
in
4.6.4
Analysing
the
Picture
String
and
a
formatting
phase
described
in
4.6.5
Formatting
the
Number
.
The analysis phase takes as its inputs the · picture string · and the variables derived from the relevant decimal format in the static context, and produces as its output a number of variables with defined values. The formatting phase takes as its inputs the number to be formatted and the variables produced by the analysis phase, and produces as its output a string containing a formatted representation of the number.
The result of the function is the formatted string representation of the supplied number.
An
error
is
raised
[
err:FODF1280
]
if
the
name
specified
as
the
$decimalformatname
argument
is
not
a
valid
lexical
QName,
or
if
its
prefix
has
not
been
declared
in
an
inscope
namespace
declaration,
or
if
the
static
context
does
not
contain
a
declaration
of
a
decimalformat
with
a
matching
expanded
QName.
If
the
processor
is
able
to
detect
the
error
statically
(for
example,
when
the
argument
is
supplied
as
a
string
literal),
then
the
processor
may
optionally
signal
this
as
a
static
error.
Numbers will always be formatted with the most significant digit on the left.
Note:
This
differs
from
the
xs:decimal
formatnumber
150.014999389...
function
previously
defined
in
XSLT
2.0
in
that
any
digit
can
be
used
in
the
picture
string
to
represent
a
mandatory
digit:
for
example
the
picture
strings
'000',
'001',
and
'999'
are
equivalent.
This
is
to
align
formatnumber
(which
previously
used
'000')
with
formatdateTime
(which
used
'001').
[Definition] The formatting of a number is controlled by a picture string . The picture string is a sequence of characters, in which the characters assigned to the variables decimalseparatorsign , groupingsign , decimaldigitfamily , optionaldigitsign and patternseparatorsign are classified as active characters, and all other characters (including the percentsign and permillesign ) are classified as passive characters.
The integer part of the subpicture is defined as the part that appears to the left of the decimalseparatorsign if there is one, or the entire subpicture otherwise. The fractional part of the subpicture is defined as the part that appears to the right of the decimalseparatorsign if there is one; it is a zerolength string otherwise.
An error is raised [ err:FODF1310 ] if the · picture string · does not conform to the following rules. Note that in these rules the words "preceded" and "followed" refer to characters anywhere in the string, they are not to be read as "immediately preceded" and "immediately followed".
A picturestring consists either of a subpicture, or of two subpictures separated by a patternseparatorsign . A picturestring must not contain more than one patternseparatorsign . If the picturestring contains two subpictures, the first is used for positive values and the second for negative values.
A subpicture must not contain more than one decimalseparatorsign .
A subpicture must not contain more than one percentsign or permillesign , and it must not contain one of each.
A subpicture must contain at least one character that is an optionaldigitsign or a member of the decimaldigitfamily .
A subpicture must not contain a passive character that is preceded by an active character and that is followed by another active character.
A subpicture must not contain a groupingseparatorsign adjacent to a decimalseparatorsign .
The integer part of a subpicture must not contain a member of the decimaldigitfamily that is followed by an optionaldigitsign . The fractional part of a subpicture must not contain an optionaldigitsign that is followed by a member of the decimaldigitfamily .
This phase of the algorithm analyses the · picture string · and the variables from the selected decimal format in the static context, and it has the effect of setting the values of various variables, which are used in the subsequent formatting phase. These variables are listed below. Each is shown with its initial setting and its data type.
Several variables are associated with each subpicture. If there are two subpictures, then these rules are applied to one subpicture to obtain the values that apply to positive numbers, and to the other to obtain the values that apply to negative numbers. If there is only one subpicture, then the values for both cases are derived from this subpicture.
The variables are as follows:
The integerpartgroupingpositions is a sequence of integers representing the positions of grouping separators within the integer part of the subpicture. For each groupingseparatorsign that appears within the integer part of the subpicture, this sequence contains an integer that is equal to the total number of optionaldigitsign and decimaldigitfamily characters that appear within the integer part of the subpicture and to the right of the groupingseparatorsign . In addition, if these integerpartgroupingpositions are at regular intervals (that is, if they form a sequence N , 2N , 3N , ... for some integer value N , including the case where there is only one number in the list), then the sequence contains all integer multiples of N as far as necessary to accommodate the largest possible number.
The minimumintegerpartsize is an integer indicating the minimum number of digits that will appear to the left of the decimalseparatorsign . It is normally set to the number of decimaldigitfamily characters found in the integer part of the subpicture. But if the subpicture contains no decimaldigitfamily character and no decimalseparatorsign , it is set to one.
Note:
There is no maximum integer part size. All significant digits in the integer part of the number will be displayed, even if this exceeds the number of optionaldigitsign and decimaldigitfamily characters in the subpicture.
The prefix is set to contain all passive characters in the subpicture to the left of the leftmost active character. If the picture string contains only one subpicture, the prefix for the negative subpicture is set by concatenating the minussign character and the prefix for the positive subpicture (if any), in that order.
The fractionalpartgroupingpositions is a sequence of integers representing the positions of grouping separators within the fractional part of the subpicture. For each groupingseparatorsign that appears within the fractional part of the subpicture, this sequence contains an integer that is equal to the total number of optionaldigitsign and decimaldigitfamily characters that appear within the fractional part of the subpicture and to the left of the groupingseparatorsign .
The minimumfractionalpartsize is set to the number of decimaldigitfamily characters found in the fractional part of the subpicture.
The maximumfractionalpartsize is set to the total number of optionaldigitsign and decimaldigitfamily characters found in the fractional part of the subpicture.
The suffix is set to contain all passive characters to the right of the rightmost active character in the fractional part of the subpicture.
Note:
If
there
is
only
one
subpicture,
then
all
variables
for
positive
numbers
and
negative
numbers
will
be
rounded
the
same,
except
for
prefix
:
the
prefix
for
negative
numbers
will
be
preceded
by
the
minussign
character.
This
section
describes
the
second
phase
of
processing
of
the
formatnumber
function.
This
phase
takes
as
input
a
number
to
be
formatted
(referred
to
as
the
input
number
),
and
the
variables
set
up
by
analysing
the
decimal
format
in
the
static
context
and
the
·
picture
string
·
,
as
described
above.
The
result
of
this
phase
is
a
string,
which
forms
the
return
value
of
the
formatnumber
function.
The algorithm for this second stage of processing is as follows:
If the input number is NaN (not a number), the result is the specified NaNsymbol (with no prefix or suffix ).
In the rules below, the positive subpicture and its associated variables are used if the input number is positive, and the negative subpicture and its associated variables are used otherwise. Negative zero is taken as negative, positive zero as positive.
If the input number is positive or negative infinity, the result is the concatenation of the appropriate prefix , the infinitysymbol , and the appropriate suffix .
If the subpicture contains a percentsign , the number is multiplied by 100. If the subpicture contains a permillesign , the number is multiplied by 1000. The resulting number is referred to below as the adjusted number .
The
adjusted
number
is
converted
(if
necessary)
to
an
xs:decimal
150.01
which
value,
using
an
implementation
of
xs:decimal
that
imposes
no
limits
on
the
totalDigits
or
fractionDigits
facets.
If
there
are
several
such
values
that
are
numerically
equal
to
the
adjusted
number
(bearing
in
mind
that
if
the
adjusted
number
is
an
xs:double
or
xs:float
,
the
comparison
will
be
converted
done
by
converting
the
decimal
value
back
to
the
an
xs:double
or
xs:float
whose
exact
),
the
one
that
is
chosen
should
be
one
with
the
smallest
possible
number
of
digits
not
counting
leading
or
trailing
zeroes
(whether
significant
or
insignificant).
For
example,
1.0
is
preferred
to
0.9999999999,
and
100000000
is
preferred
to
100000001.
This
value
is
150.0099945068...
whereas
then
rounded
so
that
it
uses
no
more
than
digits
in
its
fractional
part.
The
rounded
number
is
defined
to
be
the
result
of
converting
the
adjusted
number
to
an
roundhalftoeven(xs:decimal(150.0150),
2)
maximumfractionalpartsize
xs:decimal
value,
as
described
above,
and
then
calling
the
function
fn:roundhalftoeven
with
this
converted
number
as
the
first
argument
and
the
maximumfractionalpartsize
as
the
second
argument,
again
with
no
limits
on
the
totalDigits
or
fractionDigits
in
the
result.
The absolute value of the rounded number is converted to a string in decimal notation, with no insignificant leading or trailing zeroes, using the digits in the decimaldigitfamily to represent the ten decimal digits, and the decimalseparatorsign to separate the integer part and the fractional part. (The value zero will at this stage be represented by a decimalseparatorsign on its own.)
If the number of digits to the left of the decimalseparatorsign is less than minimumintegerpartsize , leading zerodigitsign characters are added to pad out to that size.
If the number of digits to the right of the decimalseparatorsign is less than minimumfractionalpartsize , trailing zerodigitsign characters are added to pad out to that size.
For each integer N in the integerpartgroupingpositions list, a groupingseparatorsign character is inserted into the string immediately after that digit that appears in the integer part of the number and has N digits between it and the decimalseparatorsign , if there is such a digit.
For each integer N in the fractionalpartgroupingpositions list, a groupingseparatorsign character is inserted into the string immediately before that digit that appears in the fractional part of the number and has N digits between it and the decimalseparatorsign , if there is such a digit.
If there is no decimalseparatorsign in the subpicture, or if there are no digits to the right of the decimalseparatorsign character in the string, then the decimalseparatorsign character is removed from the string (it will be the rightmost character in the string).
The result of the function is the concatenation of the appropriate prefix , the string conversion of the number as obtained above, and the appropriate suffix .
The
functions
in
this
section
perform
trigonometrical
calculations
on
xs:double
values.
They
are
designed
for
use
in
applications
performing
geometrical
computation,
for
example
when
generating
SVG
graphics.
Functions are provided to support the six most commonly used trigonometric calculations: sine, cosine and tangent, and their inverses arc sine, arc cosine, and arc tangent. Other functions such as secant, cosecant, and cotangent are not provided because they are easily computed in terms of these six.
Function  Meaning 

math:pi
 Returns the value of the mathematical constant π . 
math:sqrt
 Returns the square root of the argument. 
math:sin
 Returns the sine of the argument, expressed in radians. 
math:cos
 Returns the cosine of the argument, expressed in radians. 
math:tan
 Returns the tangent of the argument, expressed in radians. 
math:asin
 Returns the arc sine of the argument, the result being in the range  π /2 to + π /2 radians. 

Returns the arc cosine of the argument, the result being in the range zero to + π radians. 
math:atan
 Returns the arc tangent of the argument, the result being in the range  π /2 to + π /2 radians. 
[Definition]
In
this
section,
when
the
rules
for
a
function
say
that
the
returned
value
must
be
the
xs:double
either
side
of
some
mathematical
quantity,
then
if
the
mathematical
quantity
is
precisely
representable
in
the
value
space
of
xs:double
the
exact
result
must
be
returned;
otherwise
it
is
acceptable
to
return
either
the
nearest
higher
xs:double
or
the
nearest
lower
xs:double
,
and
it
is
·
implementationdependent
·
which
of
the
two
is
returned.
Returns the value of the mathematical constant π .
math:pi
()
as
xs:double
This
function
returns
the
xs:double
value
whose
lexical
representation
is
150.02.
3.141592653589793e0
The
expression
2*math:pi()
returns
6.283185307179586e0
.
The
expression
60
*
(math:pi()
div
180)
converts
an
angle
of
60
degrees
to
radians.
Returns the square root of the argument.
math:sqrt
(
$arg
as
xs:double?
)
as
xs:double?
If
is
the
empty
sequence,
the
function
returns
the
empty
sequence.
fn:roundhalftoeven(0.5)
$arg
If
is
less
than
zero,
the
result
is
0
$arg
NaN
.
If
$arg
is
positive
or
negative
zero,
positive
infinity,
or
NaN
,
then
the
result
is
$arg
.
Otherwise
the
result
is
the
xs:double
value
·
either
side
of
·
the
mathematical
square
root
of
.fn:roundhalftoeven(1.5)
$arg
Returns the sine of the argument, expressed in radians.
math:sin
(
$
θ
as
xs:double?
)
as
xs:double?
If
$
θ
is
the
empty
sequence,
the
function
returns
the
empty
sequence.
If
θ
is
positive
or
negative
zero,
the
result
is
2
$
$
θ
.
If
$
θ
is
positive
or
negative
infinity,
or
NaN
,
then
the
result
is
NaN
.
Otherwise
the
result
is
the
sine
of
$
θ
,
treated
as
an
angle
in
radians.
If
θ
is
in
the
range
2
π
to
+2
π
then
the
result
is
the
fn:roundhalftoeven(2.5)
$
xs:double
value
·
either
side
of
·
the
mathematical
sine
of
the
angle;
if
it
is
outside
this
range,
then
the
precision
of
the
result
is
·
implementationdependent
·
.
Returns the cosine of the argument, expressed in radians.
math:cos
(
$
θ
as
xs:double?
)
as
xs:double?
If
$
θ
is
the
empty
sequence,
the
function
returns
the
empty
sequence.
If
θ
is
positive
or
negative
infinity,
or
2
$
NaN
,
then
the
result
is
NaN
.
Otherwise
the
result
is
the
cosine
of
$
θ
,
treated
as
an
angle
in
radians.
If
θ
is
in
the
range
2
π
to
+2
π
then
the
result
is
the
fn:roundhalftoeven(3.567812E+3,
2)
$
xs:double
value
·
either
side
of
·
the
mathematical
cosine
of
the
angle;
if
it
is
outside
this
range,
then
the
precision
of
the
result
is
·
implementationdependent
·
.
Returns the tangent of the argument, expressed in radians.
math:tan
(
$
θ
as
xs:double?
)
as
xs:double?
If
$
θ
is
the
empty
sequence,
the
function
returns
the
empty
sequence.
If
θ
is
positive
or
negative
infinity,
or
3567.81E0
$
NaN
,
then
the
result
is
NaN
.
Otherwise
the
result
is
the
tangent
of
$
θ
,
treated
as
an
angle
in
radians.
If
θ
is
in
the
range
2
π
to
+2
π
then
the
result
is
the
fn:roundhalftoeven(4.7564E3,
2)
$
xs:double
value
·
either
side
of
·
the
mathematical
tangent
of
the
angle;
if
it
is
outside
this
range,
then
the
precision
of
the
result
is
·
implementationdependent
·
.
Returns the arc sine of the argument, the result being in the range  π /2 to + π /2 radians.
math:asin
(
$arg
as
xs:double?
)
as
xs:double?
If
$arg
is
the
empty
sequence,
the
function
returns
the
empty
sequence.
If
is
positive
or
negative
zero,
the
result
is
0.0E0
$arg
$arg
.
If
$arg
is
NaN
,
or
if
its
absolute
value
is
greater
than
one,
then
the
result
is
NaN
.
Otherwise
the
result
is
the
arc
sine
of
$arg
,
returned
as
an
angle
in
radians
in
the
range

π
/2
to
+
π
/2.
The
result
is
the
xs:double
value
·
either
side
of
·
the
mathematical
arc
sine
of
the
argument.
Returns the arc cosine of the argument, the result being in the range zero to + π radians.
math:acos
(
$arg
as
xs:double?
)
as
xs:double?
If
is
the
empty
sequence,
the
function
returns
the
empty
sequence.
fn:roundhalftoeven(35612.25,
2)
$arg
If
is
35600
$arg
NaN
,
or
if
its
absolute
value
is
greater
than
one,
then
the
result
is
NaN
.
Otherwise
the
result
is
the
arc
cosine
of
$arg
,
returned
as
an
angle
in
radians
in
the
range
0
to
+
π
.
The
result
is
the
xs:double
value
·
either
side
of
·
the
mathematical
arc
cosine
of
the
argument.
Returns the arc tangent of the argument, the result being in the range  π /2 to + π /2 radians.
math:atan
(
$arg
as
xs:double?
)
as
xs:double?
If
$arg
is
the
empty
sequence,
the
function
returns
the
empty
sequence.
If
$arg
is
positive
or
negative
zero,
the
result
is
$arg
.
If
$arg
is
NaN
then
the
result
is
NaN
.
Otherwise
the
result
is
the
arc
tangent
of
$arg
,
returned
as
an
angle
in
radians
in
the
range

π
/2
to
+
π
/2.
The
result
is
the
xs:double
value
·
either
side
of
·
the
mathematical
arc
tangent
of
the
argument.
Editorial note  
Need to add rules for the infinities? 
This
section
discusses
specifies
functions
and
operators
on
the
[XML
Schema
Part
2:
Datatypes
Second
Edition]
xs:string
datatype
and
the
datatypes
derived
from
it.
The operators described in this section are defined on the following types. Each type whose name is indented is derived from the type whose name appears nearest above with one less level of indentation.
xs:string  
xs:normalizedString  
xs:token  
xs:language  
xs:NMTOKEN  
xs:Name  
xs:NCName  
xs:ID  
xs:IDREF  
xs:ENTITY 
They also apply to userdefined types derived by restriction from the above types.
It is · implementationdefined · which version of [The Unicode Standard] is supported, but it is recommended that the most recent version of Unicode be used.
Unless
explicitly
stated,
the
xs:string
values
returned
by
the
functions
in
this
document
are
not
normalized
in
the
sense
of
[Character
Model
for
the
World
Wide
Web
1.0:
Fundamentals]
.
Notes:
This
document
uses
the
term
"code
point",
sometimes
spelt
"codepoint"
(also
known
as
"character
number"
or
"code
position")
to
mean
a
the
nonnegative
integer
that
represents
assigned
to
a
character
by
the
Unicode
consortium.
Equivalent
terms
found
in
some
encoding.
other
specifications
are
"code
point",
"character
number",
or
"code
position".
See
[Character
Model
for
the
World
Wide
Web
1.0:
Fundamentals]
.
The
use
of
the
word
"character"
in
this
document
is
in
the
sense
of
production
[2]
of
[Extensible
Markup
Language
(XML)
1.0
Recommendation
(Third
Edition)]
[RECxml]
.
[The
Unicode
Standard]
,
defines
code
points
codepoints
that
range
from
#x0000
to
#x10FFFF
inclusive
and
may
include
code
points
codepoints
that
have
not
yet
been
assigned
to
characters.
In
functions
that
involve
character
counting
such
as
fn:substring
,
fn:stringlength
and
fn:translate
,
what
is
counted
is
the
number
of
XML
characters
in
the
string
(or
equivalently,
the
number
of
Unicode
code
points).
codepoints).
Some
implementations
may
represent
a
code
point
codepoint
above
xFFFF
using
two
16bit
values
known
as
a
surrogate.
surrogate
pair.
A
surrogate
pair
counts
as
one
character,
not
two.
Function  Meaning 

fn:codepointstostring

Creates
an
xs:string
from
a
sequence
of
[The
Unicode

fn:stringtocodepoints

Returns
the
sequence
of
[The
Unicode
xs:string
value.

Creates
an
xs:string
from
a
sequence
of
[The
Unicode
Standard]
codepoints.
fn:codepointstostring
(
$arg
as
xs:integer*
)
as
xs:string
Summary:
Creates
an
xs:string
The
function
returns
the
string
made
up
from
a
sequence
of
[The
the
characters
whose
Unicode
Standard]
code
points.
Returns
codepoints
are
supplied
in
$arg
.
This
will
be
the
zerolength
string
if
$arg
is
the
empty
sequence.
If
any
of
the
code
points
codepoints
in
$arg
is
not
a
legal
XML
character,
an
error
is
raised
[
err:FOCH0001
].
The
expression
fn:codepointstostring((2309,
2358,
2378,
2325))
returns
"अशॊक"
.
Returns
the
sequence
of
[The
Unicode
Standard]
codepoints
that
constitute
an
xs:string
value.
fn:stringtocodepoints
(
$arg
as
xs:string?
)
as
xs:integer*
Summary:
Returns
the
The
function
returns
a
sequence
of
[The
integers,
each
integer
being
the
Unicode
Standard]
code
points
that
constitute
an
codepoint
of
the
corresponding
character
in
.
xs:string
$arg
If
$arg
is
a
zerolength
string
or
the
empty
sequence,
the
function
returns
the
empty
sequence
is
returned.
sequence.
The
expression
fn:stringtocodepoints("Thérèse")
returns
the
sequence
(84,
104,
233,
114,
232,
115,
101)
.
Function  Meaning 

fn:compare

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

fn:codepointequal
 Returns true if two strings are equal, considered codepointbycodepoint. 
A
collation
is
a
specification
of
the
manner
in
which
character
strings
are
compared
and,
by
extension,
ordered.
When
values
whose
type
is
xs:string
or
a
type
derived
from
xs:string
are
compared
(or,
equivalently,
sorted),
the
comparisons
are
inherently
performed
according
to
some
collation
(even
if
that
collation
is
defined
entirely
on
code
point
codepoint
values).
The
[Character
Model
for
the
World
Wide
Web
1.0:
Fundamentals]
observes
that
some
applications
may
require
different
comparison
and
ordering
behaviors
than
other
applications.
Similarly,
some
users
having
particular
linguistic
expectations
may
require
different
behaviors
than
other
users.
Consequently,
the
collation
must
be
taken
into
account
when
comparing
strings
in
any
context.
Several
functions
in
this
and
the
following
section
make
use
of
a
collation.
Collations
can
indicate
that
two
different
code
points
codepoints
are,
in
fact,
equal
for
comparison
purposes
(e.g.,
"v"
and
"w"
are
considered
equivalent
in
Swedish).
some
Swedish
collations).
Strings
can
be
compared
codepointbycodepoint
or
in
a
linguistically
appropriate
manner,
as
defined
by
the
collation.
Some
collations,
especially
those
based
on
the
[Unicode
Collation
Algorithm]
can
be
"tailored"
for
various
purposes.
This
document
does
not
discuss
such
tailoring,
nor
does
it
provide
a
mechanism
to
perform
tailoring.
Instead,
it
assumes
that
the
collation
argument
to
the
various
functions
below
is
a
tailored
and
named
collation.
A
specific
The
·
Unicode
codepoint
collation
with
·
is
a
distinguished
name,
http://www.w3.org/2005/xpathfunctions/collation/codepoint
,
provides
the
ability
to
compare
strings
based
on
code
point
values.
Every
implementation
of
XQuery/XPath
must
support
the
collation
available
in
every
implementation,
which
sorts
based
on
code
point
codepoint
values.
For
further
details
see
5.3.2
The
Unicode
Codepoint
Collation
In the ideal case, a collation should treat two strings as equal if the two strings are identical after Unicode normalization. Thus, the [Character Model for the World Wide Web 1.0: Normalization] recommends that all strings be subjected to early Unicode normalization and some collations will raise runtime errors if they encounter strings that are not properly normalized. However, it is not possible to guarantee that all strings in all XML documents are, in fact, normalized, or that they are normalized in the same manner. In order to maximize interoperability of operations on XML documents in general, there may be collations that operate on unnormalized strings and other collations that implicitly normalize strings before comparing them. Applications may choose the kind of collation best suited for their needs. Note that collations based on the Unicode collation algorithm implicitly normalize strings before comparison and produce equivalent results regardless of a string's normalization.
This
specification
assumes
that
collations
are
named
and
that
the
collation
name
may
be
provided
as
an
argument
to
string
functions.
Functions
that
allow
specification
of
a
collation
do
so
with
an
argument
whose
type
is
xs:string
but
whose
lexical
form
must
conform
to
an
xs:anyURI
.
If
the
collation
is
specified
using
a
relative
URI,
it
is
assumed
to
be
relative
to
the
value
of
the
baseuri
property
in
the
static
context.
This
specification
also
defines
the
manner
in
which
a
default
collation
is
determined
if
the
collation
argument
is
not
specified
in
invocations
calls
of
functions
that
use
a
collation
but
allow
it
to
be
omitted.
This specification does not define whether or not the collation URI is dereferenced. The collation URI may be an abstract identifier, or it may refer to an actual resource describing the collation. If it refers to a resource, this specification does not define the nature of that resource. One possible candidate is that the resource is a locale description expressed using the Locale Data Markup Language: see [Locale Data Markup Language] .
Functions
such
as
fn:compare
and
fn:max
that
compare
xs:string
values
use
a
single
collation
URI
to
identify
all
aspects
of
the
collation
rules.
This
means
that
any
parameters
such
as
the
strength
of
the
collation
must
be
specified
as
part
of
the
collation
URI.
For
example,
suppose
there
is
a
collation
"
http://www.example.com/collations/French
"
that
refers
to
a
French
collation
that
compares
on
the
basis
of
base
characters.
Collations
that
use
the
same
basic
rules,
but
with
higher
strengths,
for
example,
base
characters
and
accents,
or
base
characters,
accents
and
case,
would
need
to
be
given
different
names,
say
"
http://www.example.com/collations/French1
"
and
"
http://www.example.com/collations/French2
".
Note
that
some
specifications
use
the
term
collation
to
refer
to
an
algorithm
that
can
be
parameterized,
but
in
this
specification,
each
possible
parameterization
is
considered
to
be
a
distinct
collation.
The
XQuery/XPath
static
context
includes
a
provision
for
a
default
collation
that
can
be
used
for
string
comparisons
and
ordering
operations.
See
the
description
of
the
static
context
in
Section
2.1.1
Static
Context
^{
XP
}.
If
the
default
collation
is
not
specified
by
the
user
or
the
system,
the
default
collation
is
the
·
Unicode
code
point
codepoint
collation
(
·
.
Note:
XML
allows
elements
to
specify
the
xml:lang
attribute
to
indicate
the
language
associated
with
the
content
of
such
an
element.
This
specification
does
not
use
xml:lang
to
identify
the
default
collation
because
using
xml:lang
does
not
produce
desired
effects
when
the
two
strings
to
be
compared
have
different
xml:lang
values
or
when
a
string
is
multilingual.
[Definition]
The
collation
URI
http://www.w3.org/2005/xpathfunctions/collation/codepoint
).
identifies
a
collation
which
must
be
recognized
by
every
implementation:
it
is
referred
to
as
the
Unicode
codepoint
collation
(not
to
be
confused
with
the
Unicode
collation
algorithm).
The
decision
Unicode
codepoint
collation
does
not
perform
any
normalization
on
the
supplied
strings.
The
collation
is
defined
as
follows.
Each
of
which
the
two
strings
is
converted
to
a
sequence
of
integers
using
the
fn:stringtocodepoints
function.
These
two
sequences
$A
and
$B
are
then
compared
as
follows:
If both sequences are empty, the strings are equal
If one sequence is empty and the other is not, then the string corresponding to the empty sequence is less than the other string.
If
the
first
integer
in
$A
is
less
than
the
first
integer
in
$B
,
then
the
string
corresponding
to
$A
is
less
than
the
string
corresponding
to
$B
.
If
the
first
integer
in
$A
is
greater
than
the
first
integer
in
$B
,
then
the
string
corresponding
to
$A
is
greater
than
the
string
corresponding
to
$B
.
Otherwise
(the
first
pair
of
integers
are
equal),
the
result
is
obtained
by
applying
the
same
rules
recursively
to
fn:subsequence($A,
2)
and
fn:subsequence($B,
2)
Note:
While the Unicode codepoint collation does not produce results suitable for quality publishing of printed indexes or directories, it is adequate for many purposes where a restricted alphabet is used, such as sorting of vehicle registrations.
Many
functions
have
two
signatures,
where
one
signature
includes
a
$collation
argument
and
the
other
omits
this
argument.
The
collation
to
use
for
a
given
comparison
or
ordering
function
these
functions
is
determined
by
the
following
algorithm:
rules:
If
the
function
specifies
an
explicit
collation,
CollationA
(e.g.,
if
the
optional
collation
argument
is
specified
in
an
invocation
a
call
of
the
function),
then:
fn:compare()
fn:compare
If CollationA is supported by the implementation, then CollationA is used.
Otherwise, an error is raised [ err:FOCH0002 ].
If no collation is explicitly specified for the function and the default collation in the XQuery/XPath static context is CollationB, then:
If CollationB is supported by the implementation, then CollationB is used.
Otherwise, an error is raised [ err:FOCH0002 ].
Note:
XML
allows
elements
to
specify
the
xml:lang
attribute
to
indicate
the
language
associated
with
Because
the
content
set
of
such
collations
that
are
supported
is
·
implementationdefined
·
,
an
element.
This
specification
does
not
use
xml:lang
to
identify
the
default
collation
because
using
xml:lang
does
not
produce
desired
effects
when
implementation
has
the
two
strings
option
to
be
compared
have
different
xml:lang
values
or
when
a
string
is
multilingual.
support
all
collation
URIs,
in
which
case
it
will
never
raise
this
error.
Returns
1,
0,
or
1,
depending
on
whether
the
value
of
the
first
argument
is
respectively
less
than,
$comparand1
collates
before,
equal
to,
or
greater
than
the
value
of
the
second
argument,
after
$comparand2
according
to
the
rules
of
the
collation
that
is
used.
fn:codepointequal
Returns
true
if
the
two
arguments
are
equal
using
the
Unicode
code
point
a
selected
collation.
7.3.2
fn:compare
fn:compare
(
$comparand1
as
xs:string?
,
$comparand2
as
xs:string?
)
as
xs:integer?
fn:compare
(

$comparand1

as
xs:string?
,

$comparand2

as
xs:string?
,


$collation

as
xs:string
)
as
xs:integer?

Summary:
Returns
1,
0,
or
1,
depending
on
whether
the
value
of
the
$comparand1
is
respectively
less
than,
equal
to,
or
greater
than
the
value
of
$comparand2
,
according
to
the
rules
of
the
collation
that
is
used.
The
collation
used
by
the
invocation
of
this
function
is
determined
according
to
the
rules
in
7.3.1
Collations
5.3.3
Choosing
a
Collation
.
If
either
argument
$comparand1
or
$comparand2
is
the
empty
sequence,
the
result
is
function
returns
the
empty
sequence.
This
function,
invoked
called
with
the
first
signature,
backs
up
defines
the
semantics
of
the
"eq",
"ne",
"gt",
"lt",
"le"
and
"ge"
operators
on
string
xs:string
values.
The
expression
fn:compare('abc',
'abc')
returns
0.
0
.
The
expression
fn:compare('Strasse',
'Straße')
returns
0
.
(Assuming
the
default
collation
includes
provisions
that
equate
"ss"
and
the
(German)
character
"ß"
("sharps").
if
and
only
if
(Otherwise,
Otherwise,
the
returned
value
depends
on
the
semantics
of
the
default
collation.)
collation.).
The
expression
fn:compare('Strasse',
'Straße',
returns
'deutsch')
'http://example.com/deutsch')
0
.
(Assuming
the
collation
identified
by
the
if
relative
URI
constructed
from
the
string
http://example.com/deutsch
value
"deutsch"
includes
provisions
that
equate
"ss"
and
the
(German)
character
"ß"
("sharps").
(Otherwise,
Otherwise,
the
returned
value
depends
on
the
semantics
of
that
collation.)
collation.).
The
expression
fn:compare('Strassen',
'Straße')
returns
1
.
(Assuming
the
default
collation
includes
provisions
that
treat
differences
between
"ss"
and
the
(German)
character
"ß"
("sharps")
with
less
strength
than
the
differences
between
the
base
characters,
such
as
the
final
"n".
).
if
Returns true if two strings are equal, considered codepointbycodepoint.
fn:codepointequal
(

$comparand1

as
xs:string?
,

$comparand2

as
xs:string?
)
as
xs:boolean?

Summary:
Returns
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
code
point
codepoint
collation
(
http://www.w3.org/2005/xpathfunctions/collation/codepoint
).
This
function
allows
xs:anyURI
values
to
be
compared
without
having
to
specify
the
Unicode
code
point
codepoint
collation.
The
following
functions
are
defined
on
values
of
type
xs:string
and
types
derived
from
it.
Function  Meaning 

fn:concat


fn:stringjoin

Returns

fn:substring

Returns
the
portion
of
the
value
of
$length
.


Returns
the


Returns
the


Returns
the






Returns
the
value
of

Notes:
When
the
above
operators
and
functions
are
applied
to
datatypes
derived
from
xs:string
,
they
are
guaranteed
to
return
legal
xs:string
s,
but
they
might
not
return
a
legal
value
for
the
particular
subtype
to
which
they
were
applied.
The
strings
returned
by
fn:concat
and
fn:stringjoin
are
not
guaranteed
to
be
normalized.
But
see
note
in
fn:concat
.
Returns the concatenation of the string values of the arguments.
fn:concat
(

$arg1

as
xs:anyAtomicType?
,

$arg2

as
xs:anyAtomicType?
,


... 
)
as
xs:string

Summary:
Accepts
This
function
accepts
two
or
more
xs:anyAtomicType
arguments
and
casts
them
each
one
to
xs:string
.
Returns
The
function
returns
the
xs:string
that
is
the
concatenation
of
the
values
of
its
arguments
after
conversion.
If
any
of
the
arguments
argument
is
the
empty
sequence,
the
that
argument
is
treated
as
the
zerolength
string.
The
fn:concat
function
is
specified
to
allow
an
two
or
more
arguments
that
arguments,
which
are
concatenated
together.
This
is
the
only
function
specified
in
this
document
that
allows
a
variable
number
of
arguments.
This
capability
is
retained
for
compatibility
with
[XML
Path
Language
(XPath)
Version
1.0]
.
As
mentioned
in
7.1
5.1
String
Types
Unicode
normalization
is
not
automatically
applied
to
the
result
of
fn:concat
.
If
a
normalized
result
is
required,
fn:normalizeunicode
can
be
applied
to
the
xs:string
returned
by
fn:concat
.
The
following
XQuery:
let $v1 := "I plan to go to Mu" let $v2 := "?nchen in September" return concat($v1, $v2)
where the "?" represents either the actual Unicode character COMBINING DIARESIS (Unicode codepoint U+0308) or "̈", will return:
"I plan to go to Mu?nchen in September"
where the "?" represents either the actual Unicode character COMBINING DIARESIS (Unicode codepoint U+0308) or "̈". It is worth noting that the returned value is not normalized in NFC; however, it is normalized in NFD. .
However, the following XQuery:
let $v1 := "I plan to go to Mu" let $v2 := "?nchen in September" return normalizeunicode(concat($v1, $v2))
where the "?" represents either the actual Unicode character COMBINING DIARESIS (Unicode codepoint U+0308) or "̈", will return:
"I plan to go to München in September"
This returned result is normalized in NFC.
The
expression
fn:concat('un',
'grateful')
returns
"
.
ungrateful
".
"ungrateful"
The
expression
fn:concat('Thy
',
(),
'old
',
"groans",
"",
'
ring',
'
yet',
'
in',
'
my',
'
ancient','
ears.')
returns
"
.
Thy
"Thy
old
groans
ring
yet
in
my
ancient
ears.
".
ears."
The
expression
fn:concat('Ciao!',())
returns
"
.
Ciao!
".
"Ciao!"
The
expression
fn:concat('Ingratitude,
',
'thou
',
'marblehearted',
'
fiend!')
returns
"
.
Ingratitude,
"Ingratitude,
thou
marblehearted
fiend!
".
fiend!"
Returns a string created by concatenating the items in a sequence, with a defined separator between adjacent items.
fn:stringjoin
(
$arg1
as
xs:string*
)
as
xs:string
fn:stringjoin
(
$arg1
as
xs:string*
,
$arg2
as
xs:string
)
as
xs:string
Summary:
Returns
The
effect
of
calling
the
singleargument
version
of
this
function
is
the
same
as
calling
the
twoargument
version
with
$arg2
set
to
a
zerolength
string.
The
function
returns
an
xs:string
created
by
concatenating
the
members
of
items
in
the
sequence
$arg1
,
in
order,
using
the
value
of
sequence
$arg2
as
a
separator.
separator
between
adjacent
items.
If
the
value
of
$arg2
is
the
zerolength
string,
then
the
members
of
$arg1
are
concatenated
without
a
separator.
If
the
value
of
$arg1
is
the
empty
sequence,
the
function
returns
the
zerolength
string
is
returned.
string.
The
expression
fn:stringjoin(('Now',
'is',
'the',
'time',
'...'),
'
')
returns
"
.
Now
"Now
is
the
time
...
".
..."
The
expression
fn:stringjoin(('Blow,
',
'blow,
',
'thou
',
'winter
',
'wind!'),
'')
returns
"
.
Blow,
"Blow,
blow,
thou
winter
wind!
".
wind!"
The
expression
fn:stringjoin((),
'separator')
returns
"".
""
.
Assume a document:
<doc> <chap><section> </section><section/> </chap> </doc>
with
the
<section>
element
as
the
context
node,
the
[XML
Path
Language
(XPath)
2.0]
expression:
fn:stringjoin(for
$n
in
ancestororself::*
return
name($n),
fn:stringjoin(ancestororself::*/name(),
'/')
returns
"
doc/chap/section
"doc/chap/section"
"
Returns
the
portion
of
the
value
of
$sourceString
beginning
at
the
position
indicated
by
the
value
of
$start
and
continuing
for
the
number
of
characters
indicated
by
the
value
of
$length
.
fn:substring
(
$sourceString
as
xs:string?
,
$startingLoc
$start
as
xs:double
)
as
xs:string
fn:substring
(

$sourceString

as
xs:string?
,


as
xs:double
,


$length

as
xs:double
)
as
xs:string

Summary:
Returns
the
portion
of
If
the
value
of
$sourceString
beginning
at
is
the
empty
sequence,
the
function
returns
the
zerolength
string.
Otherwise,
the
function
returns
a
string
comprising
those
characters
of
$sourceString
whose
index
position
indicated
by
(counting
from
one)
is
greater
than
or
equal
to
the
value
of
(rounded
to
an
integer),
and
$startingLoc
$start
continuing
for
the
number
of
characters
indicated
by
(if
$length
is
specified)
less
than
the
value
sum
of
$start
and
$length
(both
rounded
to
integers).
.
The
characters
returned
do
not
extend
beyond
$sourceString
.
If
is
zero
or
negative,
only
those
characters
in
positions
greater
than
zero
are
returned.
$startingLoc
$start
More
specifically,
the
three
argument
version
of
the
function
returns
the
characters
in
$sourceString
whose
position
$p
obeys:
satisfies:
The
two
argument
version
of
the
function
assumes
that
$length
is
infinite
and
thus
returns
the
characters
in
$sourceString
whose
position
$p
obeys:
satisfies:
fn:round($startingLoc)
fn:round($start)
<=
$p
<
fn:round(INF)
In
the
above
computations,
the
rules
for
and
op:numericlessthan()
op:numericlessthan
apply.
op:numericgreaterthan()
op:numericgreaterthan
The first character of a string is located at position 1, not position 0.
The
expression
fn:substring("motor
car",
6)
returns
"
car"
.
Characters
(Characters
starting
at
position
6
to
the
end
of
$sourceString
are
selected.
selected.).
The
expression
fn:substring("metadata",
4,
3)
returns
"ada"
.
Characters
(Characters
at
positions
greater
than
or
equal
to
4
and
less
than
7
are
selected.
selected.).
The
expression
fn:substring("12345",
1.5,
2.6)
returns
"234"
.
Characters
(Characters
at
positions
greater
than
or
equal
to
2
and
less
than
5
are
selected.
selected.).
The
expression
fn:substring("12345",
0,
3)
returns
"12"
.
Characters
(Characters
at
positions
greater
than
or
equal
to
0
and
less
than
3
are
selected.
Since
the
first
position
is
1,
these
are
the
characters
at
positions
1
and
2.
2.).
The
expression
fn:substring("12345",
5,
3)
returns
""
.
Characters
(Characters
at
positions
greater
than
or
equal
to
5
and
less
than
2
are
selected.
selected.).
The
expression
fn:substring("12345",
3,
5)
returns
"1"
.
Characters
(Characters
at
positions
greater
than
or
equal
to
3
and
less
than
2
are
selected.
Since
the
first
position
is
1,
this
is
the
character
at
position
1.
1.).
The
expression
fn:substring("12345",
0
div
0E0,
3)
returns
""
.
Since
(Since
0
div
0E0
returns
NaN
,
and
NaN
compared
to
any
other
number
returns
false
,
no
characters
are
selected.
selected.).
The
expression
fn:substring("12345",
1,
0
div
0E0)
returns
""
.
(As
above.).
As
above.
The
expression
fn:substring((),
1,
3)
returns
""
.
The
expression
fn:substring("12345",
42,
1
div
0E0)
returns
"12345"
.
Characters
(Characters
at
positions
greater
than
or
equal
to
42
and
less
than
INF
are
selected.
selected.).
The
expression
fn:substring("12345",
1
div
0E0,
1
div
0E0)
returns
""
.
Since
(Since
the
value
of
INF
+
INF
returns
is
NaN
,
no
characters
are
selected.
selected.).
Returns the number of characters in a string.
fn:stringlength
()
as
xs:integer
fn:stringlength
(
$arg
as
xs:string?
)
as
xs:integer
Summary:
Returns
The
function
returns
an
xs:integer
equal
to
the
length
in
characters
of
the
value
of
$arg
.
Calling
the
zeroargument
version
of
the
function
is
equivalent
to
calling
fn:stringlength(fn:string(.))
.
If
the
value
of
$arg
is
the
empty
sequence,
the
function
returns
the
xs:integer
0
is
returned.
value
zero
(0).
If
no
argument
is
supplied,
$arg
defaults
to
the
string
value
(calculated
using
fn:string()
)
of
the
context
item
(
.
).
If
no
argument
is
supplied
or
if
the
argument
is
the
context
item
not
specified
and
the
context
item
is
undefined
undefined,
an
error
is
raised:
[
err:XPDY0002
]
^{
XP
}.
Unlike some programming languages, a codepoint greater than 65535 counts as one character, not two.
The
expression
fn:stringlength("Harp
not
on
that
string,
madam;
that
is
past.")
returns
45
.
The
expression
fn:stringlength(())
returns
0
.
Returns
the
value
of
$arg
with
leading
and
trailing
whitespace
removed,
and
sequences
of
internal
whitespace
reduced
to
a
single
space
character.
fn:normalizespace
()
as
xs:string
fn:normalizespace
(
$arg
as
xs:string?
)
as
xs:string
Summary:
Returns
If
the
value
of
$arg
with
whitespace
normalized
is
the
empty
sequence,
the
function
returns
the
zerolength
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
than
one
adjacent
whitespace
character
characters
with
a
single
space,
#x20
.
The
whitespace
characters
are
defined
in
the
metasymbol
S
(Production
3)
of
[Extensible
Markup
Language
(XML)
1.0
Recommendation
(Third
Edition)]
.
Note:
The
definition
of
the
metasymbol
S
(Production
3),
is
unchanged
in
[Extensible
Markup
Language
(XML)
1.1
Recommendation]
[RECxml]
.
If
no
argument
is
supplied,
then
$arg
defaults
to
the
string
value
(calculated
using
)
of
the
context
item
(
fn:string()
fn:string
.
).
If
no
argument
is
supplied
or
if
the
argument
is
the
context
item
and
the
context
item
is
undefined
then
an
error
is
raised:
[
err:XPDY0002
]
^{
XP
}.
fn:normalizespace("
The
wealthy
curled
darlings
definition
of
our
nation.
")
whitespace
is
unchanged
in
[Extensible
Markup
Language
(XML)
1.1
Recommendation]
.
The
expression
fn:normalizespace(" The wealthy curled darlings
of our nation. ")
returns
"
.
The
"The
wealthy
curled
darlings
of
our
nation.
".
nation."
The
expression
fn:normalizespace(())
returns
"".
""
.
Returns
the
value
of
$arg
after
applying
Unicode
normalization.
fn:normalizeunicode
(
$arg
as
xs:string?
)
as
xs:string
fn:normalizeunicode
(

$arg

as
xs:string?
,

$normalizationForm

as
xs:string
)
as
xs:string

Summary:
Returns
If
the
value
of
$arg
is
the
empty
sequence,
the
function
returns
the
zerolength
string.
If
the
singleargument
version
of
the
function
is
used,
the
result
is
the
same
as
calling
the
twoargument
version
with
$normalizationForm
set
to
the
string
"NFC".
Otherwise,
the
function
returns
the
value
of
$arg
normalized
according
to
the
normalization
criteria
for
a
rules
of
the
normalization
form
identified
by
the
value
of
$normalizationForm
.
The
effective
value
of
the
$normalizationForm
is
computed
by
removing
leading
and
trailing
blanks,
if
present,
and
converting
to
upper
case.
If
the
value
of
the
expression
$arg
fn:uppercase(fn:normalizespace($normalizationForm))
is
the
empty
sequence,
returns
the
zerolength
string.
.
See [Character Model for the World Wide Web 1.0: Normalization] for a description of the normalization forms.
If
the
effective
value
of
$normalizationForm
is
"NFC",
then
the
value
returned
by
the
function
is
returns
the
value
of
$arg
in
converted
to
Unicode
Normalization
Form
C
(NFC).
If
the
effective
value
of
$normalizationForm
is
"NFD",
then
the
value
returned
by
the
function
is
returns
the
value
of
$arg
in
converted
to
Unicode
Normalization
Form
D
(NFD).
If
the
effective
value
of
$normalizationForm
is
"NFKC",
then
the
value
returned
by
the
function
is
returns
the
value
of
$arg
in
Unicode
Normalization
Form
KC
(NFKC).
If
the
effective
value
of
$normalizationForm
is
"NFKD",
then
the
value
returned
by
the
function
is
returns
the
value
of
$arg
in
converted
to
Unicode
Normalization
Form
KD
(NFKD).
If
the
effective
value
of
$normalizationForm
is
"FULLYNORMALIZED",
then
the
value
returned
by
the
function
is
returns
the
value
of
$arg
in
the
converted
to
fully
normalized
form.
If
the
effective
value
of
$normalizationForm
is
the
zerolength
string,
no
normalization
is
performed
and
$arg
is
returned.
Conforming implementations · must · support normalization form "NFC" and · may · support normalization forms "NFD", "NFKC", "NFKD", and "FULLYNORMALIZED". They · may · also support other normalization forms with · implementationdefined · semantics.
If
the
effective
value
of
the
$normalizationForm
argument
is
other
than
not
one
of
the
values
supported
by
the
implementation,
then
an
error
is
raised
[
err:FOCH0003
].
Converts a string to upper case.
fn:uppercase
(
$arg
as
xs:string?
)
as
xs:string
Summary:
Returns
If
the
value
of
$arg
is
the
empty
sequence,
the
zerolength
string
is
returned.
Otherwise,
the
function
returns
the
value
of
$arg
after
translating
every
character
to
its
uppercase
correspondent
as
defined
in
the
appropriate
case
mappings
section
in
the
Unicode
standard
[The
Unicode
Standard]
.
For
versions
of
Unicode
beginning
with
the
2.1.8
update,
only
localeinsensitive
case
mappings
should
be
applied.
Beginning
with
version
3.2.0
(and
likely
future
versions)
of
Unicode,
precise
mappings
are
described
in
default
case
operations,
which
are
full
case
mappings
in
the
absence
of
tailoring
for
particular
languages
and
environments.
Every
lowercase
character
that
does
not
have
an
uppercase
correspondent,
as
well
as
every
uppercase
character,
is
included
in
the
returned
value
in
its
original
form.
Case
mappings
may
change
the
length
of
a
string.
In
general,
the
two
fn:uppercase
and
fn:lowercase
functions
are
not
inverses
of
each
other
other:
fn:lowercase(fn:uppercase($arg))
is
not
guaranteed
to
return
$arg
,
nor
is
fn:uppercase(fn:lowercase($arg))
.
The
Latin
small
letter
dotless
i
(as
used
in
Turkish)
is
perhaps
the
most
prominent
lowercase
letter
which
will
not
roundtrip.
The
Latin
capital
letter
i
with
dot
above
is
the
most
prominent
uppercase
letter
which
will
not
round
trip;
there
are
others.
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.
Results
may
violate
Because
the
function
is
not
sensitive
to
locale,
results
will
not
always
match
user
expectations
(in
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).
defined.
Many characters of class Ll lack uppercase equivalents in the Unicode case mapping tables; many characters of class Lu lack lowercase equivalents.
The
expression
fn:uppercase("abCd0")
returns
"ABCD0"
.
Converts a string to lower case.
fn:lowercase
(
$arg
as
xs:string?
)
as
xs:string
Summary:
Returns
If
the
value
of
$arg
is
the
empty
sequence,
the
zerolength
string
is
returned.
Otherwise,
the
function
returns
the
value
of
$arg
after
translating
every
character
to
its
lowercase
correspondent
as
defined
in
the
appropriate
case
mappings
section
in
the
Unicode
standard
[The
Unicode
Standard]
.
For
versions
of
Unicode
beginning
with
the
2.1.8
update,
only
localeinsensitive
case
mappings
should
be
applied.
Beginning
with
version
3.2.0
(and
likely
future
versions)
of
Unicode,
precise
mappings
are
described
in
default
case
operations,
which
are
full
case
mappings
in
the
absence
of
tailoring
for
particular
languages
and
environments.
Every
uppercase
character
that
does
not
have
a
lowercase
correspondent,
as
well
as
every
lowercase
character,
is
included
in
the
returned
value
in
its
original
form.
Case
mappings
may
change
the
length
of
a
string.
In
general,
the
two
fn:uppercase
and
fn:lowercase
functions
are
not
inverses
of
each
other
other:
fn:lowercase(fn:uppercase($arg))
is
not
guaranteed
to
return
$arg
,
nor
is
fn:uppercase(fn:lowercase($arg))
.
The
Latin
small
letter
dotless
i
(as
used
in
Turkish)
is
perhaps
the
most
prominent
lowercase
letter
which
will
not
roundtrip.
The
Latin
capital
letter
i
with
dot
above
is
the
most
prominent
uppercase
letter
which
will
not
round
trip;
there
are
others.
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.
Results
may
violate
Because
the
function
is
not
sensitive
to
locale,
results
will
not
always
match
user
expectations
(in
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).
defined.
Many characters of class Ll lack uppercase equivalents in the Unicode case mapping tables; many characters of class Lu lack lowercase equivalents.
The
expression
fn:lowercase("ABc!D")
returns
"abc!d"
.
Returns
the
value
of
$arg
modified
by
replacing
or
removing
individual
characters.
fn:translate
(

$arg

as
xs:string?
,

$mapString

as
xs:string
,


$transString

as
xs:string
)
as
xs:string

If
the
value
of
$arg
is
the
empty
sequence,
the
function
returns
the
zerolength
string
is
returned.
string.
Every
Otherwise,
the
function
returns
a
result
string
constructed
by
processing
each
character
in
the
value
of
$arg
,
in
order,
according
to
the
following
rules:
that
If
the
character
does
not
appear
in
the
value
of
$mapString
then
it
is
added
to
the
result
string
unchanged.
Every
If
the
character
first
appears
in
the
value
of
$arg
$mapString
that
appears
at
some
position
M
,
where
the
value
of
$transString
is
M
or
more
characters
in
length,
then
the
character
at
position
M
in
$transString
is
added
to
the
result
string.
If
the
character
first
appears
in
the
value
of
$mapString
at
some
position
M
,
where
the
value
of
,
$transString
is
less
than
M
characters
in
length,
then
the
character
is
omitted
from
the
returned
value.
result
string.
If
$mapString
is
the
zerolength
string
then
the
function
returns
$arg
is
returned.
unchanged.
If
a
character
occurs
more
than
once
in
$mapString
,
then
the
first
occurrence
determines
the
replacement
character.
action
taken.
If
$transString
is
longer
than
$mapString
,
the
excess
characters
are
ignored.
The
expression
fn:translate("bar","abc","ABC")
returns
"BAr"
.
The
expression
fn:translate("aaa","abc","ABC")
returns
"AAA"
.
The
expression
fn:translate("abcdabc",
"abc",
"AB")
returns
"ABdAB"
.
The
functions
described
in
the
section
examine
a
string
$arg1
to
see
whether
it
contains
another
string
$arg2
as
a
substring.
The
result
depends
on
whether
$arg2
is
a
substring
of
$arg1
,
and
if
so,
on
the
range
of
characters
in
$arg1
which
$arg2
matches.
When
the
·
Unicode
code
point
codepoint
collation
·
is
used,
this
simply
involves
determining
whether
$arg1
contains
a
contiguous
sequence
of
characters
whose
code
points
codepoints
are
the
same,
one
for
one,
with
the
code
points
codepoints
of
the
characters
in
$arg2
.
When a collation is specified, the rules are more complex.
All
collations
support
the
capability
of
deciding
whether
two
strings
are
considered
equal,
and
if
not,
which
of
the
strings
should
be
regarded
as
preceding
the
other.
For
functions
such
as
,
this
is
all
that
is
required.
For
other
functions,
such
as
fn:compare()
fn:compare
,
the
collation
needs
to
support
an
additional
property:
it
must
be
able
to
decompose
the
string
into
a
sequence
of
collation
units,
each
unit
consisting
of
one
or
more
characters,
such
that
two
strings
can
be
compared
by
pairwise
comparison
of
these
units.
("collation
unit"
is
equivalent
to
"collation
element"
as
defined
in
[Unicode
Collation
Algorithm]
.)
The
string
fn:contains()
fn:contains
$arg1
is
then
considered
to
contain
$arg2
as
a
substring
if
the
sequence
of
collation
units
corresponding
to
$arg2
is
a
subsequence
of
the
sequence
of
the
collation
units
corresponding
to
$arg1
.
The
characters
in
$arg1
that
match
are
the
characters
corresponding
to
these
collation
units.
This
rule
may
occasionally
lead
to
surprises.
For
example,
consider
a
collation
that
treats
"Jaeger"
and
"Jäger"
as
equal.
It
might
do
this
by
treating
"ä"
as
representing
two
collation
units,
in
which
case
the
expression
fn:contains("Jäger",
"eg")
will
return
true
.
Alternatively,
a
collation
might
treat
"ae"
as
a
single
collation
unit,
in
which
case
the
expression
fn:contains("Jaeger",
"eg")
will
return
false
.
The
results
of
these
functions
thus
depend
strongly
on
the
properties
of
the
collation
that
is
used.
In
addition,
collations
may
specify
that
some
collation
units
should
be
ignored
during
matching.
If
hyphen
is
an
ignored
collation
unit,
then
fn:contains("codepoint",
"codepoint")
will
be
true,
and
fn:contains("codepoint",
"")
will
also
be
true.
In
the
definitions
below,
we
say
that
$arg1
contains
$arg2
at
positions
m
through
n
if
the
collation
units
corresponding
refer
to
characters
the
terms
match
and
minimal
match
as
defined
in
positions
m
to
n
definitions
DS2
and
DS4
of
[Unicode
Collation
Algorithm]
.
In
applying
these
definitions:
C
is
the
collation;
that
is,
the
value
of
the
$arg1
$collation
are
the
same
as
argument
if
specified,
otherwise
the
collation
units
corresponding
to
all
default
collation.
P
is
the
characters
of
(candidate)
substring
$arg2
modulo
ignorable
collation
units.
In
the
simple
case
of
Q
is
the
Unicode
code
point
collation,
(candidate)
containing
string
$arg1
The
boundary
condition
B
is
satisfied
at
the
start
and
end
of
a
string,
and
between
any
two
characters
that
belong
to
different
collation
units
are
the
same
as
(collation
elements
in
the
characters
language
of
the
string.
See
[Unicode
Collation
Algorithm]
for
a
detailed
discussion
of
substring
matching.
).
It
is
not
satisfied
between
two
characters
that
belong
to
the
same
collation
unit.
It is possible to define collations that do not have the ability to decompose a string into units suitable for substring matching. An argument to a function defined in this section may be a URI that identifies a collation that is able to compare two strings, but that does not have the capability to split the string into collation units. Such a collation may cause the function to fail, or to give unexpected results or it may be rejected as an unsuitable argument. The ability to decompose strings into collation units is an · implementationdefined · property of the collation.
Function  Meaning 

fn:contains

contains
as
a
substring,
taking
collations
into
account.

fn:startswith

as
a
leading
substring,
taking
collations
into
account.

fn:endswith

as
a
trailing
substring,
taking
collations
into
account.

fn:substringbefore

Returns
the
that
,
taking
collations
into
account.

fn:substringafter

Returns
the
that
,
taking
collations
into
account.

Returns
true
if
the
string
$arg1
contains
$arg2
as
a
substring,
taking
collations
into
account.
fn:contains
(
$arg1
as
xs:string?
,
$arg2
as
xs:string?
)
as
xs:boolean
fn:contains
(

$arg1

as
xs:string?
,

$arg2

as
xs:string?
,


$collation

as
xs:string
)
as
xs:boolean

If
the
value
of
$arg1
or
$arg2
is
the
empty
sequence,
or
contains
only
ignorable
collation
units,
it
is
interpreted
as
the
zerolength
string.
If
the
value
of
$arg2
is
the
zerolength
string,
then
the
function
returns
true
.
If
the
value
of
$arg1
is
the
zerolength
string,
the
function
returns
false
.
The
collation
used
by
the
invocation
of
this
function
is
determined
according
to
the
rules
in
7.3.1
Collations
5.3.3
Choosing
a
Collation
.
The
function
returns
an
xs:boolean
indicating
whether
or
not
the
value
of
$arg1
contains
(at
the
beginning,
at
the
end,
or
anywhere
within)
at
least
one
sequence
of
collation
units
that
provides
a
minimal
match
to
the
collation
units
in
the
value
of
$arg2
,
according
to
the
collation
that
is
used.
Note:
Minimal match is defined in [Unicode Collation Algorithm] .
If the specified collation does not support collation units an error · may · be raised [ err:FOCH0004 ].
CollationA
The
collation
used
in
these
examples
examples,
http://example.com/CollationA
is
a
collation
in
which
both
""
and
"*"
are
ignorable
collation
units.
"Ignorable collation unit" is equivalent to "ignorable collation element" in [Unicode Collation Algorithm] .
The
expression
fn:contains
(
"tattoo",
"t")
returns
.
true
true()
The
expression
fn:contains
(
"tattoo",
"ttt")
returns
.
false
false()
The
expression
fn:contains
(
"",
())
returns
.
true
true()
The
(The
first
rule
is
applied,
followed
by
the
second
rule.
rule.).
The
expression
fn:contains
(
"abcdefghi",
"def",
returns
"CollationA")
"http://example.com/CollationA")
.
true
true()
The
expression
fn:contains
(
"a*b*c*d*e*f*g*h*i*",
"def",
returns
"CollationA")
"http://example.com/CollationA")
.
true
true()
The
expression
fn:contains
(
"abcd***ef**ghi",
"def",
returns
"CollationA")
"http://example.com/CollationA")
.
true
true()
The
expression
fn:contains
(
(),
"****",
returns
"CollationA")
"http://example.com/CollationA")
.
true
true()
The
(The
second
argument
contains
only
ignorable
collation
units
and
is
equivalent
to
the
zerolength
string.
string.).
Returns
true
if
the
string
$arg1
contains
$arg2
as
a
leading
substring,
taking
collations
into
account.
fn:startswith
(
$arg1
as
xs:string?
,
$arg2
as
xs:string?
)
as
xs:boolean
fn:startswith
(

$arg1

as
xs:string?
,

$arg2

as
xs:string?
,


$collation

as
xs:string
)
as
xs:boolean

If
the
value
of
$arg1
or
$arg2
is
the
empty
sequence,
or
contains
only
ignorable
collation
units,
it
is
interpreted
as
the
zerolength
string.
If
the
value
of
$arg2
is
the
zerolength
string,
then
the
function
returns
true
.
If
the
value
of
$arg1
is
the
zerolength
string
and
the
value
of
$arg2
is
not
the
zerolength
string,
then
the
function
returns
false
.
The
collation
used
by
the
invocation
of
this
function
is
determined
according
to
the
rules
in
7.3.1
Collations
5.3.3
Choosing
a
Collation
.
The
function
returns
an
xs:boolean
indicating
whether
or
not
the
value
of
$arg1
starts
with
a
sequence
of
collation
units
that
provides
a
match
to
the
collation
units
of
$arg2
according
to
the
collation
that
is
used.
Note:
Match is defined in [Unicode Collation Algorithm] .
If the specified collation does not support collation units an error · may · be raised [ err:FOCH0004 ].
CollationA
The
collation
used
in
these
examples
examples,
http://example.com/CollationA
is
a
collation
in
which
both
""
and
"*"
are
ignorable
collation
units.
"Ignorable collation unit" is equivalent to "ignorable collation element" in [Unicode Collation Algorithm] .
The
expression
fn:startswith("tattoo",
"tat")
returns
.
true
true()
The
expression
fn:startswith
(
"tattoo",
"att")
returns
.
false
false()
The
expression
fn:startswith
((),
())
returns
.
true
true()
The
expression
fn:startswith
(
"abcdefghi",
"abc",
returns
"CollationA")
"http://example.com/CollationA")
.
true
true()
The
expression
fn:startswith
(
"a*b*c*d*e*f*g*h*i*",
"abc",
returns
"CollationA")
"http://example.com/CollationA")
.
true
true()
The
expression
fn:startswith
(
"abcd***ef**ghi",
"abcdef",
returns
"CollationA")
"http://example.com/CollationA")
.
true
true()
The
expression
fn:startswith
(
(),
"****",
returns
"CollationA")
"http://example.com/CollationA")
.
true
true()
The
(The
second
argument
contains
only
ignorable
collation
units
and
is
equivalent
to
the
zerolength
string.
string.).
The
expression
fn:startswith
(
"abcdefghi",
"abc",
"http://example.com/CollationA")
returns
true()
.
Returns
true
if
the
string
$arg1
contains
$arg2
as
a
trailing
substring,
taking
collations
into
account.
fn:endswith
(
$arg1
as
xs:string?
,
$arg2
as
xs:string?
)
as
xs:boolean
fn:endswith
(

$arg1

as
xs:string?
,

$arg2

as
xs:string?
,


$collation

as
xs:string
)
as
xs:boolean

If
the
value
of
$arg1
or
$arg2
is
the
empty
sequence,
or
contains
only
ignorable
collation
units,
it
is
interpreted
as
the
zerolength
string.
If
the
value
of
$arg2
is
the
zerolength
string,
then
the
function
returns
true
.
If
the
value
of
$arg1
is
the
zerolength
string
and
the
value
of
$arg2
is
not
the
zerolength
string,
then
the
function
returns
false
.
The
collation
used
by
the
invocation
of
this
function
is
determined
according
to
the
rules
in
7.3.1
Collations
5.3.3
Choosing
a
Collation
.
The
function
returns
an
xs:boolean
indicating
whether
or
not
the
value
of
$arg1
starts
with
a
sequence
of
collation
units
that
provides
a
match
to
the
collation
units
of
$arg2
according
to
the
collation
that
is
used.
Note:
Match is defined in [Unicode Collation Algorithm] .
If the specified collation does not support collation units an error · may · be raised [ err:FOCH0004 ].
CollationA
The
collation
used
in
these
examples
examples,
http://example.com/CollationA
is
a
collation
in
which
both
""
and
"*"
are
ignorable
collation
units.
"Ignorable collation unit" is equivalent to "ignorable collation element" in [Unicode Collation Algorithm] .
The
expression
fn:endswith
(
"tattoo",
"tattoo")
returns
.
true
true()
The
expression
fn:endswith
(
"tattoo",
"atto")
returns
.
false
false()
The
expression
fn:endswith
((),
())
returns
.
true
true()
The
expression
fn:endswith
(
"abcdefghi",
"ghi",
returns
"CollationA")
"http://example.com/CollationA")
.
true
true()
The
expression
fn:endswith
(
"abcd***ef**ghi",
"defghi",
returns
"CollationA")
"http://example.com/CollationA")
.
true
true()
The
expression
fn:endswith
(
"abcd***ef**ghi",
"defghi",
returns
"CollationA")
"http://example.com/CollationA")
.
true
true()
The
expression
fn:endswith
(
(),
"****",
returns
"CollationA")
"http://example.com/CollationA")
.
true
true()
The
(The
second
argument
contains
only
ignorable
collation
units
and
is
equivalent
to
the
zerolength
string.
string.).
The
expression
fn:endswith
(
"abcdefghi",
"ghi",
"http://example.com/CollationA")
returns
true()
.
Returns
the
part
of
$arg1
that
precedes
the
first
occurrence
of
$arg2
,
taking
collations
into
account.
fn:substringbefore
(
$arg1
as
xs:string?
,
$arg2
as
xs:string?
)
as
xs:string
fn:substringbefore
(

$arg1

as
xs:string?
,

$arg2

as
xs:string?
,


$collation

as
xs:string
)
as
xs:string

If
the
value
of
$arg1
or
$arg2
is
the
empty
sequence,
or
contains
only
ignorable
collation
units,
it
is
interpreted
as
the
zerolength
string.
If
the
value
of
$arg2
is
the
zerolength
string,
then
the
function
returns
the
zerolength
string.
If
the
value
of
$arg1
does
not
contain
a
string
that
is
equal
to
the
value
of
$arg2
,
then
the
function
returns
the
zerolength
string.
The
collation
used
by
the
invocation
of
this
function
is
determined
according
to
the
rules
in
7.3.1
Collations
5.3.3
Choosing
a
Collation
.
The
function
returns
the
substring
of
the
value
of
$arg1
that
precedes
in
the
value
of
$arg1
the
first
occurrence
of
a
sequence
of
collation
units
that
provides
a
minimal
match
to
the
collation
units
of
$arg2
according
to
the
collation
that
is
used.
Note:
Minimal match is defined in [Unicode Collation Algorithm] .
If the specified collation does not support collation units an error · may · be raised [ err:FOCH0004 ].
CollationA
The
collation
used
in
these
examples
examples,
http://example.com/CollationA
is
a
collation
in
which
both
""
and
"*"
are
ignorable
collation
units.
"Ignorable collation unit" is equivalent to "ignorable collation element" in [Unicode Collation Algorithm] .
The
expression
fn:substringbefore
(
"tattoo",
"attoo")
returns
"
.
t
".
"t"
The
expression
fn:substringbefore
(
"tattoo",
"tatto")
returns
"".
""
.
The
expression
fn:substringbefore
((),
())
returns
"".
""
.
The
expression
fn:substringbefore
(
"abcdefghi",
"de",
returns
"CollationA")
"http://example.com/CollationA")
"
.
abc
".
"abc"
The
expression
fn:substringbefore
(
"abcdefghi",
"de",
returns
"CollationA")
"http://example.com/CollationA")
"
.
abc
".
"abc"
The
expression
fn:substringbefore
(
"a*b*c*d*e*f*g*h*i*",
"***cde",
returns
"CollationA")
"http://example.com/CollationA")
"
.
a*b*
".
"a*b*"
The
expression
fn:substringbefore
(
"Eureka!",
"****",
returns
"CollationA")
"http://example.com/CollationA")
"".
The
""
.
(The
second
argument
contains
only
ignorable
collation
units
and
is
equivalent
to
the
zerolength
string.
string.).
Returns
the
part
of
$arg1
that
follows
the
first
occurrence
of
$arg2
,
taking
collations
into
account.
fn:substringafter
(
$arg1
as
xs:string?
,
$arg2
as
xs:string?
)
as
xs:string
fn:substringafter
(

$arg1

as
xs:string?
,

$arg2

as
xs:string?
,


$collation

as
xs:string
)
as
xs:string

If
the
value
of
$arg1
or
$arg2
is
the
empty
sequence,
or
contains
only
ignorable
collation
units,
it
is
interpreted
as
the
zerolength
string.
If
the
value
of
$arg2
is
the
zerolength
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
zerolength
string.
The
collation
used
by
the
invocation
of
this
function
is
determined
according
to
the
rules
in
7.3.1
Collations
5.3.3
Choosing
a
Collation
.
The
function
returns
the
substring
of
the
value
of
$arg1
that
follows
in
the
value
of
$arg1
the
first
occurrence
of
a
sequence
of
collation
units
that
provides
a
minimal
match
to
the
collation
units
of
$arg2
according
to
the
collation
that
is
used.
Note:
Minimal match is defined in [Unicode Collation Algorithm] .
If the specified collation does not support collation units an error · may · be raised [ err:FOCH0004 ].
CollationA
The
collation
used
in
these
examples
examples,
http://example.com/CollationA
is
a
collation
in
which
both
""
and
"*"
are
ignorable
collation
units.
"Ignorable collation unit" is equivalent to "ignorable collation element" in [Unicode Collation Algorithm] .
The
expression
fn:substringafter("tattoo",
"tat")
returns
"
.
too
".
"too"
The
expression
returns
fn:substringafter
(
"tattoo",
fn:substringafter("tattoo",
"tattoo")
"".
""
.
The
expression
returns
fn:substringafter
((),
fn:substringafter((),
())
"".
""
.
The
expression
returns
fn:substringafter
(
"abcdefghi",
fn:substringafter("abcdefghi",
"de",
"CollationA")
"http://example.com/CollationA")
"
.
fghi
".
"fghi"
The
expression
returns
fn:substringafter
(
"abcdefghi",
fn:substringafter("abcdefghi",
"de",
"CollationA")
"http://example.com/CollationA")
"
.
fghi
".
"fghi"
The
expression
fn:substringafter
(
"a*b*c*d*e*f*g*h*i*",
"***cde***",
returns
"CollationA")
"http://example.com/CollationA")
"
.
*f*g*h*i*
".
"*f*g*h*i*"
The
expression
fn:substringafter
(
"Eureka!",
"****",
returns
"CollationA")
"http://example.com/CollationA")
"
.
(The
second
argument
contains
only
ignorable
collation
units
and
is
equivalent
to
the
zerolength
Eureka!
".
The
"Eureka!"
string.
string.).
The three functions described in this section make use of a regular expression syntax for pattern matching. This is described below.
Function  Meaning 

fn:matches

Returns

fn:replace

Returns
a
string
produced
from
the

fn:tokenize

Returns
a
sequence
of


Analyzes
a
string
using
a
regular
expression,
returning
an
XML
structure
that
identifies
which
parts
of
the

The regular expression syntax used by these functions is defined in terms of the regular expression syntax specified in XML Schema (see [XML Schema Part 2: Datatypes Second Edition] ), which in turn is based on the established conventions of languages such as Perl. However, because XML Schema uses regular expressions only for validity checking, it omits some facilities that are widelyused with languages such as Perl. This section, therefore, describes extensions to the XML Schema regular expressions syntax that reinstate these capabilities.
Note:
It is recommended that implementers consult [Unicode Regular Expressions] for information on using regular expression processing on Unicode characters.
The regular expression syntax and semantics are identical to those defined in [XML Schema Part 2: Datatypes Second Edition] with the following additions:
Two
metacharacters,
^
and
$
are
added.
By
default,
the
metacharacter
^
matches
the
start
of
the
entire
string,
while
$
matches
the
end
of
the
entire
string.
In
multiline
mode,
^
matches
the
start
of
any
line
(that
is,
the
start
of
the
entire
string,
and
the
position
immediately
after
a
newline
character),
while
$
matches
the
end
of
any
line
(that
is,
the
end
of
the
entire
string,
and
the
position
immediately
before
a
newline
character).
Newline
here
means
the
character
#x0A
only.
This means that the production in [XML Schema Part 2: Datatypes Second Edition] :
[10]
Char
::=
[^.\?*+()#x5B#x5D]
is modified to read:
[10]
Char
::=
[^.\?*+{}()^$#x5B#x5D]
The
characters
#x5B
and
#x5D
correspond
to
"
[
"
and
"
]
"
respectively.
Note:
The definition of Char (production [10]) in [XML Schema Part 2: Datatypes Second Edition] has a known error in which it omits the left brace ("{") and right brace ("}"). That error is corrected here.
The following production:
[11]
charClass
::=
charClassEsc

charClassExpr

WildCardEsc
is modified to read:
[11]
charClass
::=
charClassEsc

charClassExpr

WildCardEsc

"^"

"$"
Reluctant
quantifiers
are
supported.
They
are
indicated
by
a
"
?
"
following
a
quantifier.
Specifically:
X??
matches
X,
once
or
not
at
all
X*?
matches
X,
zero
or
more
times
X+?
matches
X,
one
or
more
times
X{n}?
matches
X,
exactly
n
times
X{n,}?
matches
X,
at
least
n
times
X{n,m}?
matches
X,
at
least
n
times,
but
not
more
than
m
times
The
effect
of
these
quantifiers
is
that
the
regular
expression
matches
the
shortest
possible
substring
consistent
with
the
match
as
a
whole
succeeding.
Without
the
"
?
",
the
regular
expression
matches
the
longest
possible
substring.
To achieve this, the production in [XML Schema Part 2: Datatypes Second Edition] :
[4]
quantifier
::=
[?*+]

(
'{'
quantity
'}'
)
is changed to:
[4]
quantifier
::=
(
[?*+]

(
'{'
quantity
'}'
)
)
'?'?
Note:
Reluctant
quantifiers
have
no
effect
on
the
results
of
the
boolean
fn:matches
function,
since
this
function
is
only
interested
in
discovering
whether
a
match
exists,
and
not
where
it
exists.
Subexpressions
(groups)
within
the
regular
expression
are
recognized.
The
regular
expression
syntax
defined
by
[XML
Schema
Part
2:
Datatypes
Second
Edition]
allows
a
regular
expression
to
contain
parenthesized
subexpressions,
but
attaches
no
special
significance
to
them.
The
function
described
below
allows
access
to
the
parts
of
the
input
string
that
matched
a
subexpression
(called
captured
substrings).
The
subexpressions
are
numbered
according
to
the
position
of
the
opening
parenthesis
in
lefttoright
order
within
the
toplevel
regular
expression:
the
first
opening
parenthesis
identifies
captured
substring
1,
the
second
identifies
captured
substring
2,
and
so
on.
0
identifies
the
substring
captured
by
the
entire
regular
expression.
If
a
subexpression
matches
more
than
one
substring
(because
it
is
within
a
construct
that
allows
repetition),
then
only
the
last
substring
that
it
matched
will
be
captured.
fn:replace()
fn:replace
Noncapturing
groups
are
also
recognized.
These
are
indicated
by
the
syntax
(?:xxxx)
.
Specifically,
the
production
rule
for
atom
in
[XML
Schema
Part
2:
Datatypes
Second
Edition]
is
changed
from:
[9]
atom
::=
Char

charClass

(
'('
regExp
')'
)
to:
[9]
atom
::=
Char

charClass

(
'('
'?:'?
regExp
')'
)
The
presence
of
the
optional
?:
has
no
effect
on
the
set
of
strings
that
match
the
regular
expression,
but
causes
the
left
parenthesis
not
to
be
counted
by
operations
that
number
the
groups
within
a
regular
expression,
for
example
the
fn:replace
function.
Backreferences
are
allowed.
allowed
outside
a
character
class
expression.
A
backreference
is
an
additional
kind
of
atom.
The
construct
where
\n
\N
is
a
single
digit
is
always
recognized
as
a
backreference;
if
this
is
followed
by
further
digits,
these
digits
are
taken
to
be
part
of
the
backreference
if
and
only
if
the
resulting
number
n
N
NN
is
such
that
the
backreference
is
preceded
by
sufficiently
many
capturing
subexpressions.
NN
or
more
unescaped
opening
parentheses.
The
regular
expression
is
invalid
if
a
backreference
refers
to
a
subexpression
that
does
not
exist
or
whose
closing
right
parenthesis
occurs
after
the
backreference.
A
backreference
matches
the
string
that
was
matched
by
the
th
capturing
subexpression
within
the
regular
expression,
that
is,
the
parenthesized
subexpression
whose
opening
left
parenthesis
is
the
n
N
th
unescaped
left
parenthesis
within
the
regular
expression.
n
N
The
closing
right
parenthesis
of
this
subexpression
must
occur
before
the
backreference.
For
example,
the
regular
expression
('").*\1
matches
a
sequence
of
characters
delimited
either
by
an
apostrophe
at
the
start
and
end,
or
by
a
quotation
mark
at
the
start
and
end.
If
no
string
is
matched
by
the
th
capturing
subexpression,
the
backreference
is
interpreted
as
matching
a
zerolength
string.
n
N
Backreferences change the following production:
[23]
charClassEsc
[9]
atom
::=
(
SingleCharEsc

MultiCharEsc
Char

catEsc
charClass

complEsc
(
'('
regExp
')'
)
to
[23]
charClassEsc
[9]
atom
::=
(
SingleCharEsc

MultiCharEsc
Char

catEsc
charClass

complEsc
(
'('
regExp
')'
)

backReference
)
[23a]
[9a]
backReference
::=
"\"
[19][09]*
Note:
Within
a
character
class
expression,
\
followed
by
a
digit
is
invalid.
Some
other
regular
expression
languages
interpret
this
as
an
octal
character
reference.
Single
character
escapes
are
extended
to
allow
the
$
character
to
be
escaped.
The
following
production
is
changed:
[24]SingleCharEsc
::=
'\'
[nrt\.?*+(){}#x2D#x5B#x5D#x5E]
to
[24]SingleCharEsc
::=
'\'
[nrt\.?*+(){}$#x2D#x5B#x5D#x5E]
All
these
functions
provide
an
optional
parameter,
$flags
,
to
set
options
for
the
interpretation
of
the
regular
expression.
The
parameter
accepts
a
xs:string
,
in
which
individual
letters
are
used
to
set
options.
The
presence
of
a
letter
within
the
string
indicates
that
the
option
is
on;
its
absence
indicates
that
the
option
is
off.
Letters
may
appear
in
any
order
and
may
be
repeated.
If
there
are
characters
present
that
are
not
defined
here
as
flags,
then
an
error
is
raised
[
err:FORX0001
].
The following options are defined:
s
:
If
present,
the
match
operates
in
"dotall"
mode.
(Perl
calls
this
the
singleline
mode.)
If
the
s
flag
is
not
specified,
the
metacharacter
.
matches
any
character
except
a
newline
(
#x0A
)
character.
In
dotall
mode,
the
metacharacter
.
matches
any
character
whatsoever.
Suppose
the
input
contains
"hello"
and
"world"
on
two
lines.
This
will
not
be
matched
by
the
regular
expression
"hello.*world"
unless
dotall
mode
is
enabled.
m
:
If
present,
the
match
operates
in
multiline
mode.
By
default,
the
metacharacter
^
matches
the
start
of
the
entire
string,
while
$
matches
the
end
of
the
entire
string.
In
multiline
mode,
^
matches
the
start
of
any
line
(that
is,
the
start
of
the
entire
string,
and
the
position
immediately
after
a
newline
character),
character
other
than
a
newline
that
appears
as
the
last
character
in
the
string
),
while
$
matches
the
end
of
any
line
(that
is,
the
end
of
the
entire
string,
and
the
position
immediately
before
a
newline
character).
character,
and
the
end
of
the
entire
string
if
there
is
no
newline
character
at
the
end
of
the
string).
Newline
here
means
the
character
#x0A
only.
i
:
If
present,
the
match
operates
in
caseinsensitive
mode.
The
detailed
rules
are
as
follows.
In
these
rules,
a
character
C2
is
considered
to
be
a
casevariant
of
another
character
C1
if
the
following
XPath
expression
returns
true
when
the
two
characters
are
considered
as
strings
of
length
one,
and
the
·
Unicode
codepoint
collation
·
is
used:
fn:lowercase(C1)
eq
fn:lowercase(C2)
or
fn:uppercase(C1)
eq
fn:uppercase(C2)
Note that the casevariants of a character under this definition are always single characters.
When
a
normal
character
(
Char
)
is
used
as
an
atom,
it
represents
the
set
containing
that
character
and
all
its
casevariants.
For
example,
the
regular
expression
"z"
will
match
both
"z"
and
"Z".
A
character
range
(
charRange
)
represents
the
set
containing
all
the
characters
that
it
would
match
in
the
absence
of
the
"
i
"
flag,
together
with
their
casevariants.
For
example,
the
regular
expression
"[AZ]"
will
match
all
the
letters
AZ
and
all
the
letters
az.
It
will
also
match
certain
other
characters
such
as
#x212A
(KELVIN
SIGN),
since
fn:lowercase("#x212A")
is
"k".
This
rule
applies
also
to
a
character
range
used
in
a
character
class
subtraction
(
charClassSub
):
thus
[AZ[IO]]
will
match
characters
such
as
"A",
"B",
"a",
and
"b",
but
will
not
match
"I",
"O",
"i",
or
"o".
The rule also applies to a character range used as part of a negative character group: thus [^Q] will match every character except "Q" and "q" (these being the only casevariants of "Q" in Unicode).
A
backreference
is
compared
using
caseblind
comparison:
that
is,
each
character
must
either
be
the
same
as
the
corresponding
character
of
the
previously
matched
string,
or
must
be
a
casevariant
of
that
character.
For
example,
the
strings
"Mum",
"mom",
"Dad",
and
"DUD"
all
match
the
regular
expression
"([md])[aeiou]\1"
when
the
"
i
"
flag
is
used.
All
other
constructs
are
unaffected
by
the
"
i
"
flag.
For
example,
"\p{Lu}"
continues
to
match
uppercase
letters
only.
x
:
If
present,
whitespace
characters
(#x9,
#xA,
#xD
and
#x20)
in
the
regular
expression
are
removed
prior
to
matching
with
one
exception:
whitespace
characters
within
character
class
expressions
(
charClassExpr
)
are
not
removed.
This
flag
can
be
used,
for
example,
to
break
up
long
regular
expressions
into
readable
lines.
Examples:
fn:matches("helloworld",
"hello
world",
"x")
returns
true
true()
fn:matches("helloworld",
"hello[
]world",
"x")
returns
false
false()
fn:matches("hello
world",
"hello\
sworld",
"x")
returns
true
true()
fn:matches("hello
world",
"hello
world",
"x")
returns
false
false()
q
:
if
present,
all
characters
in
the
regular
expression
are
treated
as
representing
themselves,
not
as
metacharacters.
In
effect,
every
character
that
would
normally
have
a
special
meaning
in
a
regular
expression
is
implicitly
escaped
by
preceding
it
with
a
backslash.
Furthermore,
when
this
flag
is
present,
the
characters
$
and
\
have
no
special
significance
when
used
in
the
replacement
string
supplied
to
the
fn:replace
function.
This
flag
can
be
used
in
conjunction
with
the
i
flag.
If
it
is
used
together
with
the
m
,
s
,
or
x
flag,
that
flag
has
no
effect.
Examples:
fn:tokenize("12.3.5.6",
".",
"q")
returns
("12",
"3",
"5",
"6")
fn:replace("a\b\c",
"\",
"\\",
"q")
returns
"a\\b\\c"
fn:replace("a/b/c",
"/",
"$",
"q")
returns
"a$b$c"
fn:matches("abcd",
".*",
"q")
returns
false()
fn:matches("Mr.
B.
Obama",
"B.
OBAMA",
"iq")
returns
true()
Returns true if the supplied string matches a given regular expression.
fn:matches
(
$input
as
xs:string?
,
$pattern
as
xs:string
)
as
xs:boolean
fn:matches
(

$input

as
xs:string?
,

$pattern

as
xs:string
,


$flags

as
xs:string
)
as
xs:boolean

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
zerolength
string.
Flags
are
defined
in
7.6.1.1
5.6.1.1
Flags
.
If
$input
is
the
empty
sequence,
it
is
interpreted
as
the
zerolength
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.
An
error
is
raised
[
err:FORX0002
]
if
the
value
of
$pattern
is
invalid
according
to
the
rules
described
in
5.6.1
Regular
Expression
Syntax
.
An
error
is
raised
[
err:FORX0001
]
if
the
value
of
$flags
is
invalid
according
to
the
rules
described
in
5.6.1.1
Flags
.
Unless
the
metacharacters
^
and
$
are
used
as
anchors,
the
string
is
considered
to
match
the
pattern
if
any
substring
matches
the
pattern.
But
if
anchors
are
used,
the
anchors
must
match
the
start/end
of
the
string
(in
string
mode),
or
the
start/end
of
a
line
(in
multiline
mode).
This is different from the behavior of patterns in [XML Schema Part 2: Datatypes Second Edition] , where regular expressions are implicitly anchored.
An
error
is
raised
[
err:FORX0002
]
if
the
value
of
$pattern
is
invalid
according
to
the
rules
described
in
section
7.6.1
Regular
Expression
Syntax
.
An
error
expression
matching
is
raised
[
err:FORX0001
]
if
defined
on
the
value
basis
of
$flags
is
invalid
according
to
the
rules
described
in
section
7.6.1
Regular
Expression
Syntax
.
Unicode
code
points;
it
takes
no
account
of
collations.
The
expression
fn:matches("abracadabra",
"bra")
returns
true
true()
.
The
expression
fn:matches("abracadabra",
"^a.*a$")
returns
true
true()
.
The
expression
fn:matches("abracadabra",
"^bra")
returns
false
false()
.
Given the source document:
let
$poem
:=
<poem author="Wilhelm Busch"> Kaum hat dies der Hahn gesehen, Fängt er auch schon an zu krähen:«Kikeriki! Kikikerikih!!»Kikeriki! Kikikerikih!! Tak, tak, tak!  da kommen sie. </poem>
the
following
function
calls
produce
the
following
results,
with
the
poem
element
as
the
context
node:
The
expression
returns
fn:matches(.,
fn:matches($poem,
"Kaum.*krähen")
.
false
false()
The
expression
returns
fn:matches(.,
fn:matches($poem,
"Kaum.*krähen",
"s")
.
true
true()
The
expression
returns
fn:matches(.,
fn:matches($poem,
"^Kaum.*gesehen,$",
"m")
.
true
true()
The
expression
returns
fn:matches(.,
fn:matches($poem,
"^Kaum.*gesehen,$")
.
false
false()
The
expression
returns
fn:matches(.,
fn:matches($poem,
"kiki",
"i")
.
true
Note:
Regular
expression
matching
is
defined
on
the
basis
of
Unicode
code
points;
it
takes
no
account
of
collations.
true()
Returns a string produced from the input string by replacing any substrings that match a given regular expression with a supplied replacement string.
fn:replace
(

$input

as
xs:string?
,

$pattern

as
xs:string
,


$replacement

as
xs:string
)
as
xs:string

fn:replace
(

$input

as
xs:string?
,

$pattern

as
xs:string
,


$replacement

as
xs:string
,


$flags

as
xs:string
)
as
xs:string

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
zerolength
string.
Flags
are
defined
in
7.6.1.1
5.6.1.1
Flags
.
The
$flags
argument
is
interpreted
in
the
same
manner
as
for
the
function.
fn:matches()
fn:matches
If
$input
is
the
empty
sequence,
it
is
interpreted
as
the
zerolength
string.
The
function
returns
the
xs:string
that
is
obtained
by
replacing
each
nonoverlapping
substring
of
$input
that
matches
the
given
$pattern
with
an
occurrence
of
the
$replacement
string.
If
two
overlapping
substrings
of
$input
both
match
the
$pattern
,
then
only
the
first
one
(that
is,
the
one
whose
first
character
comes
first
in
the
$input
string)
is
replaced.
Within
If
the
q
flag
is
present,
the
replacement
string
is
used
as
is
.
Otherwise,
within
the
$replacement
string,
a
variable
$N
may
be
used
to
refer
to
the
substring
captured
by
the
Nth
parenthesized
subexpression
in
the
regular
expression.
For
each
match
of
the
pattern,
these
variables
are
assigned
the
value
of
the
content
matched
by
the
relevant
subexpression,
and
the
modified
replacement
string
is
then
substituted
for
the
characters
in
$input
that
matched
the
pattern.
$0
refers
to
the
substring
captured
by
the
regular
expression
as
a
whole.
More
specifically,
the
rules
are
as
follows,
where
S
is
the
number
of
parenthesized
subexpressions
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
subexpression.
If
the
Nth
parenthesized
subexpression
was
not
matched,
then
the
variable
is
replaced
by
the
zerolength
string.
If
S
<
N
<=
9
,
then
the
variable
is
replaced
by
the
zerolength
string.
Otherwise
(if
N
>
S
and
N
>
9
),
the
last
digit
of
N
is
taken
to
be
a
literal
character
to
be
included
"as
is"
in
the
replacement
string,
and
the
rules
are
reapplied
using
the
number
N
formed
by
stripping
off
this
last
digit.
For
example,
if
the
replacement
string
is
"
$23
"
and
there
are
5
substrings,
the
result
contains
the
value
of
the
substring
that
matches
the
second
subexpression,
followed
by
the
digit
"
3
".
A
Unless
the
q
flag
is
used,
a
literal
"
$
"
symbol
character
within
the
replacement
string
must
be
written
as
"
\$
,
and
a
literal
".
A
"
\
"
symbol
character
must
be
written
as
"
\\
.
".
If
two
alternatives
within
the
pattern
both
match
at
the
same
position
in
the
$input
,
then
the
match
that
is
chosen
is
the
one
matched
by
the
first
alternative.
For
example:
fn:replace("abcd", "(ab)(a)", "[1=$1][2=$2]") returns "[1=ab][2=]cd"
An
error
is
raised
[
err:FORX0002
]
if
the
value
of
$pattern
is
invalid
according
to
the
rules
described
in
section
7.6.1
5.6.1
Regular
Expression
Syntax
.
An
error
is
raised
[
err:FORX0001
]
if
the
value
of
$flags
is
invalid
according
to
the
rules
described
in
section
7.6.1
5.6.1
Regular
Expression
Syntax
.
An
error
is
raised
[
err:FORX0003
]
if
the
pattern
matches
a
zerolength
string,
that
is,
if
the
expression
fn:matches("",
$pattern,
$flags)
returns
true
.
It
is
not
an
error,
however,
if
a
captured
substring
is
zerolength.
An
error
is
raised
[
err:FORX0004
]
if
the
value
of
$replacement
contains
a
"
$
"
character
that
is
not
immediately
followed
by
a
digit
09
and
not
immediately
preceded
by
a
"\".
An
error
is
raised
[
err:FORX0004
]
if
the
value
of
$replacement
contains
a
"
\
"
character
that
is
not
part
of
a
"
\\
"
pair,
unless
it
is
immediately
followed
by
a
"
$
"
character.
The
expression
replace("abracadabra",
"bra",
"*")
returns
"a*cada*"
.
The
expression
replace("abracadabra",
"a.*a",
"*")
returns
"*"
.
The
expression
replace("abracadabra",
"a.*?a",
"*")
returns
"*c*bra"
.
The
expression
replace("abracadabra",
"a",
"")
returns
"brcdbr"
.
The
expression
replace("abracadabra",
"a(.)",
"a$1$1")
returns
"abbraccaddabbra"
.
The
expression
replace("abracadabra",
".*?",
"$1")
raises
an
error,
because
the
pattern
matches
the
zerolength
string
The
expression
replace("AAAA",
"A+",
"b")
returns
"
.
b
"
"b"
The
expression
replace("AAAA",
"A+?",
"b")
returns
"
.
bbbb
"
"bbbb"
The
expression
replace("darted",
"^(.*?)d(.*)$",
"$1c$2")
returns
"
.
(The
first
carted
".
The
"carted"
"
d
"
is
replaced.
replaced.).
Returns a sequence of strings constructed by splitting the input wherever a separator is found; the separator is any substring that matches a given regular expression.
fn:tokenize
(
$input
as
xs:string?
,
$pattern
as
xs:string
)
as
xs:string*
fn:tokenize
(

$input

as
xs:string?
,

$pattern

as
xs:string
,


$flags

as
xs:string
)
as
xs:string*

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
zerolength
string.
Flags
are
defined
in
7.6.1.1
5.6.1.1
Flags
.
The
$flags
argument
is
interpreted
in
the
same
way
as
for
the
function.
fn:matches()
fn:matches
If
$input
is
the
empty
sequence,
or
if
$input
is
the
zerolength
string,
the
result
is
function
returns
the
empty
sequence.
If
The
function
returns
a
sequence
of
strings
formed
by
breaking
the
supplied
$pattern
$input
matches
string
into
a
zerolength
string,
sequence
of
strings,
treating
any
substring
that
is,
if
matches
fn:matches("",
$pattern,
$flags)
$pattern
returns
true
,
then
an
error
is
raised:
[
err:FORX0003
].
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
zerolength
string.
Zerolength
strings
will
also
occur
in
the
result
sequence
if
a
separator
occurs
at
the
end
of
the
$input
string,
or
if
two
adjacent
substrings
match
the
supplied
$pattern
.
If
two
alternatives
within
the
supplied
$pattern
both
match
at
the
same
position
in
the
$input
string,
then
the
match
that
is
chosen
is
the
first.
For
example:
fn:tokenize("abracadabra", "(ab)(a)") returns ("", "r", "c", "d", "r", "")
An
error
is
raised
[
err:FORX0002
]
if
the
value
of
$pattern
is
invalid
according
to
the
rules
described
in
section
7.6.1
5.6.1
Regular
Expression
Syntax
.
An
error
is
raised
[
err:FORX0001
]
if
the
value
of
$flags
is
invalid
according
to
the
rules
described
in
section
7.6.1
5.6.1
Regular
Expression
Syntax
.
If
the
supplied
$pattern
matches
a
zerolength
string,
that
is,
if
fn:matches("",
$pattern,
$flags)
7.6.4.1
returns
true
,
then
an
error
is
raised:
[
err:FORX0003
].
The
expression
fn:tokenize("The
cat
sat
on
the
mat",
"\s+")
returns
("The",
"cat",
"sat",
"on",
"the",
"mat")
.
The
expression
fn:tokenize("1,
15,
24,
50",
",\s*")
returns
("1",
"15",
"24",
"50")
.
The
expression
fn:tokenize("1,15,,24,50,",
",")
returns
("1",
"15",
"",
"24",
"50",
"")
.
fn:tokenize("abba",
".?")
raises
the
error
[
err:FORX0003
].
The
expression
fn:tokenize("Some
unparsed
<br>
HTML
<BR>
text",
"\s*<br>\s*",
"i")
returns
("Some
unparsed",
"HTML",
"text")
.
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.
fn:analyzestring
(

$input

as
xs:string?
, 
$pattern

as
xs:string
)
as
element(fn:analyzestringresult)

fn:analyzestring
(

$input

as
xs:string?
, 
$pattern

as
xs:string
,  
$flags

as
xs:string
)
as
element(fn:analyzestringresult)

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
zerolength
string.
Flags
are
defined
in
5.6.1.1
Flags
.
The
$flags
argument
is
interpreted
in
the
same
way
as
for
the
fn:matches
function.
If
$input
is
the
empty
sequence
the
function
behaves
as
if
$input
were
the
zerolength
string.
In
this
situation
the
result
will
be
an
element
node
with
no
children.
The
function
returns
an
element
node
whose
local
name
is
analyzestringresult
.
This
element
and
all
its
descendant
elements
have
the
namespace
URI
http://www.w3.org/2005/xpathfunctions
.
The
namespace
prefix
is
·
implementation
dependent
·
.
The
children
of
this
element
are
a
sequence
of
fn:match
and
fn:nonmatch
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
nonmatch
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
jumpjumps
,
then
the
match
that
is
chosen
is
jump
.
Having found the first match, the instruction proceeds to find the second and subsequent matches by repeating the search, starting at the first character that was not included in the previous match.
The
input
string
is
thus
partitioned
into
a
sequence
of
substrings,
some
of
which
match
the
regular
expression,
others
which
do
not
match
it.
Each
substring
will
contain
at
least
one
character.
This
sequence
is
represented
in
the
result
by
the
sequence
of
fn:match
and
fn:nonmatch
children
of
the
returned
element
node;
the
string
value
of
the
fn:match
or
fn:nonmatch
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:nonmatch
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
subexpression
in
the
regular
expression.
For
each
capturing
subexpression
there
will
be
at
most
one
corresponding
fn:group
element
in
each
fn:match
element
in
the
result.
If the function is called twice with the same arguments, it is · implementation dependent · whether the two calls return the same element node or distinct (but deep equal) element nodes.
A
schema
is
defined
for
the
structure
of
the
returned
element,
containing
the
definitions
below.
The
returned
element
and
its
descendants
will
have
type
annotations
obtained
by
validating
the
returned
element
against
this
schema,
unless
the
function
is
used
in
an
environment
where
type
annotations
are
not
supported
(for
example,
a
Basic
XSLT
Processor),
in
which
case
the
elements
will
all
be
annotated
as
xs:untyped
and
the
attributes
as
xs:untypedAtomic
.
<?xml version="1.0" encoding="UTF8"?> <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" targetNamespace="http://www.w3.org/2005/xpathfunctions" xmlns:fn="http://www.w3.org/2005/xpathfunctions" elementFormDefault="qualified"> <xs:element name="analyzestringresult" type="fn:analyzestringresulttype"/> <xs:element name="match" type="fn:matchtype"/> <xs:element name="nonmatch" type="xs:string"/> <xs:element name="group" type="fn:grouptype"/> <xs:complexType name="analyzestringresulttype" mixed="true"> <xs:choice minOccurs="0" maxOccurs="unbounded"> <xs:element ref="fn:match"/> <xs:element ref="fn:nonmatch"/> </xs:choice> </xs:complexType> <xs:complexType name="matchtype" mixed="true"> <xs:sequence> <xs:element ref="fn:group" minOccurs="0" maxOccurs="unbounded"/> </xs:sequence> </xs:complexType> <xs:complexType name="grouptype" mixed="true"> <xs:sequence> <xs:element ref="fn:group" minOccurs="0" maxOccurs="unbounded"/> </xs:sequence> <xs:attribute name="nr" type="xs:positiveInteger"/> </xs:complexType> </xs:schema>
An
error
is
raised
[
err:FORX0002
]
if
the
value
of
$pattern
is
invalid
according
to
the
rules
described
in
section
5.6.1
Regular
Expression
Syntax
.
An
error
is
raised
[
err:FORX0001
]
if
the
value
of
$flags
is
invalid
according
to
the
rules
described
in
section
5.6.1
Regular
Expression
Syntax
.
If
the
supplied
$pattern
matches
a
zerolength
string,
that
is,
if
fn:matches("",
$pattern,
$flags)
returns
true
,
then
an
error
is
raised:
[
err:FORX0003
].
In the following examples, the result document is shown in serialized form, with whitespace between the element nodes. This whitespace is not actually present in the result.
The
expression
fn:analyzestring("The
cat
sat
on
the
mat.",
"\w+")
returns
<analyzestringresult
xmlns="http://www.w3.org/2005/xpathfunctions">
<match>The</match>
<nonmatch>
</nonmatch>
<match>cat</match>
<nonmatch>
</nonmatch>
<match>sat</match>
<nonmatch>
</nonmatch>
<match>on</match>
<nonmatch>
</nonmatch>
<match>the</match>
<nonmatch>
</nonmatch>
<match>mat</match>
<nonmatch>.</nonmatch>
</analyzestringresult>
.
The
expression
fn:analyzestring("20081203",
"^(\d+)\(\d+)\(\d+)$")
returns
<analyzestringresult
xmlns="http://www.w3.org/2005/xpathfunctions">
<match><group
nr="1">2008</group><group
nr="2">12</group><group
nr="3">03</group></match>
</analyzestringresult>
.
The
expression
fn:analyzestring("A1,C15,,D24,
X50,",
"([AZ])([09]+)")
returns
<analyzestringresult
xmlns="http://www.w3.org/2005/xpathfunctions">
<match><group
nr="1">A</group><group
nr="2">1</group></match>
<nonmatch>,</nonmatch>
<match><group
nr="1">C</group><group
nr="2">15</group></match>
<nonmatch>,,</nonmatch>
<match><group
nr="1">D</group><group
nr="2">24</group></match>
<nonmatch>,
</nonmatch>
<match><group
nr="1">X</group><group
nr="2">50</group></match>
<nonmatch>,</nonmatch>
</analyzestringresult>
.
This
section
specifies
functions
that
take
anyURI
manipulate
URI
values,
either
as
arguments.
instances
of
xs:anyURI
or
as
strings.
Function  Meaning 

fn:resolveuri



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

Converts
a
string
containing
an
IRI
into
a

fn:escapehtmluri

Escapes
a

Resolves a relative URI reference against an absolute URI.
fn:resolveuri
(
$relative
as
xs:string?
)
as
xs:anyURI?
fn:resolveuri
(
$relative
as
xs:string?
,
$base
as
xs:string
)
as
xs:anyURI?
Summary:
The
purpose
of
this
function
If
$relative
is
to
enable
a
relative
URI
to
be
resolved
against
an
absolute
URI.
the
empty
sequence,
the
function
returns
the
empty
sequence.
The
first
form
of
this
function
resolves
$relative
against
the
value
of
the
baseuri
property
from
the
static
context.
If
the
baseuri
property
is
not
initialized
in
the
static
context
an
error
is
raised
[
err:FONS0005
].
If
$relative
is
a
relative
URI
reference,
it
is
resolved
against
$base
,
or
against
the
baseuri
property
from
the
static
context,
using
an
algorithm
such
as
the
ones
those
described
in
[RFC
2396]
or
[RFC
3986]
,
and
the
resulting
absolute
URI
reference
is
returned.
An
error
may
be
raised
[
err:FORG0009
]
in
the
resolution
process.
If
$relative
is
an
absolute
URI
reference,
it
is
returned
unchanged.
If
The
first
form
of
this
function
resolves
$relative
or
against
the
value
of
the
baseuri
property
from
the
static
context.
If
the
baseuri
property
is
not
initialized
in
the
static
context
an
error
is
raised
[
err:FONS0005
].
If
is
not
a
valid
URI
according
to
the
rules
of
the
$base
$relative
xs:anyURI
data
type,
or
if
it
is
not
a
suitable
relative
reference
to
use
as
input
to
the
chosen
resolution
algorithm,
then
an
error
is
raised
[
err:FORG0002
].
If
is
not
a
valid
URI
according
to
the
$relative
$base
empty
sequence,
rules
of
the
empty
sequence
xs:anyURI
data
type,
if
it
is
returned.
not
a
suitable
URI
to
use
as
input
to
the
chosen
resolution
algorithm
(for
example,
if
it
is
a
relative
URI
reference,
if
it
is
a
nonhierarchic
URI,
or
if
it
contains
a
fragment
identifier),
then
an
error
is
raised
[
err:FORG0002
].
Note:
If
the
chosen
resolution
algorithm
fails
for
any
other
reason
then
an
error
is
raised
[
err:FORG0009
].
Resolving a URI does not dereference it. This is merely a syntactic operation on two character strings.
The algorithms in the cited RFCs include some variations that are optional or recommended rather than mandatory; they also describe some common practices that are not recommended, but which are permitted for backwards compatibility. Where the cited RFCs permit variations in behavior, so does this specification.
Encodes reserved characters in a string that is intended to be used in the path segment of a URI.
fn:encodeforuri
(
$uripart
as
xs:string?
)
as
xs:string
If
$uripart
is
the
empty
sequence,
the
function
returns
the
zerolength
string.
This
function
applies
the
URI
escaping
rules
defined
in
section
2
of
[RFC
3986]
to
the
xs:string
supplied
as
$uripart
.
The
effect
of
the
function
is
to
escape
reserved
characters.
Each
such
character
in
the
string
is
replaced
with
its
percentencoded
form
as
described
in
[RFC
3986]
.
Since [RFC 3986] recommends that, for consistency, URI producers and normalizers should use uppercase hexadecimal digits for all percentencodings, this function must always generate hexadecimal values using the uppercase letters AF.
All characters are escaped except those identified as "unreserved" by [RFC 3986] , that is the upper and lowercase letters AZ, the digits 09, HYPHENMINUS (""), LOW LINE ("_"), FULL STOP ".", and TILDE "~".
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
.
The
expression
fn:encodeforuri("http://www.example.com/00/Weather/CA/Los%20Angeles#ocean")
returns
"http%3A%2F%2Fwww.example.com%2F00%2FWeather%2FCA%2FLos%2520Angeles%23ocean"
.
(This
is
probably
not
what
the
user
intended
because
all
of
the
delimiters
have
been
encoded.).
The
expression
concat("http://www.example.com/",
encodeforuri("~bébé"))
returns
"http://www.example.com/~b%C3%A9b%C3%A9"
.
The
expression
concat("http://www.example.com/",
encodeforuri("100%
organic"))
returns
"http://www.example.com/100%25%20organic"
.
Converts a string containing an IRI into a URI according to the rules of [RFC 3987] .
fn:iritouri
(
$iri
as
xs:string?
)
as
xs:string
If
$iri
is
the
empty
sequence,
the
function
returns
the
zerolength
string.
Otherwise,
the
function
converts
the
value
of
$iri
into
a
URI
according
to
the
rules
given
in
Section
3.1
of
[RFC
3987]
by
percentencoding
characters
that
are
allowed
in
an
IRI
but
not
in
a
URI.
If
$iri
contains
a
character
that
is
invalid
in
an
IRI,
such
as
the
space
character
(see
note
below),
the
invalid
character
is
replaced
by
its
percentencoded
form
as
described
in
[RFC
3986]
before
the
conversion
is
performed.
Since [RFC 3986] recommends that, for consistency, URI producers and normalizers should use uppercase hexadecimal digits for all percentencodings, this function must always generate hexadecimal values using the uppercase letters AF.
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
legal
IRI.
It
treats
it
as
an
xs:string
and
operates
on
the
characters
in
the
xs:string
.
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
percentencoded.
In
addition,
characters
outside
the
range
x20
x7E
will
be
percentencoded
because
they
are
invalid
in
a
URI.
Since this function does not escape the PERCENT SIGN "%" and this character is not allowed in data within a URI, users wishing to convert character strings (such as file names) that include "%" to a URI should manually escape "%" by replacing it with "%25".
The
expression
fn:iritouri
("http://www.example.com/00/Weather/CA/Los%20Angeles#ocean")
returns
"http://www.example.com/00/Weather/CA/Los%20Angeles#ocean"
.
The
expression
fn:iritouri
("http://www.example.com/~bébé")
returns
"http://www.example.com/~b%C3%A9b%C3%A9"
.
Escapes a URI in the same way that HTML user agents handle attribute values expected to contain URIs.
fn:escapehtmluri
(
$uri
as
xs:string?
)
as
xs:string
If
$uri
is
the
empty
sequence,
the
function
returns
the
zerolength
string.
Otherwise,
the
function
escapes
all
characters
except
printable
characters
of
the
USASCII
coded
character
set,
specifically
the
codepoints
between
32
and
126
(decimal)
inclusive.
Each
character
in
$uri
to
be
escaped
is
replaced
by
an
escape
sequence,
which
is
formed
by
encoding
the
character
as
a
sequence
of
octets
in
UTF8,
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
uppercase
letters
AF.
The behavior of this function corresponds to the recommended handling of nonASCII characters in URI attribute values as described in [HTML 4.0] Appendix B.2.1.
The
expression
fn:escapehtmluri
("http://www.example.com/00/Weather/CA/Los
Angeles#ocean")
returns
"http://www.example.com/00/Weather/CA/Los
Angeles#ocean"
.
The
expression
fn:escapehtmluri
("javascript:if
(navigator.browserLanguage
==
'fr')
window.open('http://www.example.com/~bébé');")
returns
"javascript:if
(navigator.browserLanguage
==
'fr')
window.open('http://www.example.com/~b%C3%A9b%C3%A9');"
.
This
section
defines
functions
and
operators
on
the
[XML
Schema
Part
2:
Datatypes
Second
Edition]
boolean
xs:boolean
datatype.
The
following
additional
constructor
functions
Since
no
literals
are
defined
on
in
XPath
to
reference
the
constant
boolean
type.
values
true
and
false,
two
functions
are
provided
for
the
purpose.
Function  Meaning 

fn:true

xs:boolean
value
true
.

fn:false

xs:boolean
value
false
.

The following functions define the semantics of operators on boolean values in [XQuery 1.0: An XML Query Language] and [XML Path Language (XPath) 2.0] :

Meaning 

op:booleanequal


op:booleanlessthan


op:booleangreaterthan


The
ordering
operators
op:booleanlessthan
and
op:booleangreaterthan
are
provided
for
application
purposes
and
for
compatibility
with
[XML
Path
Language
(XPath)
Version
1.0]
.
The
[XML
Schema
Part
2:
Datatypes
Second
Edition]
datatype
xs:boolean
is
not
ordered.
Returns
true
if
the
two
arguments
are
the
same
boolean
value.
Defines
the
semantics
of
the
"eq"
operator
on
xs:boolean
values.
op:booleanequal
(
$value1
as
xs:boolean
,
$value2
as
xs:boolean
)
as
xs:boolean
Summary:
Returns
The
function
returns
true
if
both
arguments
are
true
or
if
both
arguments
are
false
.
Returns
It
returns
false
if
one
of
the
arguments
is
true
and
the
other
argument
is
false
.
Returns true if the first argument is false and the second is true.
Defines
the
semantics
of
the
"lt"
operator
on
xs:boolean
values.
Also
used
in
the
definition
of
the
"ge"
operator.
op:booleanlessthan
(
$arg1
as
xs:boolean
,
$arg2
as
xs:boolean
)
as
xs:boolean
Summary:
Returns
The
function
returns
true
if
$arg1
is
false
and
$arg2
is
true
.
Otherwise,
it
returns
false
.
Returns true if the first argument is true and the second is false.
Defines
the
semantics
of
the
"gt"
operator
on
xs:boolean
values.
Also
used
in
the
definition
of
the
"le"
operator.
op:booleangreaterthan
(
$arg1
as
xs:boolean
,
$arg2
as
xs:boolean
)
as
xs:boolean
Summary:
Returns
true
if
$arg1
is
true
and
The
function
call
is
$arg2
op:booleangreaterthan($A,
$B)
false
.
Otherwise,
returns
false
.
This
function
backs
up
defined
to
return
the
"gt"
and
"le"
operators
on
same
result
as
xs:boolean
op:booleanlessthan($B,
$A)
values.
The following functions are defined on boolean values:
Function  Meaning 

fn:boolean

Computes
the
effective
boolean
value
of
the
sequence
$arg
. 
fn:not

if
the
effective
boolean
value
of
$arg
is
false
,
or
false
if
it
is
true
.

Computes
the
effective
boolean
value
of
the
sequence
$arg
.
fn:boolean
(
$arg
as
item()*
)
as
xs:boolean
The function computes the effective boolean value of a sequence, defined according to the following rules. See also Section 2.4.3 Effective Boolean Value ^{ XP }.
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
[
err:FORG0006
].
The static semantics of this function are described in Section 7.2.4 The fn:boolean function ^{ FS }.
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
[
err:FORG0006
].
The
expression
fn:boolean($abc[1])
returns
true()
.
The
expression
fn:boolean($abc[0])
returns
false()
.
The
expression
fn:boolean($abc[3])
returns
false()
.
Returns
true
if
the
effective
boolean
value
of
$arg
is
false
,
or
false
if
it
is
true
.
fn:not
(
$arg
as
item()*
)
as
xs:boolean
Summary:
The
value
of
$arg
is
first
reduced
to
an
effective
boolean
value
by
applying
the
fn:boolean()
function.
Returns
The
function
returns
true
if
the
effective
boolean
value
is
false
,
and
or
false
if
the
effective
boolean
value
is
true
.
The
expression
fn:not(fn:true())
returns
.
false
false()
The
expression
fn:not("false")
returns
.
false
false()
This
section
discusses
operations
on
the
[XML
Schema
Part
2:
Datatypes
Second
Edition]
date
and
time
types.
It
also
discusses
operations
on
two
subtypes
of
xs:duration
that
are
defined
in
Section
2.6
Types
DM
.
See
10.3
Two
Totally
Ordered
Subtypes
of
Duration
.
See
[Working
With
Timezones]
for
a
disquisition
on
working
with
date
and
time
values
with
and
without
timezones.
10.1
Duration,
Date
and
Time
Types
The
operators
described
in
this
section
Operators
are
defined
on
the
following
date
and
time
types:
xs:dateTime
xs:date
xs:time
xs:gYearMonth
xs:gYear
xs:gMonthDay
xs:gMonth
xs:gDay
Note
that
only
equality
is
defined
on
xs:gYearMonth
,
xs:gYear
,
xs:gMonthDay
,
xs:gMonth
and
xs:gDay
values.
In
addition,
operators
are
defined
on:
type:
xs:duration
and
on
the
two
defined
subtypes
(see
10.3
8.2
Two
Totally
Ordered
Subtypes
of
Duration
:
):
xs:yearMonthDuration
xs:dayTimeDuration
Note
that
no
No
ordering
relation
is
defined
on
xs:duration
values.Two
values.
Two
xs:duration
values
may
however
be
compared
for
equality.
Operations on durations (including equality comparison, casting to string, and extraction of components) all treat the duration as normalized. This means that the seconds and minutes components will always be less than 60, the hours component less than 24, and the months component less than 12. Thus, for example, a duration of 120 seconds always gives the same result as a duration of two minutes.
Note:
10.1.1
Limits
and
Precision
For
a
number
of
the
above
datatypes
[XML
Schema
Part
2:
Datatypes
Second
Edition]
extends
This
means
that
in
practice,
the
basic
[ISO
8601]
lexical
representations,
such
as
YYYYMMDDThh:mm:ss.s
for
dateTime,
by
allowing
a
preceding
minus
sign,
more
than
four
digits
information
content
of
an
xs:duration
value
can
be
reduced
to
represent
the
year
field
—
no
maximum
is
specified
—
an
xs:integer
number
of
months,
and
an
unlimited
xs:decimal
number
of
digits
for
fractional
seconds.
Leap
seconds
are
not
supported.
All
minimally
conforming
processors
·
must
·
support
positive
year
values
with
a
minimum
For
the
two
defined
subtypes
this
is
further
simplified
so
that
one
of
4
digits
(i.e.,
YYYY)
and
a
minimum
fractional
second
precision
these
two
components
is
fixed
at
zero.
Operations
such
as
comparison
of
1
millisecond
or
three
digits
(i.e.,
s.sss).
However,
conforming
processors
·
may
·
set
larger
·
implementationdefined
·
limits
durations
and
arithmetic
on
the
maximum
number
of
digits
they
support
durations
can
be
expressed
in
terms
of
numeric
operations
applied
to
these
two
situations.
Processors
components.


This section needs revision  it comes from the old text describing both duration and date/time operations, but it's not clear exactly what it should say for durations. 
A
processor
that
limits
the
number
of
digits
in
date
and
time
datatype
representations
may
encounter
overflow
and
underflow
conditions
when
it
tries
to
execute
the
functions
in
10.8
9.7
Arithmetic
Operators
on
Durations,
Dates
and
Times
.
In
these
situations,
the
processor
·
must
·
return
P0M
or
PT0S
in
case
of
duration
underflow
and
00:00:00
in
case
of
time
underflow.
It
·
must
·
raise
an
error
[
err:FODT0001
]
in
case
of
overflow.
The
value
spaces
of
the
two
totally
ordered
subtypes
of
xs:duration
described
in
10.3
8.2
Two
Totally
Ordered
Subtypes
of
Duration
are
xs:integer
months
for
xs:yearMonthDuration
and
xs:decimal
seconds
for
xs:dayTimeDuration
.
If
a
processor
limits
the
number
of
digits
allowed
in
the
representation
of
xs:integer
and
xs:decimal
then
overflow
and
underflow
situations
can
arise
when
it
tries
to
execute
the
functions
in
10.6
8.5
Arithmetic
Operators
on
Durations
.
In
these
situations
the
processor
·
must
·
return
zero
in
case
of
numeric
underflow
and
P0M
or
PT0S
in
case
of
duration
underflow.
It
·
must
·
raise
an
error
[
err:FODT0002
]
in
case
of
overflow.
Two
totally
ordered
subtypes
of
xs:duration
are
defined
in
Section
2.6
Types
^{
DM
}
specification
using
the
mechanisms
described
in
[XML
Schema
Part
2:
Datatypes
Second
Edition]
for
defining
userdefined
types.
Additional
details
about
these
types
is
given
below.
Note:
These types were not defined in XSD 1.0, but they are defined in the current draft of XSD 1.1. The description given here is believed to be equivalent to that in XSD 1.1, and will become nonnormative when XSD 1.1 reaches Recommendation status.
[Definition]
xs:yearMonthDuration
is
derived
from
xs:duration
by
restricting
its
lexical
representation
to
contain
only
the
year
and
month
components.
The
value
space
of
xs:yearMonthDuration
is
the
set
of
xs:integer
month
values.
The
year
and
month
components
of
xs:yearMonthDuration
correspond
to
the
Gregorian
year
and
month
components
defined
in
section
5.5.3.2
of
[ISO
8601]
,
respectively.
The
lexical
representation
for
xs:yearMonthDuration
is
the
[ISO
8601]
reduced
format
PnYnM,
where
nY
represents
the
number
of
years
and
nM
the
number
of
months.
The
values
of
the
years
and
months
components
are
not
restricted
but
allow
an
arbitrary
unsigned
xs:integer
.
An
optional
preceding
minus
sign
('')
is
allowed
to
indicate
a
negative
duration.
If
the
sign
is
omitted
a
positive
duration
is
indicated.
To
indicate
a
xs:yearMonthDuration
of
1
year,
2
months,
one
would
write:
P1Y2M.
One
could
also
indicate
a
xs:yearMonthDuration
of
minus
13
months
as:
P13M.
Reduced precision and truncated representations of this format are allowed provided they conform to the following:
If the number of years or months in any expression equals zero (0), the number and its corresponding designator · may · be omitted. However, at least one number and its designator · must · be present. For example, P1347Y and P1347M are allowed; P1347M is not allowed, although P1347M is allowed. P1Y2MT is not allowed. Also, P24YM is not allowed, nor is PY43M since Y must have at least one preceding digit and M must have one preceding digit.
The
value
of
a
xs:yearMonthDuration
lexical
form
is
obtained
by
multiplying
the
value
of
the
years
component
by
12
and
adding
the
value
of
the
months
component.
The
value
is
positive
or
negative
depending
on
the
preceding
sign.
The
canonical
representation
of
xs:yearMonthDuration
restricts
the
value
of
the
months
component
to
xs:integer
values
between
0
and
11,
both
inclusive.
To
convert
from
a
noncanonical
representation
to
the
canonical
representation,
the
lexical
representation
is
first
converted
to
a
value
in
xs:integer
months
as
defined
above.
This
value
is
then
divided
by
12
to
obtain
the
value
of
the
years
component
of
the
canonical
representation.
The
remaining
number
of
months
is
the
value
of
the
months
component
of
the
canonical
representation.
For
negative
durations,
the
canonical
form
is
calculated
using
the
absolute
value
of
the
duration
and
a
negative
sign
is
prepended
to
it.
If
a
component
has
the
value
zero
(0),
then
the
number
and
the
designator
for
that
component
·
must
·
be
omitted.
However,
if
the
value
is
zero
(0)
months,
the
canonical
form
is
"P0M".
Let
the
function
that
calculates
the
value
of
an
xs:yearMonthDuration
in
the
manner
described
above
be
called
V(d).
Then
for
two
xs:yearMonthDuration
values
x
and
y,
x
>
y
if
and
only
if
V(x)
>
V(y).
The
order
relation
on
yearMonthDuration
is
a
total
order.
[Definition]
xs:dayTimeDuration
is
derived
from
xs:duration
by
restricting
its
lexical
representation
to
contain
only
the
days,
hours,
minutes
and
seconds
components.
The
value
space
of
xs:dayTimeDuration
is
the
set
of
fractional
second
values.
The
components
of
xs:dayTimeDuration
correspond
to
the
day,
hour,
minute
and
second
components
defined
in
Section
5.5.3.2
of
[ISO
8601]
,
respectively.
The
lexical
representation
for
xs:dayTimeDuration
is
the
[ISO
8601]
truncated
format
PnDTnHnMnS,
where
nD
represents
the
number
of
days,
T
is
the
date/time
separator,
nH
the
number
of
hours,
nM
the
number
of
minutes
and
nS
the
number
of
seconds.
The
values
of
the
days,
hours
and
minutes
components
are
not
restricted,
but
allow
an
arbitrary
unsigned
xs:integer
.
Similarly,
the
value
of
the
seconds
component
allows
an
arbitrary
unsigned
xs:decimal
.
An
optional
minus
sign
('')
is
allowed
to
precede
the
'P',
indicating
a
negative
duration.
If
the
sign
is
omitted,
the
duration
is
positive.
See
also
[ISO
8601]
Date
and
Time
Formats.
For example, to indicate a duration of 3 days, 10 hours and 30 minutes, one would write: P3DT10H30M. One could also indicate a duration of minus 120 days as: P120D. Reduced precision and truncated representations of this format are allowed, provided they conform to the following:
If the number of days, hours, minutes, or seconds in any expression equals zero (0), the number and its corresponding designator · may · be omitted. However, at least one number and its designator · must · be present.
The seconds part · may · have a decimal fraction.
The designator 'T' · must · be absent if and only if all of the time items are absent. The designator 'P' · must · always be present.
For example, P13D, PT47H, P3DT2H, PT35.89S and P4DT251M are all allowed. P134D is not allowed (invalid location of minus sign), although P134D is allowed.
The
value
of
a
xs:dayTimeDuration
lexical
form
in
fractional
seconds
is
obtained
by
converting
the
days,
hours,
minutes
and
seconds
value
to
fractional
seconds
using
the
conversion
rules:
24
hours
=
1
day,
60
minutes
=
1
hour
and
60
seconds
=
1
minute.
The
canonical
representation
of
xs:dayTimeDuration
restricts
the
value
of
the
hours
component
to
xs:integer
values
between
0
and
23,
both
inclusive;
the
value
of
the
minutes
component
to
xs:integer
values
between
0
and
59;
both
inclusive;
and
the
value
of
the
seconds
component
to
xs:decimal
valued
from
0.0
to
59.999...
(see
[XML
Schema
Part
2:
Datatypes
Second
Edition]
,
Appendix
D).
To convert from a noncanonical representation to the canonical representation, the value of the lexical form in fractional seconds is first calculated in the manner described above. The value of the days component in the canonical form is then calculated by dividing the value by 86,400 (24*60*60). The remainder is in fractional seconds. The value of the hours component in the canonical form is calculated by dividing this remainder by 3,600 (60*60). The remainder is again in fractional seconds. The value of the minutes component in the canonical form is calculated by dividing this remainder by 60. The remainder in fractional seconds is the value of the seconds component in the canonical form. For negative durations, the canonical form is calculated using the absolute value of the duration and a negative sign is prepended to it. If a component has the value zero (0) then the number and the designator for that component must be omitted. However, if all the components of the lexical form are zero (0), the canonical form is "PT0S".
Let
the
function
that
calculates
the
value
of
a
xs:dayTimeDuration
in
the
manner
described
above
be
called
V(d)
.
Then
for
two
xs:dayTimeDuration
values
x
and
y,
x
>
y
if
and
only
if
V(x)
>
V(y)
.
The
order
relation
on
xs:dayTimeDuration
is
a
total
order.

Meaning 

op:yearMonthDurationlessthan

$arg2
.

op:yearMonthDurationgreaterthan

$arg2
.

op:dayTimeDurationlessthan

$arg2
.

op:dayTimeDurationgreaterthan

$arg2
.

op:durationequal

$arg1
and
$arg2
are
durations
of
the
same
length.

The
following
comparison
operators
are
defined
on
the
[XML
Schema
Part
2:
Datatypes
Second
Edition]
duration
datatypes.
Each
operator
takes
two
operands
of
the
same
type
and
returns
an
xs:boolean
result.
As
discussed
in
[XML
Schema
Part
2:
Datatypes
Second
Edition]
,
the
order
relation
on
xs:duration
is
not
a
total
order
but,
rather,
a
partial
order.
For
this
reason,
only
equality
is
defined
on
xs:duration
.
A
full
complement
of
comparison
and
arithmetic
functions
are
defined
on
the
two
subtypes
of
duration
described
in
8.2
Two
Totally
Ordered
Subtypes
of
Duration
which
do
have
a
total
order.
Returns
true
if
$arg1
is
a
shorter
duration
than
$arg2
.
Defines
the
semantics
of
the
"lt"
operator
on
xs:yearMonthDuration
values.
Also
used
in
the
definition
of
the
"ge"
operator.
op:yearMonthDurationlessthan
(

$arg1

as
xs:yearMonthDuration
, 
$arg2

as
xs:yearMonthDuration
)
as
xs:boolean

If
the
number
of
months
in
the
value
of
$arg1
is
numerically
less
than
the
number
of
months
in
the
value
of
$arg2
,
the
function
returns
true.
Otherwise, the function returns false.
Either or both durations may be negative
Returns
true
if
$arg1
is
a
longer
duration
than
$arg2
.
Defines
the
semantics
of
the
"gt"
operator
on
xs:yearMonthDuration
values.
Also
used
in
the
definition
of
the
"le"
operator.
op:yearMonthDurationgreaterthan
(

$arg1

as
xs:yearMonthDuration
, 
$arg2

as
xs:yearMonthDuration
)
as
xs:boolean

The
function
call
op:yearMonthDurationgreaterthan($A,
$B)
is
defined
to
return
the
same
result
as
op:yearMonthDurationlessthan($B,
$A)
Returns
true
if
$arg1
is
a
shorter
duration
than
$arg2
.
Defines
the
semantics
of
the
"lt"
operator
on
xs:dayTimeDuration
values.
Also
used
in
the
definition
of
the
"ge"
operator.
op:dayTimeDurationlessthan
(

$arg1

as
xs:dayTimeDuration
, 
$arg2

as
xs:dayTimeDuration
)
as
xs:boolean

If
the
number
of
seconds
in
the
value
of
$arg1
is
numerically
less
than
the
number
of
seconds
in
the
value
of
$arg2
,
the
function
returns
true.
Otherwise, the function returns false.
Either or both durations may be negative
Returns
true
if
$arg1
is
a
longer
duration
than
$arg2
.
Defines
the
semantics
of
the
"gt"
operator
on
xs:dayTimeDuration
values.
Also
used
in
the
definition
of
the
"le"
operator.
op:dayTimeDurationgreaterthan
(

$arg1

as
xs:dayTimeDuration
, 
$arg2

as
xs:dayTimeDuration
)
as
xs:boolean

The
function
call
op:dayTimeDurationgreaterthan($A,
$B)
is
defined
to
return
the
same
result
as
op:dayTimeDurationlessthan($B,
$A)
Returns
true
if
$arg1
and
$arg2
are
durations
of
the
same
length.
Defines
the
semantics
of
the
"eq"
operators
on
xs:duration
values.
Also
used
in
the
definition
of
the
"ne"
operator.
op:durationequal
(
$arg1
as
xs:duration
,
$arg2
as
xs:duration
)
as
xs:boolean
If
the
xs:yearMonthDuration
components
of
$arg1
and
$arg2
are
equal
and
the
xs:dayTimeDuration
components
of
$arg1
and
$arg2
are
equal,
the
function
returns
true
.
Otherwise, the function returns false.
The semantics of this function are:
xs:yearMonthDuration($arg1) div xs:yearMonthDuration('P1M') eq xs:yearMonthDuration($arg2) div xs:yearMonthDuration('P1M') and xs:dayTimeDuration($arg1) div xs:dayTimeDuration('PT1S') eq xs:dayTimeDuration($arg2) div xs:dayTimeDuration('PT1S')
that
is,
the
function
returns
true
if
the
months
and
seconds
values
of
the
two
durations
are
equal.
Note
that
this
function,
like
any
other,
may
be
applied
to
arguments
that
are
derived
from
the
types
given
in
the
function
signature,
including
the
two
subtypes
xs:dayTimeDuration
and
xs:yearMonthDuration
.
With
the
exception
of
the
zerolength
duration,
no
instance
of
xs:dayTimeDuration
can
ever
be
equal
to
an
instance
of
xs:yearMonthDuration
.
The
expression
op:durationequal(xs:duration("P1Y"),
xs:duration("P12M"))
returns
true()
.
The
expression
op:durationequal(xs:duration("PT24H"),
xs:duration("P1D"))
returns
true()
.
The
expression
op:durationequal(xs:duration("P1Y"),
xs:duration("P365D"))
returns
false()
.
The
expression
op:durationequal(xs:yearMonthDuration("P0Y"),
xs:dayTimeDuration("P0D"))
returns
true()
.
The
expression
op:durationequal(xs:yearMonthDuration("P1Y"),
xs:dayTimeDuration("P365D"))
returns
false()
.
The
expression
op:durationequal(xs:yearMonthDuration("P2Y"),
xs:yearMonthDuration("P24M"))
returns
true()
.
The
expression
op:durationequal(xs:dayTimeDuration("P10D"),
xs:dayTimeDuration("PT240H"))
returns
true()
.
The
expression
op:durationequal(xs:duration("P2Y0M0DT0H0M0S"),
xs:yearMonthDuration("P24M"))
returns
true()
.
The
expression
op:durationequal(xs:duration("P0Y0M10D"),
xs:dayTimeDuration("PT240H"))
returns
true()
.
The
duration
datatype
may
be
considered
to
be
a
composite
datatypes
in
that
it
contains
distinct
properties
or
components.
The
extraction
functions
specified
below
extract
a
single
component
from
a
duration
value.
For
xs:duration
and
its
subtypes,
including
the
two
subtypes
xs:yearMonthDuration
and
xs:dayTimeDuration
,
the
components
are
normalized:
this
means
that
the
seconds
and
minutes
components
will
always
be
less
than
60,
the
hours
component
less
than
24,
and
the
months
component
less
than
12.
Function  Meaning 

fn:yearsfromduration
 Returns the number of years in a duration. 


fn:daysfromduration
 Returns the number of days in a duration. 
fn:hoursfromduration
 Returns the number of hours in a duration. 
fn:minutesfromduration
 Returns the number of minutes in a duration. 
fn:secondsfromduration
 Returns the number of seconds in a duration. 
Returns the number of years in a duration.
fn:yearsfromduration
(
$arg
as
xs:duration?
)
as
xs:integer?
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
18.1.4
Casting
to
duration
types
)
and
then
computing
the
years
component
as
described
in
8.2.1.3
Canonical
representation
.
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:yearsfromduration(xs:yearMonthDuration("P20Y15M"))
returns
21
.
The
expression
fn:yearsfromduration(xs:yearMonthDuration("P15M"))
returns
1
.
The
expression
fn:yearsfromduration(xs:dayTimeDuration("P2DT15H"))
returns
0
.
Returns the number of months in a duration.
fn:monthsfromduration
(
$arg
as
xs:duration?
)
as
xs:integer?
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
18.1.4
Casting
to
duration
types
)
and
then
computing
the
months
component
as
described
in
8.2.1.3
Canonical
representation
.
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:monthsfromduration(xs:yearMonthDuration("P20Y15M"))
returns
3
.
The
expression
fn:monthsfromduration(xs:yearMonthDuration("P20Y18M"))
returns
6
.
The
expression
fn:monthsfromduration(xs:dayTimeDuration("P2DT15H0M0S"))
returns
0
.
Returns the number of days in a duration.
fn:daysfromduration
(
$arg
as
xs:duration?
)
as
xs:integer?
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
18.1.4
Casting
to
duration
types
)
and
then
computing
the
days
component
as
described
in
8.2.2.3
Canonical
representation
.
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:daysfromduration(xs:dayTimeDuration("P3DT10H"))
returns
3
.
The
expression
fn:daysfromduration(xs:dayTimeDuration("P3DT55H"))
returns
5
.
The
expression
fn:daysfromduration(xs:yearMonthDuration("P3Y5M"))
returns
0
.
Returns the number of hours in a duration.
fn:hoursfromduration
(
$arg
as
xs:duration?
)
as
xs:integer?
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
18.1.4
Casting
to
duration
types
)
and
then
computing
the
hours
component
as
described
in
8.2.2.3
Canonical
representation
.
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:hoursfromduration(xs:dayTimeDuration("P3DT10H"))
returns
10
.
The
expression
fn:hoursfromduration(xs:dayTimeDuration("P3DT12H32M12S"))
returns
12
.
The
expression
fn:hoursfromduration(xs:dayTimeDuration("PT123H"))
returns
3
.
The
expression
fn:hoursfromduration(xs:dayTimeDuration("P3DT10H"))
returns
10
.
Returns the number of minutes in a duration.
fn:minutesfromduration
(
$arg
as
xs:duration?
)
as
xs:integer?
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
18.1.4
Casting
to
duration
types
)
and
then
computing
the
minutes
component
as
described
in
8.2.2.3
Canonical
representation
.
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:minutesfromduration(xs:dayTimeDuration("P3DT10H"))
returns
0
.
The
expression
fn:minutesfromduration(xs:dayTimeDuration("P5DT12H30M"))
returns
30
.
Returns the number of seconds in a duration.
fn:secondsfromduration
(
$arg
as
xs:duration?
)
as
xs:decimal?
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
18.1.4
Casting
to
duration
types
)
and
then
computing
the
seconds
component
as
described
in
8.2.2.3
Canonical
representation
.
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:secondsfromduration(xs:dayTimeDuration("P3DT10H12.5S"))
returns
12.5
.
The
expression
fn:secondsfromduration(xs:dayTimeDuration("PT256S"))
returns
16.0
.
Function  Meaning 

op:addyearMonthDurations

Returns
the
result
of
adding
two
xs:yearMonthDuration
values.

op:subtractyearMonthDurations

Returns
the
result
of
subtracting
one
xs:yearMonthDuration
value
from
another.

op:multiplyyearMonthDuration

Returns
the
result
of
multiplying
the
value
of
$arg1
by
$arg2
.
The
result
is
rounded
to
the
nearest
month.

op:divideyearMonthDuration

Returns
the
result
of
dividing
the
value
of
$arg1
by
$arg2
.
The
result
is
rounded
to
the
nearest
month.

op:divideyearMonthDurationbyyearMonthDuration

Returns
the
ratio
of
two
xs:yearMonthDuration
values.

op:adddayTimeDurations

Returns
the
sum
of
two
xs:dayTimeDuration
values.

op:subtractdayTimeDurations

Returns
the
result
of
subtracting
one
xs:dayTimeDuration
from
another.

op:multiplydayTimeDuration

Returns
the
result
of
multiplying
a
xs:dayTimeDuration
by
a
number.

op:dividedayTimeDuration

Returns
the
result
of
multiplying
a
xs:dayTimeDuration
by
a
number.

op:dividedayTimeDurationbydayTimeDuration

Returns
the
ratio
of
two
xs:dayTimeDuration
values,
as
a
decimal
number.

For operators that combine a duration and a date/time value, see 9.7 Arithmetic Operators on Durations, Dates and Times .
Returns
the
result
of
adding
two
xs:yearMonthDuration
values.
Defines
the
semantics
of
the
"+"
operator
on
xs:yearMonthDuration
values.
op:addyearMonthDurations
(

$arg1

as
xs:yearMonthDuration
, 
$arg2

as
xs:yearMonthDuration
)
as
xs:yearMonthDuration

The
function
returns
the
result
of
adding
the
value
of
$arg1
to
the
value
of
$arg2
.
The
result
will
be
an
xs:yearMonthDuration
whose
length
in
months
is
equal
to
the
length
in
months
of
$arg1
plus
the
length
in
months
of
$arg2
.
For handling of overflow, see 8.1 Limits and Precision .
Either duration (and therefore the result) may be negative.
The
expression
op:addyearMonthDurations(xs:yearMonthDuration("P2Y11M"),
xs:yearMonthDuration("P3Y3M"))
returns
xs:yearMonthDuration("P6Y2M")
.
Returns
the
result
of
subtracting
one
xs:yearMonthDuration
value
from
another.
Defines
the
semantics
of
the
""
operator
on
xs:yearMonthDuration
values.
op:subtractyearMonthDurations
(

$arg1

as
xs:yearMonthDuration
, 
$arg2

as
xs:yearMonthDuration
)
as
xs:yearMonthDuration

The
function
returns
the
result
of
subtracting
the
value
of
$arg2
from
the
value
of
$arg1
.
The
result
will
be
an
xs:yearMonthDuration
whose
length
in
months
is
equal
to
the
length
in
months
of
$arg1
minus
the
length
in
months
of
$arg2
.
For handling of overflow, see 8.1 Limits and Precision .
Either duration (and therefore the result) may be negative.
The
expression
op:subtractyearMonthDurations(xs:yearMonthDuration("P2Y11M"),
xs:yearMonthDuration("P3Y3M"))
returns
xs:yearMonthDuration("P4M")
.
Returns
the
result
of
multiplying
the
value
of
$arg1
by
$arg2
.
The
result
is
rounded
to
the
nearest
month.
Defines
the
semantics
of
the
"*"
operator
on
xs:yearMonthDuration
values.
op:multiplyyearMonthDuration
(

$arg1

as
xs:yearMonthDuration
, 
$arg2

as
xs:double
)
as
xs:yearMonthDuration

The
result
is
the
xs:yearMonthDuration
whose
length
in
months
is
equal
to
the
result
of
applying
the
fn:round
function
to
the
value
obtained
by
multiplying
the
length
in
months
of
$arg1
by
the
value
of
$arg2
.
If
$arg2
is
positive
or
negative
zero,
the
result
is
a
zerolength
duration.
If
$arg2
is
positive
or
negative
infinity,
the
result
overflows
and
is
handled
as
discussed
in
8.1
Limits
and
Precision
.
For handling of overflow and underflow, see 8.1 Limits and Precision .
If
$arg2
is
NaN
an
error
is
raised
[
err:FOCA0005
].
Either duration (and therefore the result) may be negative.
The
expression
op:multiplyyearMonthDuration(xs:yearMonthDuration("P2Y11M"),
2.3)
returns
xs:yearMonthDuration("P6Y9M")
.
Returns
the
result
of
dividing
the
value
of
$arg1
by
$arg2
.
The
result
is
rounded
to
the
nearest
month.
Defines
the
semantics
of
the
"div"
operator
on
xs:yearMonthDuration
and
numeric
values.
op:divideyearMonthDuration
(

$arg1

as
xs:yearMonthDuration
, 
$arg2

as
xs:double
)
as
xs:yearMonthDuration

The
result
is
the
xs:yearMonthDuration
whose
length
in
months
is
equal
to
the
result
of
applying
the
fn:round
function
to
the
value
obtained
by
dividing
the
length
in
months
of
$arg1
by
the
value
of
$arg2
.
If
$arg2
is
positive
or
negative
infinity,
the
result
is
a
zerolength
duration.
If
$arg2
is
positive
or
negative
zero,
the
result
overflows
and
is
handled
as
discussed
in
8.1
Limits
and
Precision
.
For handling of overflow and underflow, see 8.1 Limits and Precision .
If
$arg2
is
NaN
an
error
is
raised
[
err:FOCA0005
].
Either operand (and therefore the result) may be negative.
The
expression
op:divideyearMonthDuration(xs:yearMonthDuration("P2Y11M"),
1.5)
returns
xs:yearMonthDuration("P1Y11M")
.
Returns
the
ratio
of
two
xs:yearMonthDuration
values.
Defines
the
semantics
of
the
"div"
operator
on
xs:yearMonthDuration
values.
op:divideyearMonthDurationbyyearMonthDuration
(

$arg1

as
xs:yearMonthDuration
, 
$arg2

as
xs:yearMonthDuration
)
as
xs:decimal

The
function
returns
the
result
of
dividing
the
length
in
months
of
$arg1
by
the
length
in
months
of
$arg2
,
according
to
the
rules
of
the
op:numericdivide
function
for
integer
operands.
For handling of overflow and underflow, see 8.1 Limits and Precision .
Either duration (and therefore the result) may be negative.
The
expression
op:divideyearMonthDurationbyyearMonthDuration(xs:yearMonthDuration("P3Y4M"),
xs:yearMonthDuration("P1Y4M"))
returns
2.5
.
The
following
example
demonstrates
how
to
calculate
the
length
of
an
xs:yearMonthDuration
value
in
months:
The
expression
op:divideyearMonthDurationbyyearMonthDuration(xs:yearMonthDuration("P3Y4M"),
xs:yearMonthDuration("P1M"))
returns
40
.
Returns
the
sum
of
two
xs:dayTimeDuration
values.
Defines
the
semantics
of
the
"+"
operator
on
xs:dayTimeDuration
values.
op:adddayTimeDurations
(

$arg1

as
xs:dayTimeDuration
, 
$arg2

as
xs:dayTimeDuration
)
as
xs:dayTimeDuration

The
function
returns
the
result
of
adding
the
value
of
$arg1
to
the
value
of
$arg2
.
The
result
is
the
xs:dayTimeDuration
whose
length
in
seconds
is
equal
to
the
sum
of
the
length
in
seconds
of
the
two
input
durations.
For handling of overflow, see 8.1 Limits and Precision .
Either duration (and therefore the result) may be negative.
The
expression
op:adddayTimeDurations(xs:dayTimeDuration("P2DT12H5M"),
xs:dayTimeDuration("P5DT12H"))
returns
xs:dayTimeDuration('P8DT5M')
.
Returns
the
result
of
subtracting
one
xs:dayTimeDuration
from
another.
Defines
the
semantics
of
the
""
operator
on
xs:dayTimeDuration
values.
op:subtractdayTimeDurations
(

$arg1

as
xs:dayTimeDuration
, 
$arg2

as
xs:dayTimeDuration
)
as
xs:dayTimeDuration

The
function
returns
the
result
of
subtracting
the
value
of
$arg2
from
the
value
of
$arg1
.
The
result
is
the
xs:dayTimeDuration
whose
length
in
seconds
is
equal
to
the
length
in
seconds
of
$arg1
minus
the
length
in
seconds
of
$arg2
.
For handling of overflow, see 8.1 Limits and Precision .
Either duration (and therefore the result) may be negative.
The
expression
op:subtractdayTimeDurations(xs:dayTimeDuration("P2DT12H"),
xs:dayTimeDuration("P1DT10H30M"))
returns
xs:dayTimeDuration('P1DT1H30M')
.
Returns
the
result
of
multiplying
a
xs:dayTimeDuration
by
a
number.
Defines
the
semantics
of
the
"*"
operator
on
xs:dayTimeDuration
and
numeric
values.
op:multiplydayTimeDuration
(

$arg1

as
xs:dayTimeDuration
, 
$arg2

as
xs:double
)
as
xs:dayTimeDuration

The
function
returns
the
result
of
multiplying
the
value
of
$arg1
by
$arg2
.
The
result
is
the
xs:dayTimeDuration
whose
length
in
seconds
is
equal
to
the
length
in
seconds
of
$arg1
multiplied
by
the
numeric
value
$arg2
.
Editorial note  
We ought to say whether the calculation is performed using double or decimal arithmetic. 
If
$arg2
is
positive
or
negative
zero,
the
result
is
a
zerolength
duration.
If
$arg2
is
positive
or
negative
infinity,
the
result
overflows
and
is
handled
as
discussed
in
9.1.1
Limits
and
Precision
.
For handling of overflow and underflow, see 8.1 Limits and Precision .
If
$arg2
is
NaN
an
error
is
raised
[
err:FOCA0005
].
Either operand (and therefore the result) may be negative.
The
expression
op:multiplydayTimeDuration(xs:dayTimeDuration("PT2H10M"),
2.1)
returns
xs:dayTimeDuration('PT4H33M')
.
Returns
the
result
of
multiplying
a
xs:dayTimeDuration
by
a
number.
Defines
the
semantics
of
the
"div"
operator
on
xs:dayTimeDuration
values.
op:dividedayTimeDuration
(

$arg1

as
xs:dayTimeDuration
, 
$arg2

as
xs:double
)
as
xs:dayTimeDuration

The
function
returns
the
result
of
dividing
the
value
of
$arg1
by
$arg2
.
The
result
is
the
xs:dayTimeDuration
whose
length
in
seconds
is
equal
to
the
length
in
seconds
of
$arg1
divided
by
the
numeric
value
$arg2
.
If
$arg2
is
positive
or
negative
infinity,
the
result
is
a
zerolength
duration.
If
$arg2
is
positive
or
negative
zero,
the
result
overflows
and
is
handled
as
discussed
in
9.1.1
Limits
and
Precision
.
Editorial note  
We ought to say whether the calculation is performed using double or decimal arithmetic. 
For handling of overflow and underflow, see 8.1 Limits and Precision .
If
$arg2
is
NaN
an
error
is
raised
[
err:FOCA0005
]
Either operand (and therefore the result) may be negative.
The
expression
op:dividedayTimeDuration(xs:dayTimeDuration("P1DT2H30M10.5S"),
1.5)
returns
xs:duration("PT17H40M7S")
.
Returns
the
ratio
of
two
xs:dayTimeDuration
values,
as
a
decimal
number.
Defines
the
semantics
of
the
"div"
operator
on
xs:dayTimeDuration
values.
op:dividedayTimeDurationbydayTimeDuration
(

$arg1

as
xs:dayTimeDuration
, 
$arg2

as
xs:dayTimeDuration
)
as
xs:decimal

The
function
returns
the
result
of
dividing
the
value
of
$arg1
by
$arg2
.
The
result
is
the
xs:dayTimeDuration
whose
length
in
seconds
is
equal
to
the
length
in
seconds
of
$arg1
divided
by
the
length
in
seconds
of
$arg2
.
The
calculation
is
performed
by
applying
op:numericdivide
to
the
two
xs:decimal
operands.
For handling of overflow and underflow, see 8.1 Limits and Precision .
Either operand (and therefore the result) may be negative.
The
expression
fn:roundhalftoeven(
op:dividedayTimeDurationbydayTimeDuration(
xs:dayTimeDuration("P2DT53M11S"),
xs:dayTimeDuration("P1DT10H")),
4)
returns
1.4378
.
This examples shows how to determine the number of seconds in a duration.
The
expression
op:dividedayTimeDurationbydayTimeDuration(xs:dayTimeDuration("P2DT53M11S"),
xs:dayTimeDuration("PT1S"))
returns
175991.0
.
This section defines operations on the [XML Schema Part 2: Datatypes Second Edition] date and time types.
See [Working With Timezones] for a disquisition on working with date and time values with and without timezones.
The operators described in this section are defined on the following date and time types:
xs:dateTime
xs:date
xs:time
xs:gYearMonth
xs:gYear
xs:gMonthDay
xs:gMonth
xs:gDay
The
only
operations
defined
on
xs:gYearMonth
,
xs:gYear
,
xs:gMonthDay
,
xs:gMonth
and
xs:gDay
values
are
equality
comparison
and
component
extraction.
For
other
types,
further
operations
are
provided,
including
order
comparisons,
arithmetic,
formatted
display,
and
timezone
adjustment.
For a number of the above datatypes [XML Schema Part 2: Datatypes Second Edition] extends the basic [ISO 8601] lexical representations, such as YYYYMMDDThh:mm:ss.s for dateTime, by allowing a preceding minus sign, more than four digits to represent the year field — no maximum is specified — and an unlimited number of digits for fractional seconds. Leap seconds are not supported.
All minimally conforming processors · must · support positive year values with a minimum of 4 digits (i.e., YYYY) and a minimum fractional second precision of 1 millisecond or three digits (i.e., s.sss). However, conforming processors · may · set larger · implementationdefined · limits on the maximum number of digits they support in these two situations. Processors · may · also choose to support the year 0000 and years with negative values. The results of operations on dates that cross the year 0000 are · implementationdefined · .
A processor that limits the number of digits in date and time datatype representations may encounter overflow and underflow conditions when it tries to execute the functions in 9.7 Arithmetic Operators on Durations, Dates and Times . In these situations, the processor · must · return 00:00:00 in case of time underflow. It · must · raise an error [ err:FODT0001 ] in case of overflow.
Editorial note  
Can time underflow occur, and if so when? 
As
defined
in
Section
3.3.2
Dates
and
Times
^{
DM
},
xs:dateTime
,
xs:date
,
xs:time
,
xs:gYearMonth
,
xs:gYear
,
xs:gMonthDay
,
xs:gMonth
,
xs:gDay
values,
referred
to
collectively
as
date/time
values,
are
represented
as
seven
components
or
properties:
year
,
month
,
day
,
hour
,
minute
,
second
and
timezone
.
The
value
of
the
first
five
components
are
xs:integer
s.
The
value
of
the
second
component
is
an
xs:decimal
and
the
value
of
the
timezone
component
is
an
xs:dayTimeDuration
.
For
all
the
primitive
date/time
datatypes,
the
timezone
property
is
optional
and
may
or
may
not
be
present.
Depending
on
the
datatype,
some
of
the
remaining
six
properties
must
be
present
and
some
must
be
absent.
Absent,
or
missing,
properties
are
represented
by
the
empty
sequence.
This
value
is
referred
to
as
the
local
value
in
that
the
value
retains
its
original
timezone.
Before
comparing
or
subtracting
xs:dateTime
values,
this
local
value
·
must
·
be
translated
or
normalized
to
UTC.
For
xs:time
,
00:00:00
and
24:00:00
are
alternate
lexical
forms
for
the
same
value,
whose
canonical
representation
is
00:00:00
.
For
xs:dateTime
,
a
time
component
24:00:00
translates
to
00:00:00"
of
the
following
day.
An
xs:dateTime
with
lexical
representation
19990531T05:00:00
is
represented
in
the
datamodel
by
{1999,
5,
31,
5,
0,
0.0,
()}
.
An
xs:dateTime
with
lexical
representation
19990531T13:20:0005:00
is
represented
by
{1999,
5,
31,
13,
20,
0.0,
PT5H}
.
An
xs:dateTime
with
lexical
representation
19991231T24:00:00
is
represented
by
{2000,
1,
1,
0,
0,
0.0,
()}
.
An
xs:date
with
lexical
representation
20050228+8:00
is
represented
by
{2005,
2,
28,
(),
(),
(),
PT8H}
.
An
xs:time
with
lexical
representation
24:00:00
is
represented
by
{(),
(),
(),
0,
0,
0,
()}
.
A
function
is
provided
for
constructing
a
xs:dateTime
value
from
a
xs:date
value
and
a
xs:time
value.
Returns
an
xs:dateTime
value
created
by
combining
an
xs:date
and
an
xs:time
.
fn:dateTime
(
$arg1
as
xs:date?
,
$arg2
as
xs:time?
)
as
xs:dateTime?
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.
If the two arguments both have timezones and the timezones are different, an error is raised: [ err:FORG0008 ]
The
expression
fn:dateTime(xs:date("19991231"),
xs:time("12:00:00"))
returns
xs:dateTime("19991231T12:00:00")
.
The
expression
fn:dateTime(xs:date("19991231"),
xs:time("24:00:00"))
returns
xs:dateTime("19991231T00:00:00")
.
(This
is
because
"24:00:00"
is
an
alternate
lexical
form
for
"00:00:00"
).
Function  Meaning 

op:dateTimeequal

Returns
true
if
the
two
supplied
xs:dateTime
values
refer
to
the
same
instant
in
time.

op:dateTimelessthan


op:dateTimegreaterthan


op:dateequal

true
if
and
only
if
the
starting
instants
of
the
two
supplied
xs:date
values
are
the
same.

op:datelessthan

$arg1
is
less
than
the
starting
instant
of
$arg2
.
Returns
false
otherwise.

op:dategreaterthan

$arg1
is
greater
than
the
starting
instant
of
$arg2
.
Returns
false
otherwise.

op:timeequal

true
if
the
two
xs:time
values
represent
the
same
instant
in
time,
when
treated
as
being
times
on
the
same
date,
before
adjusting
the
timezone.

op:timelessthan

true
if
the
first
xs:time

op:timegreaterthan

true
if
the
first
xs:time

op:gYearMonthequal

xs:gYearMonth
values
have
the
same
starting
instant.

op:gYearequal

xs:gYear
values
have
the
same
starting
instant.

op:gMonthDayequal

xs:gMonthDay
values
have
the
same
starting
instant,
when
considered
as
days
in
the
same
year.

op:gMonthequal

xs:gMonth
values
have
the
same
starting
instant,
when
considered
as
months
in
the
same
year.

op:gDayequal

xs:gDay
values
have
the
same
starting
instant,
when
considered
as
days
in
the
same
month
of
the
same
year.

The
following
comparison
operators
are
defined
on
the
[XML
Schema
Part
2:
Datatypes
Second
Edition]
date,
time
and
duration
date/time
datatypes.
Each
operator
takes
two
operands
of
the
same
type
and
returns
an
xs:boolean
result.
As
discussed
in
[XML
Schema
Part
2:
Datatypes
Second
Edition]
,
the
order
relation
on
xs:duration
is
not
a
total
order
but,
rather,
a
partial
order.
For
this
reason,
only
equality
is
defined
on
xs:duration
.
A
full
complement
of
comparison
and
arithmetic
functions
are
defined
on
the
two
subtypes
of
duration
described
in
10.3
Two
Totally
Ordered
Subtypes
of
Duration
which
do
have
a
total
order.
[XML Schema Part 2: Datatypes Second Edition] also states that the order relation on date and time datatypes is not a total order but a partial order because these datatypes may or may not have a timezone. This is handled as follows. If either operand to a comparison function on date or time values does not have an (explicit) timezone then, for the purpose of the operation, an implicit timezone, provided by the dynamic context Section C.2 Dynamic Context Components ^{ XP }, is assumed to be present as part of the value. This creates a total order for all date and time values.
Editorial note  
The following paragraph seems to duplicate material that has already been covered. 
An
xs:dateTime
can
be
considered
to
consist
of
seven
components:
year
,
month
,
day
,
hour
,
minute
,
second
and
timezone
.
For
xs:dateTime
six
components:
year
,
month
,
day
,
hour
,
minute
and
second
are
required
and
timezone
is
optional.
For
other
date/time
values,
of
the
first
six
components,
some
are
required
and
others
must
be
absent
or
missing.
Timezone
is
always
optional.
For
example,
for
xs:date
,
the
year
,
month
and
day
components
are
required
and
hour
,
minute
and
second
components
must
be
absent;
for
xs:time
the
hour
,
minute
and
second
components
are
required
and
year
,
month
and
day
are
missing;
for
xs:gDay
,
day
is
required
and
year
,
month
,
hour
,
minute
and
second
are
missing.
Values
of
the
date/time
datatypes
xs:time
,
xs:gMonthDay
,
xs:gMonth
,
and
xs:gDay
,
can
be
considered
to
represent
a
sequence
of
recurring
time
instants
or
time
periods.
An
xs:time
occurs
every
day.
An
xs:gMonth
occurs
every
year.
Comparison
operators
on
these
datatypes
compare
the
starting
instants
of
equivalent
occurrences
in
the
recurring
series.
These
xs:dateTime
values
are
calculated
as
described
below.
Comparison
operators
on
xs:date
,
xs:gYearMonth
and
xs:gYear
compare
their
starting
instants.
These
xs:dateTime
values
are
calculated
as
described
below.
The
starting
instant
of
an
occurrence
of
a
date/time
value
is
an
xs:dateTime
calculated
by
filling
in
the
missing
components
of
the
local
value
from
a
reference
xs:dateTime
.
If
the
value
filled
in
for
a
missing
day
component
exceeds
the
maximum
day
value
for
the
month,
the
last
day
An
example
of
the
month
is
used.
Suppose,
for
example,
that
the
a
suitable
reference
xs:dateTime
is
.
Then,
for
example,
the
starting
instant
corresponding
to
the
19721231T00:00:00
and
19720101T00:00:00
xs:date
value
to
be
compared
is
19930331
.
Filling
in
the
time
components
from
the
reference
xs:dateTime
20090312
we
get
is
19930331T00:00:00
20090312T00:00:00
which
is
;
the
starting
instant
of
that
day.
Similarly,
if
corresponding
to
the
xs:time
value
is
12:30:00
13:30:02
to
be
compared,
we
fill
in
19720101T13:30:02
;
and
the
missing
components
from
starting
instant
corresponding
to
the
reference
xs:dateTime
gMonthDay
and
we
get
value
19721231T12:30:00
0229
which
is
the
time
on
that
day.
For
an
xs:gYearMonth
19720229T00:00:00
value
(which
explains
why
a
leap
year
was
chosen
for
the
reference).
Note:
In
the
previous
version
of
this
specification,
the
reference
date/time
chosen
was
.
While
this
gives
the
197602
we
fill
in
19721231T00:00:00
missing
components,
adjust
same
results,
it
produces
a
"starting
instant"
for
a
gMonth
or
gMonthDay
that
bears
no
relation
to
the
last
day
in
English
meaning
of
the
month
term,
and
get
19760229T00:00:00
.
it
also
required
special
handling
of
short
months.
The
original
choice
was
made
to
allow
for
leap
seconds;
but
since
leap
seconds
are
not
recognized
in
date/time
arithmetic,
this
is
not
actually
necessary.
If
the
xs:time
value
written
as
24:00:00
is
to
be
compared,
filling
in
the
missing
components
gives
,
because
19721231T00:00:00
19720101T00:00:00
24:00:00
is
an
alternative
representation
of
00:00:00
(the
lexical
value
"24:00:00"
is
converted
to
the
time
components
{0,0,0}
before
the
missing
components
are
filled
in).
This
has
the
consequence
that
when
ordering
xs:time
values,
24:00:00
is
considered
to
be
earlier
than
23:59:59
.
However,
when
ordering
xs:dateTime
values,
a
time
component
of
24:00:00
is
considered
equivalent
to
00:00:00
on
the
following
day.
Note
that
the
reference
xs:dateTime
does
not
have
a
timezone.
The
timezone
component
is
never
filled
in
from
the
reference
xs:dateTime
.
In
some
cases,
if
the
date/time
value
does
not
have
a
timezone,
the
implicit
timezone
from
the
dynamic
context
is
used
as
the
timezone.
Note:
This
proposal
specification
uses
the
reference
xs:dateTime
in
the
description
of
the
comparison
operators.
Implementations
19721231T00:00:00
19720101T00:00:00
are
allowed
to
may
use
other
reference
xs:dateTime
values
as
long
as
they
yield
the
same
results.
The
reference
xs:dateTime
used
must
meet
the
following
constraints:
when
it
is
used
to
supply
components
into
xs:gMonthDay
values,
the
year
must
allow
for
February
29
and
so
must
be
a
leap
year;
when
it
is
used
to
supply
missing
components
into
xs:gDay
values,
the
month
must
allow
for
31
days.
Different
reference
xs:dateTime
values
may
be
used
for
different
operators.
Summary:
Returns
true
if
and
only
if
$arg1
is
less
than
$arg2
.
Returns
false
otherwise.
This
function
backs
up
the
"lt"
and
"le"
operators
on
xs:yearMonthDuration
values.
10.4.2
op:yearMonthDurationgreaterthan
op:yearMonthDurationgreaterthan
(
$arg1
as
xs:yearMonthDuration
,
$arg2
as
xs:yearMonthDuration
)
as
xs:boolean
Summary:
Returns
true
if
and
only
if
$arg1
is
greater
than
$arg2
.
Returns
two
supplied
false
xs:dateTime
otherwise.
This
function
backs
up
values
refer
to
the
"gt"
and
"ge"
operators
on
xs:yearMonthDuration
values.
10.4.3
op:dayTimeDurationlessthan
op:dayTimeDurationlessthan
(
$arg1
as
xs:dayTimeDuration
,
$arg2
as
xs:dayTimeDuration
)
as
xs:boolean
Summary:
Returns
true
if
and
only
if
$arg1
is
less
than
$arg2
.
Returns
false
otherwise.
same
instant
in
time.
This
function
backs
up
Defines
the
"lt"
and
"le"
operators
semantics
of
the
"eq"
operator
on
values.
xs:dayTimeDuration
xs:dateTime
10.4.4
op:dayTimeDurationgreaterthan
op:dayTimeDurationgreaterthan
(
$arg1
as
xs:dayTimeDuration
,
$arg2
as
xs:dayTimeDuration
)
as
xs:boolean
Summary:
Returns
true
if
and
only
if
$arg1
is
greater
than
$arg2
.
Returns
false
otherwise.
This
function
backs
up
Also
used
in
the
"gt"
definition
of
the
"ne",
"le"
and
"ge"
operators
on
xs:dayTimeDuration
values.
operators.
op:durationequal
op:dateTimeequal
(
$arg1
as
xs:duration
xs:dateTime
,
$arg2
as
xs:duration
xs:dateTime
)
as
xs:boolean
Summary:
Returns
true
if
and
only
if
the
xs:yearMonthDuration
and
the
xs:dayTimeDuration
components
of
If
either
$arg1
and
or
$arg2
compare
equal
respectively.
Returns
false
otherwise.
This
function
backs
up
the
"eq"
and
"ne"
operators
on
xs:duration
values.
Note
that
this
function,
like
any
other,
may
be
applied
to
arguments
that
are
derived
from
the
types
given
in
has
no
timezone
component,
the
function
signature,
including
effective
value
of
the
two
subtypes
xs:dayTimeDuration
and
xs:yearMonthDuration
.
With
argument
is
obtained
by
substituting
the
exception
of
implicit
timezone
from
the
zerolength
duration,
no
instance
of
xs:dayTimeDuration
can
ever
be
equal
to
an
instance
of
xs:yearMonthDuration
.
dynamic
evaluation
context.
The
semantics
of
this
function
are:
xs:yearMonthDuration($arg1) div xs:yearMonthDuration('P1M') eq
xs:yearMonthDuration($arg2) div xs:yearMonthDuration('P1M')
and
xs:dayTimeDuration($arg1) div xs:dayTimeDuration('PT1S') eq
xs:dayTimeDuration($arg2) div xs:dayTimeDuration('PT1S')
that
is,
the
function
returns
true
if
the
months
and
seconds
values
of
the
two
durations
are
equal.
10.4.5.1
Examples
op:durationequal(xs:duration("P1Y"),
xs:duration("P12M"))
returns
true
.
op:durationequal(xs:duration("PT24H"),
xs:duration("P1D"))
returns
true
.
op:durationequal(xs:duration("P1Y"),
xs:duration("P365D"))
returns
false
.
op:durationequal(xs:yearMonthDuration("P0Y"),
xs:dayTimeDuration("PT0D"))
returns
true
.
op:durationequal(xs:yearMonthDuration("P1Y"),
xs:dayTimeDuration("PT365D"))
returns
false
.
op:durationequal(xs:yearMonthDuration("P2Y"),
xs:yearMonthDuration("P24M"))
returns
true
.
op:durationequal(xs:dayTimeDuration("PT10D"),
xs:dayTimeDuration("PT240H"))
returns
true
.
op:durationequal(xs:duration("P2Y0M0DT0H0M0S"),
xs:yearMonthDuration("P24M"))
then
returns
true
if
and
only
if
the
effective
value
of
.
op:durationequal(xs:duration("P0Y0M10D"),
xs:dayTimeDuration("PT240H"))
returns
true
.
10.4.6
op:dateTimeequal
op:dateTimeequal
(
$arg1
as
xs:dateTime
,
$arg2
as
xs:dateTime
)
as
xs:boolean
Summary:
Returns
true
$arg1
is
equal
to
the
effective
value
of
$arg2
according
to
the
algorithm
defined
in
section
3.2.7.4
of
[XML
Schema
Part
2:
Datatypes
Second
Edition]
"Order
relation
on
dateTime"
for
xs:dateTime
values
with
timezones.
Returns
false
otherwise.
This
function
backs
up
Otherwise
the
"eq",
"ne",
"le"
and
"ge"
operators
on
function
returns
.
xs:dateTime
values.
false
Assume
that
the
dynamic
context
provides
an
implicit
timezone
value
of
05:00
.
The
expression
op:dateTimeequal(xs:dateTime("20020402T12:00:0001:00"),
xs:dateTime("20020402T17:00:00+04:00"))
returns
.
true
true()
The
expression
op:dateTimeequal(xs:dateTime("20020402T12:00:00"),
xs:dateTime("20020402T23:00:00+06:00"))
returns
.
true
true()
The
expression
op:dateTimeequal(xs:dateTime("20020402T12:00:00"),
xs:dateTime("20020402T17:00:00"))
returns
.
false
false()
The
expression
op:dateTimeequal(xs:dateTime("20020402T12:00:00"),
xs:dateTime("20020402T12:00:00"))
returns
.
true
true()
The
expression
op:dateTimeequal(xs:dateTime("20020402T23:00:0004:00"),
xs:dateTime("20020403T02:00:0001:00"))
returns
.
true
true()
The
expression
op:dateTimeequal(xs:dateTime("19991231T24:00:00"),
xs:dateTime("20000101T00:00:00"))
returns
.
true
true()
The
expression
op:dateTimeequal(xs:dateTime("20050404T24:00:00"),
xs:dateTime("20050404T00:00:00"))
returns
.
false
false()
Returns
true
if
the
first
argument
represents
an
earlier
instant
in
time
than
the
second
argument.
Defines
the
semantics
of
the
"lt"
operator
on
xs:dateTime
values.
Also
used
in
the
definition
of
the
"le"
operator.
op:dateTimelessthan
(
$arg1
as
xs:dateTime
,
$arg2
as
xs:dateTime
)
as
xs:boolean
Summary:
Returns
If
either
$arg1
or
$arg2
has
no
timezone
component,
the
effective
value
of
the
argument
is
obtained
by
substituting
the
implicit
timezone
from
the
dynamic
evaluation
context.
The
function
then
returns
true
if
and
only
if
the
effective
value
of
$arg1
is
less
than
the
effective
value
of
$arg2
according
to
the
algorithm
defined
in
section
3.2.7.4
of
[XML
Schema
Part
2:
Datatypes
Second
Edition]
"Order
relation
on
dateTime"
for
xs:dateTime
values
with
timezones.
Returns
false
otherwise.
This
function
backs
up
Otherwise
the
"lt"
and
"le"
operators
on
function
returns
.
xs:dateTime
values.
false
Returns
true
if
the
first
argument
represents
a
later
instant
in
time
than
the
second
argument.
Defines
the
semantics
of
the
"gt"
operator
on
xs:dateTime
values.
Also
used
in
the
definition
of
the
"ge"
operator.
op:dateTimegreaterthan
(

$arg1

as
xs:dateTime
,

$arg2

as
xs:dateTime
)
as
xs:boolean

The
function
call
op:dateTimegreaterthan($A,
$B)
is
defined
to
return
the
same
result
as
op:dateTimelessthan($B,
$A)
Summary:
Returns
true
if
and
only
if
the
value
of
$arg1
is
greater
than
the
value
starting
instants
of
$arg2
according
to
the
algorithm
defined
in
section
3.2.7.4
of
[XML
Schema
Part
2:
Datatypes
Second
Edition]
"Order
relation
on
dateTime"
for
two
supplied
values
xs:dateTime
xs:date
with
timezones.
Returns
false
otherwise.
are
the
same.
This
function
backs
up
Defines
the
"gt"
and
"ge"
operators
semantics
of
the
"eq"
operator
on
values.
Also
used
in
the
definition
of
the
"ne",
"le"
and
"ge"
operators.
xs:dateTime
xs:date
op:dateequal
(
$arg1
as
xs:date
,
$arg2
as
xs:date
)
as
xs:boolean
The
starting
instant
of
an
xs:date
is
the
xs:dateTime
at
time
00:00:00
on
that
date.
The
two
starting
instants
are
compared
using
op:dateTimeequal
.
This
function
backs
up
returns
the
"eq",
"ne",
"le"
and
"ge"
operators
on
xs:date
values.
result
of
the
expression:
op:dateTimeequal(xs:dateTime($arg1), xs:dateTime($arg2))
The
expression
op:dateequal(xs:date("20041225Z"),
xs:date("20041225+07:00"))
returns
.
false
false()
The
(The
starting
instants
are
xs:dateTime("20041225T00:00:00Z")
and
xs:dateTime("20041225T00:00:00+07:00")
.
These
are
normalized
to
xs:dateTime("20041225T00:00:00Z")
and
xs:dateTime("20041224T17:00:00Z")
.
).
The
expression
op:dateequal(xs:date("2004122512:00"),
xs:date("20041226+12:00"))
returns
.
true
true()
Returns
true
if
and
only
if
the
starting
instant
of
$arg1
is
less
than
the
starting
instant
of
$arg2
.
Returns
false
otherwise.
Defines
the
semantics
of
the
"lt"
operator
on
xs:date
values.
Also
used
in
the
definition
of
the
"le"
operator.
op:datelessthan
(
$arg1
as
xs:date
,
$arg2
as
xs:date
)
as
xs:boolean
The
starting
instant
of
an
xs:date
is
the
xs:dateTime
at
time
00:00:00
on
that
date.
The
two
starting
instants
are
compared
using
op:dateTimelessthan
.
This
function
backs
up
returns
the
"lt"
and
"le"
operators
on
xs:date
values.
result
of
the
expression:
op:dateTimelessthan(xs:dateTime($arg1), xs:dateTime($arg2))
The
expression
op:datelessthan(xs:date("20041225Z"),
xs:date("2004122505:00"))
returns
.
true
true()
The
expression
op:datelessthan(xs:date("2004122512:00"),
xs:date("20041226+12:00"))
returns
.
false
false()
Returns
true
if
and
only
if
the
starting
instant
of
$arg1
is
greater
than
the
starting
instant
of
$arg2
.
Returns
false
otherwise.
Defines
the
semantics
of
the
"gt"
operator
on
xs:date
values.
Also
used
in
the
definition
of
the
"ge"
operator.
op:dategreaterthan
(
$arg1
as
xs:date
,
$arg2
as
xs:date
)
as
xs:boolean
The
starting
instant
of
an
function
call
is
defined
to
return
the
xs:date
op:dategreaterthan($A,
$B)
xs:dateTime
at
time
00:00:00
on
that
date.
The
two
starting
instants
are
compared
using
op:dateTimegreaterthan
same
result
as
.
This
function
backs
up
the
"gt"
and
"ge"
operators
on
xs:date
op:datelessthan($B,
$A)
values.
10.4.11.1
The
expression
op:dategreaterthan(xs:date("20041225Z"),
xs:date("20041225+07:00"))
returns
.
true
true()
The
expression
op:dategreaterthan(xs:date("2004122512:00"),
xs:date("20041226+12:00"))
returns
.
false
false()
Returns
true
if
the
two
xs:time
values
represent
the
same
instant
in
time,
when
treated
as
being
times
on
the
same
date,
before
adjusting
the
timezone.
Defines
the
semantics
of
the
"eq"
operator
on
xs:time
values.
Also
used
in
the
definition
of
the
"ne",
"le"
and
"ge"
operators.
op:timeequal
(
$arg1
as
xs:time
,
$arg2
as
xs:time
)
as
xs:boolean
Summary:
Returns
true
if
and
only
if
the
value
Each
of
$arg1
converted
to
an
xs:dateTime
using
the
date
components
from
the
reference
supplied
values
is
xs:dateTime
xs:time
equal
to
the
value
of
$arg2
converted
expanded
to
an
xs:dateTime
using
the
date
components
from
value
by
associating
the
same
reference
xs:dateTime
.
Returns
false
otherwise.
time
with
an
arbitrary
date.
The
function
returns
the
result
of
comparing
these
two
xs:dateTime
values
are
compared
using
op:dateTimeequal
.
This
The
result
of
the
function
backs
up
is
thus
the
"eq",
"ne",
"le"
and
"ge"
operators
on
xs:time
values.
same
as
the
value
of
the
expression:
op:dateTimeequal( fn:dateTime(xs:date('19721231'), $arg1), fn:dateTime(xs:date('19721231'), $arg2))
Assume
that
the
date
components
from
the
reference
xs:dateTime
correspond
to
19721231
.
The
expression
op:timeequal(xs:time("08:00:00+09:00"),
xs:time("17:00:0006:00"))
returns
.
false
false()
The
(The
xs:dateTime
s
calculated
using
the
reference
date
components
are
19721231T08:00:00+09:00
and
19721231T17:00:0006:00
.
These
normalize
to
19721230T23:00:00Z
and
19721231T23:00:00
.
).
The
expression
op:timeequal(xs:time("21:30:00+10:30"),
xs:time("06:00:0005:00"))
returns
.
true
true()
The
expression
op:timeequal(xs:time("24:00:00+01:00"),
xs:time("00:00:00+01:00"))
returns
.
true
true()
This
(This
not
the
result
one
might
expect.
For
xs:dateTime
values,
a
time
of
24:00:00
is
equivalent
to
00:00:00
on
the
following
day.
For
xs:time
,
the
normalization
from
24:00:00
to
00:00:00
happens
before
the
xs:time
is
converted
into
an
xs:dateTime
for
the
purpose
of
the
equality
comparison.
For
xs:time
,
any
operation
on
24:00:00
produces
the
same
result
as
the
same
operation
on
00:00:00
because
these
are
two
different
lexical
representations
of
the
same
value.
).
Returns
true
if
the
first
xs:time
value
represents
an
earlier
instant
in
time
than
the
second,
when
both
are
treated
as
being
times
on
the
same
date,
before
adjusting
the
timezone.
Defines
the
semantics
of
the
"lt"
operator
on
xs:time
values.
Also
used
in
the
definition
of
the
"le"
operator.
op:timelessthan
(
$arg1
as
xs:time
,
$arg2
as
xs:time
)
as
xs:boolean
Summary:
Returns
true
if
and
only
if
the
value
Each
of
$arg1
converted
to
an
xs:dateTime
using
the
date
components
from
the
reference
supplied
values
is
xs:dateTime
xs:time
less
than
the
normalized
value
of
$arg2
converted
expanded
to
an
xs:dateTime
using
the
date
components
from
value
by
associating
the
same
reference
xs:dateTime
.
Returns
false
otherwise.
time
with
an
arbitrary
date.
The
function
returns
the
result
of
comparing
these
two
xs:dateTime
values
are
compared
using
op:dateTimelessthan
.
This
The
result
of
the
function
backs
up
is
thus
the
"lt"
and
"le"
operators
on
xs:time
values.
same
as
the
value
of
the
expression:
op:dateTimelessthan( fn:dateTime(xs:date('19721231'), $arg1), fn:dateTime(xs:date('19721231'), $arg2))
Assume
that
the
dynamic
context
provides
an
implicit
timezone
value
of
05:00
.
The
expression
op:timelessthan(xs:time("12:00:00"),
xs:time("23:00:00+06:00"))
returns
.
false
false()
The
expression
op:timelessthan(xs:time("11:00:00"),
xs:time("17:00:00Z"))
returns
.
true
true()
The
expression
op:timelessthan(xs:time("23:59:59"),
xs:time("24:00:00"))
returns
.
false
false()
Returns
true
if
the
first
xs:time
value
represents
a
later
instant
in
time
than
the
second,
when
both
are
treated
as
being
times
on
the
same
date,
before
adjusting
the
timezone.
Defines
the
semantics
of
the
"gt"
operator
on
xs:time
values.
Also
used
in
the
definition
of
the
"ge"
operator.
op:timegreaterthan
(
$arg1
as
xs:time
,
$arg2
as
xs:time
)
as
xs:boolean
Summary:
Returns
true
if
and
only
if
the
value
of
$arg1
converted
to
an
xs:dateTime
using
the
date
components
from
the
reference
The
function
call
is
xs:dateTime
op:timegreaterthan($A,
$B)
greater
than
the
value
of
$arg2
converted
defined
to
an
xs:dateTime
using
the
date
components
from
return
the
same
reference
xs:dateTime
.
Returns
false
otherwise.
The
two
xs:dateTime
values
are
compared
using
op:dateTimegreaterthan
result
as
.
This
function
backs
up
the
"gt"
and
"ge"
operators
on
xs:time
op:timelessthan($B,
$A)
values.
10.4.14.1
The
expression
op:timegreaterthan(xs:time("08:00:00+09:00"),
xs:time("17:00:0006:00"))
returns
.
false
false()
Returns
true
if
the
two
xs:gYearMonth
values
have
the
same
starting
instant.
Defines
the
semantics
of
the
"eq"
operator
on
xs:gYearMonth
values.
Also
used
in
the
definition
of
the
"ne"
operator.
op:gYearMonthequal
(

$arg1

as
xs:gYearMonth
,

$arg2

as
xs:gYearMonth
)
as
xs:boolean

Summary:
Returns
true
if
and
only
if
the
xs:dateTime
s
representing
the
starting
instants
of
$arg1
and
$arg2
compare
equal.
The
starting
instants
of
$arg1
and
$arg2
are
calculated
by
adding
supplying
the
missing
components
of
$arg1
and
$arg2
from
the
xs:dateTime
template
.
xxxxxxddT00:00:00
where
dd
represents
the
last
day
of
the
month
component
in
$arg1
or
$arg2
xxxxxx01T00:00:00
Returns
false
otherwise.
The
two
xs:dateTime
values
representing
function
returns
the
result
of
comparing
these
two
starting
instants
of
$arg1
and
$arg2
are
compared
using
op:dateTimeequal
.
Assume
that
the
dynamic
context
provides
an
implicit
timezone
value
of
05:00
.
returns
op:gYearMonthequal(xs:gYearMonth("197602"),
xs:gYearMonth("197603Z"))
op:gYearMonthequal(xs:gYearMonth("198602"),
xs:gYearMonth("198603"))
.
The
starting
instants
are
false
false()
and
19720229T00:00:0005:00
19860201T00:00:0005:00
,
respectively.
19720331T00:00:00Z
19860301T00:00:00
returns
op:gYearMonthequal(xs:gYearMonth("197603"),
xs:gYearMonth("197603Z"))
op:gYearMonthequal(xs:gYearMonth("197803"),
xs:gYearMonth("198603Z"))
.
The
starting
instants
are
false
false()
19860301T00:00:0005:00
and
19860301T00:00:00Z
,
respectively.
Returns
true
if
the
two
xs:gYear
values
have
the
same
starting
instant.
Defines
the
semantics
of
the
"eq"
operator
on
xs:gYear
values.
Also
used
in
the
definition
of
the
"ne"
operator.
op:gYearequal
(
$arg1
as
xs:gYear
,
$arg2
as
xs:gYear
)
as
xs:boolean
Summary:
Returns
true
if
and
only
if
the
xs:dateTime
s
representing
the
starting
instants
of
$arg1
and
$arg2
compare
equal.
The
starting
instants
of
$arg1
and
$arg2
are
calculated
by
adding
supplying
the
missing
components
of
$arg1
and
$arg2
from
a
the
xs:dateTime
template
such
as
xxxx0101T00:00:00
.
Returns
false
otherwise.
The
two
xs:dateTime
values
representing
function
returns
the
result
of
comparing
these
two
starting
instants
of
$arg1
and
$arg2
are
compared
using
op:dateTimeequal
.
Assume
that
the
dynamic
context
provides
an
implicit
timezone
value
of
05:00
.
Assume,
also,
that
the
xs:dateTime
template
is
xxxx0101T00:00:00
.
op:gYearequal(xs:gYear("200512:00"),
xs:gYear("2005+12:00"))
returns
.
The
starting
instants
are
false
false()
20050101T00:00:0012:00
and
20050101T00:00:00+12:00
,
respectively,
and
normalize
to
and
200501015T12:00:00Z
20050101T12:00:00Z
20041231T12:00:00Z
.
The
expression
op:gYearequal(xs:gYear("197605:00"),
xs:gYear("1976"))
returns
.
true
true()
Returns
true
if
the
two
xs:gMonthDay
values
have
the
same
starting
instant,
when
considered
as
days
in
the
same
year.
Defines
the
semantics
of
the
"eq"
operator
on
xs:gMonthDay
values.
Also
used
in
the
definition
of
the
"ne"
operator.
op:gMonthDayequal
(
$arg1
as
xs:gMonthDay
,
$arg2
as
xs:gMonthDay
)
as
xs:boolean
Summary:
Summary:
Returns
true
if
and
only
if
the
xs:dateTime
s
representing
the
starting
instants
of
equivalent
occurrences
of
$arg1
and
$arg2
compare
equal.
The
starting
instants
of
equivalent
occurrences
of
$arg1
and
$arg2
are
calculated
by
adding
supplying
the
missing
components
of
$arg1
and
$arg2
from
an
the
xs:dateTime
template
such
as
1972xxxxT00:00:00
.
Returns
false
otherwise.
or
an
equivalent.
The
two
xs:dateTime
values
representing
function
returns
the
result
of
comparing
these
two
starting
instants
of
equivalent
occurrences
of
$arg1
and
$arg2
are
compared
using
op:dateTimeequal
.
Assume
that
the
dynamic
context
provides
an
implicit
timezone
value
of
05:00
.
Assume,
also,
Assume
for
the
purposes
of
illustration
that
the
xs:dateTime
template
used
is
(this
does
not
affect
the
result).
1976xxxxT00:00:00
.
1972xxxxT00:00:00
The
expression
op:gMonthDayequal(xs:gMonthDay("122514:00"),
xs:gMonthDay("1226+10:00"))
returns
.
(
The
starting
instants
are
true
true()
and
19761225T00:00:0014:00
19721225T00:00:0014:00
,
respectively,
and
normalize
to
19761226T00:00:00+10:00
19721226T00:00:00+10:00
and
19761225T14:00:00Z
19721225T14:00:00Z
.
).
19761225T14:00:00Z
19721225T14:00:00Z
The
expression
op:gMonthDayequal(xs:gMonthDay("1225"),
xs:gMonthDay("1226Z"))
returns
.
false
false()
Returns
true
if
the
two
xs:gMonth
values
have
the
same
starting
instant,
when
considered
as
months
in
the
same
year.
Defines
the
semantics
of
the
"eq"
operator
on
xs:gMonth
values.
Also
used
in
the
definition
of
the
"ne"
operator.
op:gMonthequal
(
$arg1
as
xs:gMonth
,
$arg2
as
xs:gMonth
)
as
xs:boolean
Summary:
Returns
true
if
and
only
if
the
xs:dateTime
s
representing
the
starting
instants
of
equivalent
occurrences
of
$arg1
and
$arg2
compare
equal.
The
starting
instants
of
equivalent
occurrences
of
$arg1
and
$arg2
are
calculated
by
adding
supplying
the
missing
components
of
$arg1
and
$arg2
from
an
the
xs:dateTime
template
such
as
or
1972xxddT00:00:00
where
dd
represents
the
last
day
of
the
month
component
in
$arg1
1972xx01T00:00:00
$arg2
.
Returns
false
otherwise.
an
equivalent.
The
two
xs:dateTime
values
representing
function
returns
the
result
of
comparing
these
two
starting
instants
of
equivalent
occurrences
of
$arg1
and
$arg2
are
compared
using
op:dateTimeequal
.
Assume
that
the
dynamic
context
provides
an
implicit
timezone
value
of
05:00
.
Assume,
also,
that
the
xs:dateTime
template
chosen
is
.
1972xx29T00:00:00
1972xx01T00:00:00
The
expression
op:gMonthequal(xs:gMonth("1214:00"),
returns
xs:gMonth("12+10:00")
xs:gMonth("12+10:00"))
.
(
The
starting
instants
are
false
false()
and
19721229T00:00:0014:00
19721201T00:00:0014:00
,
respectively,
and
normalize
to
19721229T00:00:00+10:00
19721201T00:00:00+10:00
and
19721229T14:00:00Z
19721130T14:00:00Z
.
).
19721228T14:00:00Z
19721201T14:00:00Z
The
expression
op:gMonthequal(xs:gMonth("12"),
xs:gMonth("12Z"))
returns
.
false
false()
Returns
true
if
the
two
xs:gDay
values
have
the
same
starting
instant,
when
considered
as
days
in
the
same
month
of
the
same
year.
Defines
the
semantics
of
the
"eq"
operator
on
xs:gDay
values.
Also
used
in
the
definition
of
the
"ne"
operator.
op:gDayequal
(
$arg1
as
xs:gDay
,
$arg2
as
xs:gDay
)
as
xs:boolean
Summary:
Returns
true
if
and
only
if
the
xs:dateTime
s
representing
the
starting
instants
of
equivalent
occurrences
of
$arg1
and
$arg2
compare
equal.
The
starting
instants
of
equivalent
occurrences
of
$arg1
and
$arg2
are
calculated
by
adding
supplying
the
missing
components
of
$arg1
and
$arg2
from
an
the
xs:dateTime
template
such
as
197212xxT00:00:00
.
Returns
false
otherwise.
or
an
equivalent.
The
two
xs:dateTime
values
representing
function
returns
the
result
of
comparing
these
two
starting
instants
of
equivalent
occurrences
of
$arg1
and
$arg2
are
compared
using
op:dateTimeequal
.
Assume
that
the
dynamic
context
provides
an
implicit
timezone
value
of
05:00
.
Assume,
also,
that
the
xs:dateTime
template
is
.
197612xxT00:00:00
197212xxT00:00:00
The
expression
op:gDayequal(xs:gDay("2514:00"),
xs:gDay("25+10:00"))
returns
.
(
The
starting
instants
are
false
false()
19721225T00:00:0014:00
and
19721225T00:00:00+10:00
,
respectively,
and
normalize
to
19721225T14:00:00Z
and
19721224T14:00:00Z
.
).
The
expression
op:gDayequal(xs:gDay("12"),
xs:gDay("12Z"))
returns
.
false
false()
The
duration,
date
and
time
datatypes
may
be
considered
to
be
composite
datatypes
in
that
they
contain
distinct
properties
or
components.
The
extraction
functions
specified
below
extract
a
single
component
from
a
duration,
date
or
time
value.
For
the
date/time
datatypes
In
all
cases
the
local
value
(that
is,
the
original
value
as
written,
without
any
timezone
adjustment)
is
used.
For
Note:
A
time
written
as
xs:duration
24:00:00
and
its
subtypes,
including
the
two
subtypes
is
treated
as
xs:yearMonthDuration
00:00:00
and
xs:dayTimeDuration
,
the
components
are
normalized:
this
means
that
the
seconds
and
minutes
components
will
always
be
less
than
60,
the
hours
component
less
than
24,
and
on
the
months
component
less
than
12.
following
day.
Function  Meaning 

fn:yearfromdateTime

Returns
the
year
xs:dateTime
.

fn:monthfromdateTime

Returns
the
month
xs:dateTime
.

fn:dayfromdateTime

Returns
the
day
xs:dateTime
.

fn:hoursfromdateTime

Returns
the
hours
xs:dateTime
.

fn:minutesfromdateTime

Returns
the
xs:dateTime
.

fn:secondsfromdateTime

Returns
the
seconds
xs:dateTime
.

fn:timezonefromdateTime

Returns
the
timezone
xs:dateTime
.

fn:yearfromdate

Returns
the
year
xs:date
.

fn:monthfromdate

Returns
the
month
xs:date
.

fn:dayfromdate

Returns
the
day
xs:date
.

fn:timezonefromdate

Returns
the
timezone
xs:date
.

fn:hoursfromtime

Returns
the
hours
xs:time
.

fn:minutesfromtime

Returns
the
minutes
xs:time
.

fn:secondsfromtime

Returns
the
seconds
xs:time
.

fn:timezonefromtime

Returns
the
timezone
xs:time
.

Summary:
Returns
an
xs:integer
representing
the
years
year
component
in
the
value
of
$arg
.
The
result
is
obtained
by
casting
$arg
to
an
.
xs:yearMonthDuration
(see
17.1.4
Casting
to
duration
types
)
and
then
computing
the
years
component
as
described
in
10.3.1.3
Canonical
representation
.
The
result
may
be
negative.
If
$arg
is
an
xs:dayTimeDuration
returns
0.
If
$arg
is
the
empty
sequence,
returns
the
empty
sequence.
10.5.1.1
Examples
fn:yearsfromduration(xs:yearMonthDuration("P20Y15M"))
returns
21
.
fn:yearsfromduration(xs:yearMonthDuration("P15M"))
returns
1
.
fn:yearsfromduration(xs:dayTimeDuration("P2DT15H"))
returns
0
xs:dateTime
fn:monthsfromduration
fn:yearfromdateTime
(
$arg
as
xs:duration?
xs:dateTime?
)
as
xs:integer?
If
$arg
is
the
empty
sequence,
returns
the
empty
sequence.
10.5.2.1
Examples
fn:monthsfromduration(xs:yearMonthDuration("P20Y15M"))
returns
3
.
fn:monthsfromduration(xs:yearMonthDuration("P20Y18M"))
returns
6
.
fn:monthsfromduration(xs:dayTimeDuration("P2DT15H0M0S"))
returns
0
.
10.5.3
fn:daysfromduration
fn:daysfromduration
(
$arg
as
xs:duration?
)
as
xs:integer?
Summary:
Returns
an
xs:integer
representing
the
days
component
in
the
value
of
$arg
.
The
result
is
obtained
by
casting
$arg
to
an
xs:dayTimeDuration
(see
17.1.4
Casting
to
duration
types
)
and
then
computing
the
days
component
as
described
in
10.3.2.3
Canonical
representation
.
The
result
may
be
negative.
If
$arg
is
an
xs:yearMonthDuration
returns
0.
If
$arg
is
the
empty
sequence,
function
returns
the
empty
sequence.
fn:daysfromduration(xs:yearMonthDuration("P3Y5M"))
Otherwise,
the
function
returns
0
.
10.5.4
fn:hoursfromduration
fn:hoursfromduration
(
$arg
as
xs:duration?
)
as
xs:integer?
Summary:
Returns
an
xs:integer
representing
the
hours
year
component
in
the
local
value
of
$arg
.
The
result
is
obtained
by
casting
$arg
to
an
xs:dayTimeDuration
(see
17.1.4
Casting
to
duration
types
)
and
then
computing
the
hours
component
as
described
in
10.3.2.3
Canonical
representation
.
The
result
may
be
negative.
The
expression
returns
fn:hoursfromduration(xs:dayTimeDuration("PT123H"))
fn:yearfromdateTime(xs:dateTime("19990531T13:20:0005:00"))
.
3
1999
The
expression
returns
fn:hoursfromduration(xs:dayTimeDuration("P3DT10H"))
fn:yearfromdateTime(xs:dateTime("19990531T21:30:0005:00"))
.
10
1999
Summary:
Returns
an
xs:integer
representing
the
minutes
component
in
the
value
of
$arg
.
The
result
is
obtained
by
casting
$arg
to
an
xs:dayTimeDuration
(see
17.1.4
Casting
to
duration
types
)
and
then
computing
the
minutes
component
as
described
in
10.3.2.3
Canonical
representation
.
The
result
may
be
negative.
If
$arg
is
an
xs:yearMonthDuration
returns
0.
If
$arg
is
the
empty
sequence,
returns
the
empty
sequence.
10.5.5.1
Examples
expression
returns
fn:minutesfromduration(xs:dayTimeDuration("P3DT10H"))
fn:yearfromdateTime(xs:dateTime("19991231T19:20:00"))
.
0
1999
The
expression
returns
fn:minutesfromduration(xs:dayTimeDuration("P5DT12H30M"))
fn:yearfromdateTime(xs:dateTime("19991231T24:00:00"))
.
30
2000
Summary:
Returns
an
xs:decimal
representing
the
seconds
month
component
in
the
value
of
$arg
.
The
result
is
obtained
by
casting
$arg
to
an
xs:dayTimeDuration
(see
17.1.4
Casting
to
duration
types
)
and
then
computing
the
seconds
component
as
described
in
10.3.2.3
Canonical
representation
.
The
result
may
be
negative.
If
$arg
is
an
.
xs:yearMonthDuration
returns
0.
If
$arg
is
the
empty
sequence,
returns
the
empty
sequence.
10.5.6.1
Examples
fn:secondsfromduration(xs:dayTimeDuration("P3DT10H12.5S"))
returns
12.5
.
fn:secondsfromduration(xs:dayTimeDuration("P256S"))
returns
16.0
xs:dateTime
fn:yearfromdateTime
fn:monthfromdateTime
(
$arg
as
xs:dateTime?
)
as
xs:integer?
If
$arg
is
the
empty
sequence,
the
function
returns
the
empty
sequence.
fn:yearfromdateTime(xs:dateTime("19991231T24:00:00"))
Otherwise,
the
function
returns
2000
.
10.5.8
fn:monthfromdateTime
fn:monthfromdateTime
(
$arg
as
xs:dateTime?
)
as
xs:integer?
Summary:
Returns
an
xs:integer
between
1
and
12,
both
inclusive,
representing
the
month
component
in
the
localized
local
value
of
$arg
.
The
expression
fn:monthfromdateTime(xs:dateTime("19990531T13:20:0005:00"))
returns
5
.
The
expression
fn:monthfromdateTime(xs:dateTime("19991231T19:20:0005:00"))
returns
12
.
The
expression
fn:monthfromdateTime(fn:adjustdateTimetotimezone(xs:dateTime("19991231T19:20:0005:00"),
xs:dayTimeDuration("PT0S")))
returns
1
.
Returns
the
day
component
of
an
xs:dateTime
.
fn:dayfromdateTime
(
$arg
as
xs:dateTime?
)
as
xs:integer?
Summary:
Returns
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
local
value
of
$arg
.
The
expression
fn:dayfromdateTime(xs:dateTime("19990531T13:20:0005:00"))
returns
31
.
The
expression
fn:dayfromdateTime(xs:dateTime("19991231T20:00:0005:00"))
returns
31
.
The
expression
fn:dayfromdateTime(fn:adjustdateTimetotimezone(xs:dateTime("19991231T19:20:0005:00"),
xs:dayTimeDuration("PT0S")))
returns
1
.
Returns
the
hours
component
of
an
xs:dateTime
.
fn:hoursfromdateTime
(
$arg
as
xs:dateTime?
)
as
xs:integer?
Summary:
Returns
If
$arg
is
the
empty
sequence,
the
function
returns
the
empty
sequence.
Otherwise,
the
function
returns
an
xs:integer
between
0
and
23,
both
inclusive,
representing
the
hours
component
in
the
localized
local
value
of
$arg
.
The
expression
fn:hoursfromdateTime(xs:dateTime("19990531T08:20:0005:00"))
returns
8
.
The
expression
fn:hoursfromdateTime(xs:dateTime("19991231T21:20:0005:00"))
returns
21
.
The
expression
fn:hoursfromdateTime(fn:adjustdateTimetotimezone(xs:dateTime("19991231T21:20:0005:00"),
xs:dayTimeDuration("PT0S")))
returns
2
.
The
expression
fn:hoursfromdateTime(xs:dateTime("19991231T12:00:00"))
returns
12
.
The
expression
fn:hoursfromdateTime(xs:dateTime("19991231T24:00:00"))
returns
0
.
Returns
the
minute
component
of
an
xs:dateTime
.
fn:minutesfromdateTime
(
$arg
as
xs:dateTime?
)
as
xs:integer?
Summary:
Returns
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
localized
local
value
of
$arg
.
The
expression
fn:minutesfromdateTime(xs:dateTime("19990531T13:20:0005:00"))
returns
20
.
.
The
expression
fn:minutesfromdateTime(xs:dateTime("19990531T13:30:00+05:30"))
returns
30
.
.
Returns
the
seconds
component
of
an
xs:dateTime
.
fn:secondsfromdateTime
(
$arg
as
xs:dateTime?
)
as
xs:decimal?
Summary:
Returns
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
localized
local
value
of
$arg
.
The
expression
fn:secondsfromdateTime(xs:dateTime("19990531T13:20:0005:00"))
returns
0
.
Returns
the
timezone
component
of
an
xs:dateTime
.
fn:timezonefromdateTime
(
$arg
as
xs:dateTime?
)
as
xs:dayTimeDuration?
Summary:
Returns
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.
Otherwise,
the
result
is
the
empty
sequence.
If
$arg
is
has
no
timezone
component,
the
empty
sequence,
returns
result
is
the
empty
sequence.
The
expression
fn:timezonefromdateTime(xs:dateTime("19990531T13:20:0005:00"))
returns
the
xs:dayTimeDuration
whose
value
is
.
PT5H
xs:dayTimeDuration("PT5H")
The
expression
fn:timezonefromdateTime(xs:dateTime("20000612T13:20:00Z"))
returns
the
.
xs:dayTimeDuration
whose
value
is
PT0S
xs:dayTimeDuration("PT0S")
The
expression
fn:timezonefromdateTime(xs:dateTime("20040827T00:00:00"))
returns
()
.
Returns
the
year
component
of
an
xs:date
.
fn:yearfromdate
(
$arg
as
xs:date?
)
as
xs:integer?
Summary:
Returns
If
$arg
is
the
empty
sequence,
the
function
returns
the
empty
sequence.
Otherwise,
the
function
returns
an
xs:integer
representing
the
year
in
the
localized
local
value
of
$arg
.
The
value
may
be
negative.
The
expression
fn:yearfromdate(xs:date("19990531"))
returns
1999
.
The
expression
fn:yearfromdate(xs:date("20000101+05:00"))
returns
2000
.
Returns
the
month
component
of
an
xs:date
.
fn:monthfromdate
(
$arg
as
xs:date?
)
as
xs:integer?
Summary:
Returns
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
localized
local
value
of
$arg
.
The
expression
fn:monthfromdate(xs:date("1999053105:00"))
returns
5
.
.
The
expression
fn:monthfromdate(xs:date("20000101+05:00"))
returns
1
.
Returns
the
day
component
of
an
xs:date
.
fn:dayfromdate
(
$arg
as
xs:date?
)
as
xs:integer?
Summary:
Returns
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:dayfromdate(xs:date("1999053105:00"))
returns
31
.
The
expression
fn:dayfromdate(xs:date("20000101+05:00"))
returns
1
.
Returns
the
timezone
component
of
an
xs:date
.
fn:timezonefromdate
(
$arg
as
xs:date?
)
as
xs:dayTimeDuration?
Summary:
Returns
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.
Otherwise,
the
result
is
the
empty
sequence.
If
$arg
is
has
no
timezone
component,
the
empty
sequence,
returns
result
is
the
empty
sequence.
The
expression
fn:timezonefromdate(xs:date("1999053105:00"))
returns
the
xs:dayTimeDuration
whose
value
is
.
PT5H
xs:dayTimeDuration("PT5H")
The
expression
fn:timezonefromdate(xs:date("20000612Z"))
returns
the
xs:dayTimeDuration
with
value
.
PT0S
xs:dayTimeDuration("PT0S")
Returns
the
hours
component
of
an
xs:time
.
fn:hoursfromtime
(
$arg
as
xs:time?
)
as
xs:integer?
Summary:
Returns
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
localized
local
value
of
$arg
.
Assume
that
the
dynamic
context
provides
an
implicit
timezone
value
of
05:00
.
The
expression
fn:hoursfromtime(xs:time("11:23:00"))
returns
11
.
The
expression
fn:hoursfromtime(xs:time("21:23:00"))
returns
21
.
The
expression
fn:hoursfromtime(xs:time("01:23:00+05:00"))
returns
1
.
The
expression
fn:hoursfromtime(fn:adjusttimetotimezone(xs:time("01:23:00+05:00"),
xs:dayTimeDuration("PT0S")))
returns
20
.
The
expression
fn:hoursfromtime(xs:time("24:00:00"))
returns
0
.
Returns
the
minutes
component
of
an
xs:time
.
fn:minutesfromtime
(
$arg
as
xs:time?
)
as
xs:integer?
Summary:
Returns
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
localized
local
value
of
$arg
.
The
expression
fn:minutesfromtime(xs:time("13:00:00Z"))
returns
0
.
.
Returns
the
seconds
component
of
an
xs:time
.
fn:secondsfromtime
(
$arg
as
xs:time?
)
as
xs:decimal?
Summary:
Returns
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
localized
local
value
of
$arg
.
The
expression
fn:secondsfromtime(xs:time("13:20:10.5"))
returns
10.5
.
Returns
the
timezone
component
of
an
xs:time
.
fn:timezonefromtime
(
$arg
as
xs:time?
)
as
xs:dayTimeDuration?
Summary:
Returns
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.
Otherwise,
the
result
is
the
empty
sequence.
If
$arg
is
has
no
timezone
component,
the
empty
sequence,
returns
result
is
the
empty
sequence.
The
expression
fn:timezonefromtime(xs:time("13:20:0005:00"))
returns
.
xs:dayTimeDuration
whose
value
is
PT5H
xs:dayTimeDuration("PT5H")
The
expression
fn:timezonefromtime(xs:time("13:20:00"))
returns
()
.
Function  Meaning 

fn:adjustdateTimetotimezone

Adjusts
an
xs:dateTime
value
to
a
specific
timezone,
or
to
no
timezone
at
all.

fn:adjustdatetotimezone

Adjusts
an
xs:date
value
to
a
specific
timezone,
or
to
no
timezone
at

fn:adjusttimetotimezone

Adjusts
an
xs:time
value
to
a
specific
timezone,
or
to
no
timezone
at
all.

These
functions
adjust
the
timezone
component
of
an
xs:dateTime
,
xs:date
or
xs:time
value.
The
$timezone
argument
to
these
functions
is
defined
as
an
xs:dayTimeDuration
but
must
be
a
valid
timezone
value.
Adjusts
an
xs:dateTime
value
to
a
specific
timezone,
or
to
no
timezone
at
all.
fn:adjustdateTimetotimezone
(
$arg
as
xs:dateTime?
)
as
xs:dateTime?
xs:dateTime
fn:adjustdateTimetotimezone
(

$arg

as
xs:dateTime?
,

$timezone

as
xs:dayTimeDuration?
)
as

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
result
is
function
returns
the
empty
sequence.
A
dynamic
error
is
raised
[
err:FODT0003
]
if
$timezone
is
less
than
PT14H
or
greater
than
PT14H
or
if
does
not
contain
an
integral
number
of
minutes.
If
$arg
does
not
have
a
timezone
component
and
$timezone
is
the
empty
sequence,
then
the
result
is
$arg
.
If
$arg
does
not
have
a
timezone
component
and
$timezone
is
not
the
empty
sequence,
then
the
result
is
$arg
with
$timezone
as
the
timezone
component.
If
$arg
has
a
timezone
component
and
$timezone
is
the
empty
sequence,
then
the
result
is
the
localized
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
an
the
xs:dateTime
value
with
a
timezone
component
of
$timezone
that
is
equal
to
$arg
and
that
has
a
timezone
component
equal
to
$timezone
.
A
dynamic
error
is
raised
[
err:FODT0003
10.7.1.1
]
if
$timezone
is
less
than
PT14H
or
greater
than
PT14H
or
is
not
an
integral
number
of
minutes.
Assume
the
dynamic
context
provides
an
implicit
timezone
of
05:00
(PT5H0M)
.
let
$tz
$tz10
:=
xs:dayTimeDuration("PT10H")
The
expression
returns
fn:adjustdateTimetotimezone(xs:dateTime("20020307T10:00:00"))
fn:adjustdateTimetotimezone(xs:dateTime('20020307T10:00:00'))
.
20020307T10:00:0005:00
xs:dateTime('20020307T10:00:0005:00')
The
expression
returns
fn:adjustdateTimetotimezone(xs:dateTime("20020307T10:00:0007:00"))
fn:adjustdateTimetotimezone(xs:dateTime('20020307T10:00:0007:00'))
.
20020307T12:00:0005:00
xs:dateTime('20020307T12:00:0005:00')
The
expression
returns
fn:adjustdateTimetotimezone(xs:dateTime("20020307T10:00:00"),
$tz)
fn:adjustdateTimetotimezone(xs:dateTime('20020307T10:00:00'),
$tz10)
.
20020307T10:00:0010:00
xs:dateTime('20020307T10:00:0010:00')
The
expression
returns
fn:adjustdateTimetotimezone(xs:dateTime("20020307T10:00:0007:00"),
$tz)
fn:adjustdateTimetotimezone(xs:dateTime('20020307T10:00:0007:00'),
$tz10)
.
20020307T07:00:0010:00
xs:dateTime('20020307T07:00:0010:00')
The
expression
returns
fn:adjustdateTimetotimezone(xs:dateTime("20020307T10:00:0007:00"),
fn:adjustdateTimetotimezone(xs:dateTime('20020307T10:00:0007:00'),
xs:dayTimeDuration("PT10H"))
.
20020308T03:00:00+10:00
xs:dateTime('20020308T03:00:00+10:00')
The
expression
returns
fn:adjustdateTimetotimezone(xs:dateTime("20020307T00:00:00+01:00"),
fn:adjustdateTimetotimezone(xs:dateTime('20020307T00:00:00+01:00'),
xs:dayTimeDuration("PT8H"))
.
20020306T15:00:0008:00
xs:dateTime('20020306T15:00:0008:00')
The
expression
returns
fn:adjustdateTimetotimezone(xs:dateTime("20020307T10:00:00"),
fn:adjustdateTimetotimezone(xs:dateTime('20020307T10:00:00'),
())
.
20020307T10:00:00
xs:dateTime('20020307T10:00:00')
The
expression
returns
fn:adjustdateTimetotimezone(xs:dateTime("20020307T10:00:0007:00"),
fn:adjustdateTimetotimezone(xs:dateTime('20020307T10:00:0007:00'),
())
.
20020307T10:00:00
xs:dateTime('20020307T10:00:00')
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.
fn:adjustdatetotimezone
(
$arg
as
xs:date?
)
as
xs:date?
fn:adjustdatetotimezone
(

$arg

as
xs:date?
,

$timezone

as
xs:dayTimeDuration?
)
as
xs:date?

If
$timezone
is
not
specified,
then
the
effective
value
of
$timezone
is
the
value
of
the
implicit
timezone
in
the
dynamic
context.
If
$arg
is
the
empty
sequence,
then
the
result
is
function
returns
the
empty
sequence.
A
dynamic
error
is
raised
[
err:FODT0003
]
if
$timezone
is
less
than
PT14H
or
greater
than
PT14H
or
if
does
not
contain
an
integral
number
of
minutes.
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
localized
local
value
of
$arg
without
its
timezone
component.
If
$arg
has
a
timezone
component
and
$timezone
is
not
the
empty
sequence,
then:
then
the
function
returns
the
value
of
the
expression:
Let
be
$srcdt
$dt
an
xs:dateTime
value,
with
00:00:00
for
the
time
component
and
date
and
timezone
components
that
are
the
same
as
the
date
and
timezone
components
value
of
.
$arg
.
fn:dateTime($arg,
xs:time('00:00:00'))
Let
be
the
$r
$adt
result
value
of
evaluating
fn:adjustdateTimetotimezone($srcdt,
fn:adjustdateTimetotimezone($dt,
$timezone)
The
result
of
this
function
will
be
a
date
value
that
has
date
and
timezone
components
that
are
the
same
as
returns
the
date
and
timezone
components
value
of
$r
.
xs:date($adt)
Editorial note  
I suspect this procedure actually gives the right result in all cases, so the whole description can be simplified. 
A
dynamic
error
is
raised
[
err:FODT0003
10.7.2.1
]
if
$timezone
is
less
than
PT14H
or
greater
than
PT14H
or
is
not
an
integral
number
of
minutes.
Assume
the
dynamic
context
provides
an
implicit
timezone
of
05:00
(PT5H0M)
.
let
$tz
$tz10
:=
xs:dayTimeDuration("PT10H")
The
expression
fn:adjustdatetotimezone(xs:date("20020307"))
returns
.
2002030705:00.
xs:date("2002030705:00")
The
expression
fn:adjustdatetotimezone(xs:date("2002030707:00"))
returns
.
(
2002030705:00
xs:date("2002030705:00")
$arg
is
converted
to
the
.
This
is
adjusted
to
the
implicit
timezone,
giving
xs:dateTime
"20020307T00:00:0007:00"
xs:dateTime("20020307T00:00:0007:00")
.
).
"20020307T02:00:0005:00".
"20020307T02:00:0005:00"
The
expression
fn:adjustdatetotimezone(xs:date("20020307"),
returns
$tz)
$tz10)
.
2002030710:00
xs:date("2002030710:00")
The
expression
fn:adjustdatetotimezone(xs:date("2002030707:00"),
returns
$tz)
$tz10)
.
(
2002030610:00
xs:date("2002030610:00")
$arg
is
converted
to
the
xs:dateTime
"20020307T00:00:0007:00"
.
This
is
adjusted
to
the
given
timezone,
giving
"20020306T21:00:0010:00"
.
).
The
expression
fn:adjustdatetotimezone(xs:date("20020307"),
())
returns
.
20020307.
xs:date("20020307")
The
expression
fn:adjustdatetotimezone(xs:date("2002030707:00"),
())
returns
.
20020307.
xs:date("20020307")
Adjusts
an
xs:time
value
to
a
specific
timezone,
or
to
no
timezone
at
all.
fn:adjusttimetotimezone
(
$arg
as
xs:time?
)
as
xs:time?
fn:adjusttimetotimezone
(

$arg

as
xs:time?
,

$timezone

as
xs:dayTimeDuration?
)
as
xs:time?

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
result
is
function
returns
the
empty
sequence.
A
dynamic
error
is
raised
[
err:FODT0003
]
if
$timezone
is
less
than
PT14H
or
greater
than
PT14H
or
if
does
not
contain
an
integral
number
of
minutes.
If
$arg
does
not
have
a
timezone
component
and
$timezone
is
the
empty
sequence,
then
the
result
is
$arg
.
If
$arg
does
not
have
a
timezone
component
and
$timezone
is
not
the
empty
sequence,
then
the
result
is
$arg
with
$timezone
as
the
timezone
component.
If
$arg
has
a
timezone
component
and
$timezone
is
the
empty
sequence,
then
the
result
is
the
localized
value
of
$arg
without
its
timezone
component.
If
$arg
has
a
timezone
component
and
$timezone
is
not
the
empty
sequence,
then:
Let
be
$srcdt
$dt
an
the
xs:dateTime
value,
with
an
arbitrary
date
for
the
date
component
and
time
and
timezone
components
that
are
the
same
as
the
time
and
timezone
components
of
value
.
$arg
.
fn:dateTime(xs:date('19721231'),
$arg)
Let
be
the
$r
$adt
result
value
of
evaluating
fn:adjustdateTimetotimezone($srcdt,
fn:adjustdateTimetotimezone($dt,
$timezone)
The
result
of
this
function
will
be
a
time
value
that
has
time
and
timezone
components
that
are
the
same
as
returns
the
time
and
timezone
components
of
value
$r
xs:time
xs:time($adt)
.
A
dynamic
error
is
raised
[
err:FODT0003
10.7.3.1
]
if
$timezone
is
less
than
PT14H
or
greater
than
PT14H
or
if
does
not
contain
an
integral
number
of
minutes.
Assume
the
dynamic
context
provides
an
implicit
timezone
of
05:00
(PT5H0M)
.
let
$tz
$tz10
:=
xs:dayTimeDuration("PT10H")
The
expression
fn:adjusttimetotimezone(xs:time("10:00:00"))
returns
.
10:00:0005:00
xs:time("10:00:0005:00")
The
expression
fn:adjusttimetotimezone(xs:time("10:00:0007:00"))
returns
.
12:00:0005:00
xs:time("12:00:0005:00")
The
expression
fn:adjusttimetotimezone(xs:time("10:00:00"),
returns
$tz)
$tz10)
.
10:00:0010:00
xs:time("10:00:0010:00")
The
expression
fn:adjusttimetotimezone(xs:time("10:00:0007:00"),
returns
$tz)
$tz10)
.
07:00:0010:00
xs:time("07:00:0010:00")
The
expression
fn:adjusttimetotimezone(xs:time("10:00:00"),
())
returns
.
10:00:00
xs:time("10:00:00")
The
expression
fn:adjusttimetotimezone(xs:time("10:00:0007:00"),
())
returns
.
10:00:00
xs:time("10:00:00")
The
expression
fn:adjusttimetotimezone(xs:time("10:00:0007:00"),
xs:dayTimeDuration("PT10H"))
returns
.
03:00:00+10:00
xs:time("03:00:00+10:00")
These
functions
support
adding
or
subtracting
a
duration
value
to
or
from
an
xs:dateTime
,
an
xs:date
or
an
xs:time
value.
Appendix
E
of
[XML
Schema
Part
2:
Datatypes
Second
Edition]
describes
an
algorithm
for
performing
such
operations.
Function  Meaning 

op:subtractdateTimes

Returns
an
xs:dayTimeDuration
representing
the
.

op:subtractdates

Returns
the
xs:dayTimeDuration
that
corresponds
to
the
elapsed
time
between
.

op:subtracttimes

Returns
the
xs:dayTimeDuration
that
corresponds
to
the
elapsed
time
between
treated
as
times
on
the
same
date.

op:addyearMonthDurationtodateTime

Returns
the
xs:dateTime

op:adddayTimeDurationtodateTime

Returns
the
xs:dateTime

op:subtractyearMonthDurationfromdateTime

Returns
the
xs:dateTime

op:subtractdayTimeDurationfromdateTime

Returns
the
xs:dateTime

op:addyearMonthDurationtodate

Returns
the
xs:date

op:adddayTimeDurationtodate

Returns
the
xs:date

op:subtractyearMonthDurationfromdate

Returns
the
xs:date

op:subtractdayTimeDurationfromdate

Returns
the
xs:date

op:adddayTimeDurationtotime

xs:time

op:subtractdayTimeDurationfromtime

xs:time

Returns
an
xs:dayTimeDuration
representing
the
amount
of
elapsed
time
between
the
instants
arg2
and
arg1
.
Defines
the
semantics
of
the
""
operator
on
xs:dateTime
values.
op:subtractdateTimes
(

$arg1

as
xs:dateTime
,

$arg2

as
xs:dateTime
)
as

Summary:
Returns
the
xs:dayTimeDuration
that
corresponds
to
the
difference
between
the
normalized
value
of
$arg1
and
the
normalized
value
of
$arg2
.
If
either
$arg1
or
$arg2
do
not
contain
an
explicit
timezone
then,
for
the
purpose
of
the
operation,
the
implicit
timezone
provided
by
the
dynamic
context
(See
Section
C.2
Dynamic
Context
Components
^{
XP
}.)
is
assumed
to
be
present
as
part
of
the
value.
The
function
returns
the
elapsed
time
between
the
date/time
instant
arg2
and
the
date/time
instant
arg1
,
computed
according
to
the
algorithm
given
in
Appendix
E
of
[XML
Schema
Part
2:
Datatypes
Second
Edition]
,
and
expressed
as
a
xs:dayTimeDuration
.
If
the
normalized
value
of
$arg1
precedes
in
time
the
normalized
value
of
$arg2
,
then
the
returned
value
is
a
negative
duration.
Assume
that
the
dynamic
context
provides
an
implicit
timezone
value
of
05:00
.
The
expression
op:subtractdateTimes(xs:dateTime("20001030T06:12:00"),
xs:dateTime("19991128T09:00:00Z"))
returns
an
.
xs:dayTimeDuration
value
corresponding
to
337
days,
2
hours
and
12
minutes.
xs:dayTimeDuration("P337DT2H12M")
Returns
the
xs:dayTimeDuration
that
corresponds
to
the
elapsed
time
between
the
starting
instant
of
$arg2
and
the
the
starting
instant
of
$arg2
.
Defines
the
semantics
of
the
""
operator
on
xs:date
values.
op:subtractdates
(
$arg1
as
xs:date
,
$arg2
as
xs:date
)
as
xs:dayTimeDuration?
xs:dayTimeDuration
Summary:
Returns
the
xs:dayTimeDuration
that
corresponds
to
the
difference
between
the
starting
instant
of
$arg1
and
the
the
starting
instant
of
$arg2
.
If
either
$arg1
or
$arg2
do
not
contain
an
explicit
timezone
then,
for
the
purpose
of
the
operation,
the
implicit
timezone
provided
by
the
dynamic
context
(See
Section
C.2
Dynamic
Context
Components
^{
XP
}.)
is
assumed
to
be
present
as
part
of
the
value.
The
starting
instant
of
an
xs:date
is
the
xs:dateTime
at
00:00:00
on
that
date.
The
result
is
function
returns
the
result
of
subtracting
the
two
starting
instants
using
op:subtractdateTimes
.
If
the
starting
instant
of
$arg1
precedes
in
time
the
starting
instant
of
$arg2
,
then
the
returned
value
is
a
negative
duration.
Assume
that
the
dynamic
context
provides
an
implicit
timezone
value
of
Z
.
The
expression
op:subtractdates(xs:date("20001030"),
xs:date("19991128"))
returns
an
.
(The
normalized
values
of
the
two
starting
instants
are
xs:dayTimeDuration
value
corresponding
to
337
days.
The
xs:dayTimeDuration("P337D")
{2000,
10,
30,
0,
0,
0,
PT0S}
and
{1999,
11,
28,
0,
0,
0,
PT0S}
.).
.
If
Now
assume
that
the
dynamic
context
provides
an
implicit
timezone
value
of
+05:00
.
,
The
expression
op:subtractdates(xs:date("20001030"),
xs:date("19991128Z"))
returns
an
.
(
The
normalized
values
of
the
two
starting
instants
are
xs:dayTimeDuration
value
corresponding
to
336
days
and
19
hours.
xs:dayTimeDuration("P336DT19H")
{2000,
10,
29,
19,
0,
0,
PT0S}
and
{1999,
11,
28,
0,
0,
0,
PT0S}
.).
.
The
expression
op:subtractdates(xs:date("2000101505:00"),
xs:date("20001010+02:00"))
returns
an
.
xs:dayTimeDuration
value
corresponding
to
lexical
form
"
P5DT7H
".
xs:dayTimeDuration("P5DT7H")
Returns
the
xs:dayTimeDuration
that
corresponds
to
the
elapsed
time
between
the
values
of
$arg2
and
$arg1
treated
as
times
on
the
same
date.
Defines
the
semantics
of
the
""
operator
on
xs:time
values.
op:subtracttimes
(
$arg1
as
xs:time
,
$arg2
as
xs:time
)
as
xs:dayTimeDuration
The
result
is
function
returns
the
result
of
subtracting
the
two
xs:dateTime
s
using
op:subtractdateTimes
.
expression:
opsubtractdateTimes( fn:dateTime(xs:date('19721231'), $arg1), fn:dateTime(xs:date('19721231'), $arg2))
If
the
value
of
$arg1
converted
to
an
xs:dateTime
using
the
date
components
from
the
Any
other
reference
xs:dateTime
precedes
in
time
the
value
of
$arg2
converted
to
an
xs:dateTime
using
the
date
components
from
the
same
reference
xs:dateTime
,
then
the
returned
value
is
a
negative
duration.
Backs
up
the
subtract,
"",
operator
on
xs:time
values.
would
work
equally
well.
Assume
that
the
dynamic
context
provides
an
implicit
timezone
value
of
05:00
.
Assume,
also,
that
the
date
components
of
the
reference
xs:dateTime
correspond
to
"19721231"
.
The
expression
op:subtracttimes(xs:time("11:12:00Z"),
xs:time("04:00:00"))
returns
an
.
(This
is
obtained
by
subtracting
from
the
xs:dayTimeDuration
value
corresponding
to
2
hours
and
12
minutes.
This
xs:dayTimeDuration("PT2H12M")
xs:dateTime
value
{1972,
12,
31,
11,
12,
0,
PT0S}
the
xs:dateTime
value
{1972,
12,
31,
9,
0,
0,
PT0S}
.).
.
The
expression
op:subtracttimes(xs:time("11:00:0005:00"),
xs:time("21:30:00+05:30"))
returns
a
zero
xs:dayTimeDuration
value
corresponding
to
the
lexical
representation
.
"PT0S"
xs:dayTimeDuration("PT0S")
The
(The
two
xs:dateTime
values
are
{1972,
12,
31,
11,
0,
0,
PT5H}
and
{1972,
12,
31,
21,
30,
0,
PT5H30M}
.
These
normalize
to
{1972,
12,
31,
16,
0,
0,
PT0S}
and
{1972,
12,
31,
16,
0,
0,
PT0S}
.
).
The
expression
op:subtracttimes(xs:time("17:00:0006:00"),
xs:time("08:00:00+09:00"))
returns
an
.
(The
two
normalized
xs:dayTimeDuration
value
corresponding
to
one
day
or
24
hours.
The
xs:dayTimeDuration("P1D")
xs:dateTime
values
are
{1972,
12,
31,
23,
0,
0,
PT0S}
and
{1972,
12,
30,
23,
0,
0,
PT0S}
.).
.
The
expression
op:subtracttimes(xs:time("24:00:00"),
xs:time("23:59:59"))
returns
an
xs:dayTimeDuration
value
corresponding
to
.
"PT23H59M59S"
xs:dayTimeDuration("PT23H59M59S")
The
(The
two
normalized
xs:dateTime
values
are
{1972,
12,
31,
0,
0,
0,
()}
and
{1972,
12,
31,
23,
59,
59.0,
()}
.).
.
Returns
the
xs:dateTime
that
is
a
given
duration
after
a
specified
xs:dateTime
(or
before,
if
the
duration
is
negative).
Defines
the
semantics
of
the
"+"
operator
on
xs:dateTime
and
xs:yearMonthDuration
values.
op:addyearMonthDurationtodateTime
(

$arg1

as
xs:dateTime
,

$arg2

as
xs:yearMonthDuration
)
as
xs:dateTime

Summary:
Returns
The
function
returns
the
xs:dateTime
computed
by
result
of
adding
$arg2
to
the
value
of
$arg1
using
the
algorithm
described
in
Appendix
E
of
[XML
Schema
Part
2:
Datatypes
Second
Edition]
,
disregarding
the
rule
about
leap
seconds.
If
$arg2
is
negative,
then
the
result
xs:dateTime
precedes
$arg1
.
The
result
has
the
same
timezone
as
$arg1
.
If
$arg1
has
no
timezone,
the
result
has
no
timezone.
The
expression
op:addyearMonthDurationtodateTime(xs:dateTime("20001030T11:12:00"),
xs:yearMonthDuration("P1Y2M"))
returns
an
.
xs:dateTime
value
corresponding
to
the
lexical
representation
"20011230T11:12:00"
xs:dateTime("20011230T11:12:00")
Returns
the
xs:dateTime
that
is
a
given
duration
after
a
specified
xs:dateTime
(or
before,
if
the
duration
is
negative).
Defines
the
semantics
of
the
"+"
operator
on
xs:dateTime
and
xs:dayTimeDuration
values.
op:adddayTimeDurationtodateTime
(

$arg1

as
xs:dateTime
,

$arg2

as
xs:dayTimeDuration
)
as
xs:dateTime

Summary:
Returns
The
function
returns
the
xs:dateTime
computed
by
result
of
adding
$arg2
to
the
value
of
$arg1
using
the
algorithm
described
in
Appendix
E
of
[XML
Schema
Part
2:
Datatypes
Second
Edition]
,
disregarding
the
rule
about
leap
seconds.
If
$arg2
is
negative,
then
the
result
xs:dateTime
precedes
$arg1
.
The
result
has
the
same
timezone
as
$arg1
.
If
$arg1
has
no
timezone,
the
result
has
no
timezone.
The
expression
op:adddayTimeDurationtodateTime(xs:dateTime("20001030T11:12:00"),
xs:dayTimeDuration("P3DT1H15M"))
returns
an
.
xs:dateTime
value
corresponding
to
the
lexical
representation
"20001102T12:27:00"
xs:dateTime("20001102T12:27:00")
Returns
the
xs:dateTime
that
is
a
given
duration
before
a
specified
xs:dateTime
(or
after,
if
the
duration
is
negative).
Defines
the
semantics
of
the
""
operator
on
xs:dateTime
and
xs:yearMonthDuration
values.
op:subtractyearMonthDurationfromdateTime
(

$arg1

as
xs:dateTime
,

$arg2

as
xs:yearMonthDuration
)
as
xs:dateTime

Summary:
Returns
The
function
returns
the
xs:dateTime
computed
by
negating
$arg2
and
adding
the
result
to
the
value
of
$arg1
using
the
algorithm
described
in
Appendix
E
of
[XML
Schema
Part
2:
Datatypes
Second
Edition]
disregarding
the
rule
about
leap
seconds.
If
function
$arg2
op:addyearMonthDurationtodateTime
is
negative,
then
the
.
The
expression
xs:dateTime
op:subtractyearMonthDurationfromdateTime(xs:dateTime("20001030T11:12:00"),
xs:yearMonthDuration("P1Y2M"))
returned
follows
returns
.
$arg1
xs:dateTime("19990830T11:12:00")
The
result
has
Returns
the
same
timezone
as
that
is
a
given
duration
before
a
specified
$arg1
.
If
xs:dateTime
$arg1
xs:dateTime
has
no
timezone,
(or
after,
if
the
result
has
no
timezone.
duration
is
negative).
This
functions
backs
up
Defines
the
semantics
of
the
""
operator
on
xs:dateTime
and
values.
xs:yearMonthDuration
xs:dayTimeDuration
op:subtractdayTimeDurationfromdateTime
(

$arg1

as
xs:dateTime
,

$arg2

as
xs:dayTimeDuration
)
as
xs:dateTime

Summary:
Returns
The
function
returns
the
xs:dateTime
computed
by
negating
$arg2
and
adding
the
result
to
the
value
of
$arg1
using
the
algorithm
described
in
Appendix
E
of
[XML
Schema
Part
2:
Datatypes
Second
Edition]
disregarding
the
rule
about
leap
seconds.
If
function
$arg2
op:adddayTimeDurationtodateTime
is
negative,
then
the
.
The
expression
xs:dateTime
op:subtractdayTimeDurationfromdateTime(xs:dateTime("20001030T11:12:00"),
xs:dayTimeDuration("P3DT1H15M"))
returned
follows
returns
.
$arg1
xs:dateTime("20001027T09:57:00")
The
result
has
Returns
the
same
timezone
as
that
is
a
given
duration
after
a
specified
$arg1
.
If
xs:date
$arg1
xs:date
has
no
timezone,
(or
before,
if
the
result
has
no
timezone.
duration
is
negative).
This
functions
backs
up
Defines
the
""
semantics
of
the
"+"
operator
on
and
xs:dateTime
xs:date
values.
xs:dayTimeDuration
xs:yearMonthDuration
op:addyearMonthDurationtodate
(

$arg1

as
xs:date
,

$arg2

as
xs:yearMonthDuration
)
as
xs:date

Summary:
Returns
the
xs:date
computed
by
adding
$arg2
to
The
function
returns
the
starting
instant
result
of
casting
$arg1
using
the
algorithm
described
in
Appendix
E
of
[XML
Schema
Part
2:
Datatypes
Second
Edition]
and
discarding
the
time
components
from
the
resulting
to
an
xs:dateTime
,
adding
.
If
$arg2
is
negative,
then
using
the
function
xs:date
op:addyearMonthDurationtodateTime
returned
precedes
,
and
casting
the
result
back
to
an
.
$arg1
xs:date
The
starting
instant
of
an
xs:date
is
the
expression
xs:dateTime
op:addyearMonthDurationtodate(xs:date("20001030"),
xs:yearMonthDuration("P1Y2M"))
at
time
returns
.
00:00:00
on
that
date.
xs:date("20011230")
The
result
has
Returns
the
same
timezone
as
that
is
a
given
duration
after
a
specified
$arg1
.
If
xs:date
$arg1
xs:date
has
no
timezone,
(or
before,
if
the
result
has
no
timezone.
duration
is
negative).
This
functions
backs
up
Defines
the
semantics
of
the
"+"
operator
on
xs:date
and
values.
xs:yearMonthDuration
xs:dayTimeDuration
op:adddayTimeDurationtodate
(

$arg1

as
xs:date
,

$arg2

as
xs:dayTimeDuration
)
as
xs:date

Summary:
Returns
the
xs:date
computed
by
adding
$arg2
to
The
function
returns
the
starting
instant
result
of
casting
$arg1
using
the
algorithm
described
in
Appendix
E
of
[XML
Schema
Part
2:
Datatypes
Second
Edition]
and
discarding
the
time
components
from
the
resulting
xs:dateTime
.
If
$arg2
is
negative,
then
the
xs:date
returned
precedes
$arg1
.
The
starting
instant
of
to
an
,
adding
xs:date
is
the
xs:dateTime
at
time
00:00:00
$arg2
on
that
date.
The
result
has
using
the
same
timezone
as
$arg1
.
If
function
$arg1
op:adddayTimeDurationtodateTime
has
no
timezone,
,
and
casting
the
result
has
no
timezone.
This
functions
backs
up
the
"+"
operator
on
back
to
an
xs:date
.
and
xs:dayTimeDuration
values.
The
expression
op:adddayTimeDurationtodate(xs:date("20041030Z"),
xs:dayTimeDuration("P2DT2H30M0S"))
returns
the
.
(
The
starting
instant
of
the
first
argument
is
the
xs:date
November
1,
2004.
xs:date("20041101Z")
xs:dateTime
value
{2004,
10,
30,
0,
0,
0,
PT0S}
.
Adding
the
second
argument
to
this,
this
gives
the
xs:dateTime
value
{2004,
11,
1,
2,
30,
0,
PT0S}
.
The
time
components
are
then
discarded.
).
Returns
the
xs:date
that
is
a
given
duration
before
a
specified
xs:date
(or
after,
if
the
duration
is
negative).
Defines
the
semantics
of
the
""
operator
on
xs:date
and
xs:yearMonthDuration
values.
op:subtractyearMonthDurationfromdate
(

$arg1

as
xs:date
,

$arg2

as
xs:yearMonthDuration
)
as
xs:date

Summary:
Returns
the
xs:date
computed
by
negating
$arg2
and
adding
the
result
to
the
starting
instant
of
$arg1
using
the
algorithm
described
in
Appendix
E
of
[XML
Schema
Part
2:
Datatypes
Second
Edition]
and
discarding
the
time
components
from
the
resulting
xs:dateTime
.
If
$arg2
is
positive,
then
the
xs:date
returned
precedes
$arg1
.
The
starting
instant
of
an
xs:date
is
the
xs:dateTime
at
00:00:00
on
that
date.
The
result
has
the
same
timezone
as
$arg1
.
If
$arg1
has
no
timezone,
the
result
has
no
timezone.
This
functions
backs
up
the
""
operator
on
xs:date
and
function
xs:yearMonthDuration
op:addyearMonthDurationtodate
values.
10.8.10.1
.
The
expression
op:subtractyearMonthDurationfromdate(xs:date("20001030"),
xs:yearMonthDuration("P1Y2M"))
returns
the
.
xs:date
August
30,
1999.
xs:date("19990830")
The
expression
op:subtractyearMonthDurationfromdate(xs:date("20000229Z"),
xs:yearMonthDuration("P1Y"))
returns
the
xs:date
February
28,
1999
in
timezone
.
Z
xs:date("19990228Z")
The
expression
op:subtractyearMonthDurationfromdate(xs:date("2000103105:00"),
xs:yearMonthDuration("P1Y1M"))
returns
the
xs:date
September
30,
1999
in
timezone
.
05:00
xs:date("1999093005:00")
Returns
the
xs:date
that
is
a
given
duration
before
a
specified
xs:date
(or
after,
if
the
duration
is
negative).
Defines
the
semantics
of
the
""
operator
on
xs:date
and
xs:dayTimeDuration
values.
op:subtractdayTimeDurationfromdate
(

$arg1

as
xs:date
,

$arg2

as
xs:dayTimeDuration
)
as
xs:date

Summary:
Returns
the
xs:date
computed
by
negating
$arg2
and
adding
the
result
to
the
starting
instant
of
$arg1
using
the
algorithm
described
in
Appendix
E
of
[XML
Schema
Part
2:
Datatypes
Second
Edition]
and
discarding
the
time
components
from
the
resulting
xs:dateTime
.
If
$arg2
is
positive,
then
the
function
xs:date
op:adddayTimeDurationtodate
returned
precedes
$arg1
.
.
The
starting
instant
of
an
xs:date
is
the
expression
xs:dateTime
op:subtractdayTimeDurationfromdate(xs:date("20001030"),
xs:dayTimeDuration("P3DT1H15M"))
at
returns
.
00:00:00
on
that
date.
xs:date("20001026")
The
result
has
Returns
the
same
timezone
as
value
that
is
a
given
duration
after
a
specified
$arg1
.
If
xs:time
$arg1
xs:time
has
no
timezone,
(or
before,
if
the
result
has
no
timezone.
duration
is
negative
or
causes
wraparound
past
midnight)
This
functions
backs
up
Defines
the
""
semantics
of
the
"+"
operator
on
and
xs:date
xs:time
xs:dayTimeDuration
values.
op:adddayTimeDurationtotime
(

$arg1

as
xs:time
,

$arg2

as
xs:dayTimeDuration
)
as
xs:time

Summary:
First,
the
days
component
in
the
canonical
lexical
representation
of
$arg2
is
set
to
zero
(0)
and
the
value
of
the
resulting
xs:dayTimeDuration
is
calculated.
Alternatively,
the
value
of
$arg2
modulus
86,400
is
used
as
the
second
argument.
This
value
is
added
to
the
value
of
$arg1
converted
to
an
xs:dateTime
using
a
reference
date
such
as
19721231
,
and
the
time
components
component
of
the
result
is
returned.
Note
that
the
xs:time
returned
may
occur
in
a
following
or
preceding
day
and
may
be
less
than
$arg1
.
The
result
has
the
same
timezone
as
$arg1
.
If
$arg1
has
no
timezone,
the
result
has
no
timezone.
This
functions
backs
up
The
expression
op:adddayTimeDurationtotime(xs:time("11:12:00"),
xs:dayTimeDuration("P3DT1H15M"))
returns
xs:time("12:27:00")
.
The
expression
op:adddayTimeDurationtotime(xs:time("23:12:00+03:00"),
xs:dayTimeDuration("P1DT3H15M"))
returns
xs:time("02:27:00+03:00")
.
(That
is,
{0,
0,
0,
2,
27,
0,
PT3H}
).
Returns
the
"+"
xs:time
value
that
is
a
given
duration
before
a
specified
xs:time
(or
after,
if
the
duration
is
negative
or
causes
wraparound
past
midnight)
Defines
the
semantics
of
the
""
operator
on
xs:time
and
xs:dayTimeDuration
values.
op:subtractdayTimeDurationfromtime
(

$arg1

as
xs:time
, 
$arg2

as
xs:dayTimeDuration
)
as
xs:time

The
function
returns
the
result
of
negating
xs:time
$arg2
value
corresponding
and
adding
the
result
to
$arg1
using
the
lexical
representation
"
function
.12:27:00
adddayTimeDurationtotime
The
expression
op:subtractdayTimeDurationfromtime(xs:time("11:12:00"),
xs:dayTimeDuration("P3DT1H15M"))
".
returns
xs:time("09:57:00")
.
The
expression
returns
op:adddayTimeDurationtotime(xs:time("23:12:00+03:00"),
xs:dayTimeDuration("P1DT3H15M"))
op:subtractdayTimeDurationfromtime(xs:time("08:20:0005:00"),
xs:dayTimeDuration("P23DT10H10M"))
xs:time("22:10:0005:00")
.
Editorial note  
This section has been created by the editor in response to a WG decision in principle; the detailed text needs to be reviewed and approved. 
Function  Meaning 

fn:formatdateTime

Returns
a
string
containing
an
xs:dateTime
value
formatted
for
display.

fn:formatdate

Returns
a
string
containing
an
xs:date
value
formatted
for
display.

fn:formattime

Returns
a
string
containing
an
xs:time
value

Three
functions
are
provided
to
represent
dates
and
times
as
a
string,
using
the
lexical
representation
"
conventions
of
a
selected
calendar,
language,
and
country.
The
signatures
are
presented
first,
followed
by
the
rules
which
apply
to
each
of
the
functions.
Returns
a
string
containing
an
02:27:00+03:00
xs:dateTime
",
i.e.
{0,
0,
0,
2,
27,
0,
PT3H}
.
value
formatted
for
display.
fn:formatdateTime
(

$value

as
xs:dateTime?
, 
$picture

as
xs:string
,  
$language

as
xs:string?
,  
$calendar

as
xs:string?
,  
$country

as
xs:string?
)
as
xs:string?

fn:formatdateTime
(
$value
as
xs:dateTime?
,
$picture
as
xs:string
)
as
xs:string?
Returns
a
string
containing
an
xs:date
value
formatted
for
display.
(


as
,


as
xs:string
,  
$language

as
,  
$calendar

as
xs:string?
,  
$country

as
xs:string?
)
as
xs:string?

fn:formatdate
(
$value
as
xs:date?
,
$picture
as
xs:string
)
as
xs:string?
Returns
a
string
containing
an
xs:time
value
formatted
for
display.
fn:formattime
(

$value

as
xs:time?
, 
$picture

as
xs:string
,  
$language

as
xs:string?
,  
$calendar

as
xs:string?
,  
$country

as
xs:string?
)
as
xs:string?

fn:formattime
(
$value
as
xs:time?
,
$picture
as
xs:string
)
as
xs:string?
Summary:
See
9.8.4
The
date/time
formatting
functions
.
The
fn:formatdateTime
,
fn:formatdate
,
and
fn:formattime
functions
format
$value
as
a
string
using
the
picture
string
specified
by
the
$picture
argument,
the
calendar
specified
by
the
$calendar
argument,
the
language
specified
by
the
$language
argument,
and
the
country
specified
by
the
$country
argument.
The
result
of
the
function
is
calculated
the
formatted
string
representation
of
the
supplied
xs:dateTime
,
xs:date
,
or
xs:time
value.
[Definition]
The
three
functions
fn:formatdateTime
,
fn:formatdate
,
and
fn:formattime
are
referred
to
collectively
as
the
date
formatting
functions
.
If
$value
is
the
empty
sequence,
the
function
returns
the
empty
sequence.
Calling the twoargument form of each of the three functions is equivalent to calling the fiveargument form with each of the last three arguments set to an empty sequence.
For
details
of
the
language
,
calendar
,
and
country
arguments,
see
9.8.4.2
The
Language,
Calendar,
and
Country
Arguments
.
In
general,
the
use
of
an
invalid
picture
,
language
,
calendar
,
or
country
argument
results
in
a
dynamic
error.
By
contrast,
use
of
an
option
in
any
of
these
arguments
that
is
valid
but
not
supported
by
first
setting
the
day
implementation
is
not
an
error,
and
in
these
cases
the
implementation
is
required
to
output
the
value
in
a
fallback
representation.
The picture consists of a sequence of variable markers and literal substrings. A substring enclosed in square brackets is interpreted as a variable marker; substrings not enclosed in square brackets are taken as literal substrings. The literal substrings are optional and if present are rendered unchanged, including any whitespace. If an opening or closing square bracket is required within a literal substring, it must be doubled. The variable markers are replaced in the result by strings representing aspects of the date and/or time to be formatted. These are described in detail below.
A variable marker consists of a component specifier followed optionally by one or two presentation modifiers and/or optionally by a width modifier. Whitespace within a variable marker is ignored.
The component specifier indicates the component of the date or time that is required, and takes the following values:
Specifier  Meaning  Default Presentation Modifier 

Y  year (absolute value)  1 
M  month in year  1 
D  day in month  1 
d  day in year  1 
F  day of week  n 
W  week in year  1 
w  week in month  1 
H  hour in day (24 hours)  1 
h  hour in halfday (12 hours)  1 
P  am/pm marker  n 
m  minute in hour  01 
s  second in minute  01 
f  fractional seconds  1 
Z  timezone as a time offset from UTC, or if an alphabetic modifier is present the conventional name of a timezone (such as PST)  1 
z 
timezone
as
a
time
offset
using
GMT,
for
example
GMT+1
or
GMT05:00.
For
this
component
there
is
a
fixed
prefix
of
GMT
,
or
a
localized
variation
thereof
for
the
chosen
language,
and
the
presentation
modifier
controls
the
 1 
C  calendar: the name or abbreviation of a calendar name  n 
E  era: the name of a baseline for the numbering of years, for example the reign of a monarch  n 
An error is reported [ err:FOFD1340 ] if the syntax of the picture is incorrect.
An
error
is
reported
[
err:FOFD1350
]
if
a
component
specifier
within
the
picture
refers
to
components
that
are
not
available
in
the
given
type
of
,
for
example
if
the
picture
supplied
to
the
$arg2
$value
formattime
refers
to
zero
(0)
and
calculating
the
year,
month,
or
day
component.
It is not an error to include a timezone component when the supplied value has no timezone. In these circumstances the timezone component will be ignored.
The first presentation modifier indicates the style in which the value of a component is to be represented. Its value may be either:
any
format
token
permitted
as
a
primary
format
token
in
the
second
argument
of
the
resulting
function,
indicating
that
the
value
of
the
component
is
to
be
output
numerically
using
the
specified
number
format
(for
example,
xs:dayTimeDuration
.
Alternatively,
formatinteger
,$arg2
1
01
,
i
,
I
,
w
,
W
,
or
Ww
modulus
86,400
)
or
the
format
token
n
,
N
,
or
Nn
,
indicating
that
the
value
of
the
component
is
to
be
output
by
name,
in
lowercase,
uppercase,
or
titlecase
respectively.
Components
that
can
be
output
by
name
include
(but
are
not
limited
to)
months,
days
of
the
week,
timezones,
and
eras.
If
the
processor
cannot
output
these
components
by
name
for
the
chosen
calendar
and
language
then
it
must
use
an
implementationdefined
fallback
representation.
If
a
comma
is
to
be
used
as
a
grouping
separator
within
the
format
token,
then
there
must
be
a
width
specifier.
More
specifically:
if
a
variable
marker
contains
one
or
more
commas,
then
the
last
comma
is
treated
as
introducing
the
width
modifier,
and
all
others
are
treated
as
grouping
separators.
So
[Y9,999,*]
will
output
the
year
as
2,008
.
If the implementation does not support the use of the requested format token, it must use the default presentation modifier for that component.
If
the
first
presentation
modifier
is
present,
then
it
may
optionally
be
followed
by
a
second
argument.
presentation
modifier
as
follows:
Modifier  Meaning 

t 
traditional
numbering.
This
fn:formatinteger
. 
o 
ordinal
form
of
a
number,
for
example
8th
or
8º
.
This
has
the
same
meaning
as
in
the
second
argument
of
fn:formatinteger
.
The
actual
representation
of
the
ordinal
form
of
a
number
may
depend
not
only
on
the
language,
but
also
on
the
grammatical
context
(for
example,
in
some
languages
it
must
agree
in
gender).

Note:
Although
the
formatting
rules
are
expressed
in
terms
of
the
rules
for
format
tokens
in
fn:formatinteger
,
the
formats
actually
used
may
be
specialized
to
the
numbering
of
date
components
where
appropriate.
For
example,
in
Italian,
it
is
subtracted
from
conventional
to
use
an
ordinal
number
(
primo
)
for
the
value
first
day
of
the
month,
and
cardinal
numbers
(
$arg1
due,
tre,
quattro
...
converted
)
for
the
remaining
days.
A
processor
may
therefore
use
this
convention
to
number
days
of
the
month,
ignoring
the
presence
or
absence
of
the
ordinal
presentation
modifier.
Whether or not a presentation modifier is included, a width modifier may be supplied. This indicates the number of characters or digits to be included in the representation of the value.
The width modifier, if present, is introduced by a comma or semicolon. It takes the form:
"," minwidth
(""
maxwidth)?
where
minwidth
is
either
an
unsigned
integer
indicating
the
minimum
number
of
characters
to
be
output,
or
*
indicating
that
there
is
no
explicit
minimum,
and
maxwidth
is
either
an
unsigned
integer
indicating
the
maximum
number
of
characters
to
be
output,
or
xs:dateTime
*
using
indicating
that
there
is
no
explicit
maximum;
if
maxwidth
is
omitted
then
*
is
assumed.
Both
integers,
if
present,
must
be
greater
than
zero.
A
format
token
containing
more
than
one
digit,
such
as
001
or
9999
,
sets
the
minimum
and
maximum
width
to
the
number
of
digits
appearing
in
the
format
token;
if
a
reference
date
width
modifier
is
also
present,
then
the
width
modifier
takes
precedence.
Note:
A
format
token
consisting
of
a
single
digit,
such
as
,
does
not
constrain
the
number
of
digits
in
the
output.
In
the
case
of
fractional
seconds
in
particular,
19721231
1
[f001]
requests
three
decimal
digits,
[f01]
requests
two
digits,
but
[f1]
will
produce
an
implementationdefined
number
of
digits.
If
exactly
one
digit
is
required,
this
can
be
achieved
using
the
component
specifier
[f1,11]
.
If
the
minimum
and
maximum
width
are
unspecified,
then
the
time
components
output
uses
as
many
characters
as
are
required
to
represent
the
value
of
the
result
component
without
truncation
and
without
padding:
this
is
referred
to
below
as
the
full
representation
of
the
value.
For
a
timezone
offset
(component
specifier
z
),
the
full
representation
consists
of
a
sign
for
the
offset,
the
number
of
hours
of
the
offset,
and
if
the
offset
is
not
an
integral
number
of
hours,
a
colon
(
:
)
followed
by
the
two
digits
of
the
minutes
of
the
offset..
If
the
full
representation
of
the
value
exceeds
the
specified
maximum
width,
then
the
processor
should
attempt
to
use
an
alternative
shorter
representation
that
fits
within
the
maximum
width.
Where
the
presentation
modifier
is
N
,
n
,
or
Nn
,
this
is
done
by
abbreviating
the
name,
using
either
conventional
abbreviations
if
available,
or
crude
righttruncation
if
not.
For
example,
setting
maxwidth
to
4
indicates
that
fourletter
abbreviations
should
be
used,
though
it
would
be
acceptable
to
use
a
threeletter
abbreviation
if
this
is
in
conventional
use.
(For
example,
"Tuesday"
might
be
abbreviated
to
"Tues",
and
"Friday"
to
"Fri".)
In
the
case
of
the
year
component,
setting
maxwidth
requests
omission
of
highorder
digits
from
the
year,
for
example,
if
maxwidth
is
set
to
2
then
the
year
2003
will
be
output
as
03
.
In
the
case
of
the
fractional
seconds
component,
the
value
is
rounded
to
the
specified
size
as
if
by
applying
the
function
roundhalftoeven(fractionalseconds,
maxwidth)
.
If
no
mechanism
is
available
for
fitting
the
value
within
the
specified
maximum
width
(for
example,
when
roman
numerals
are
returned.
Note
used),
then
the
value
should
be
output
in
its
full
representation.
If the full representation of the value is shorter than the specified minimum width, then the processor should pad the value to the specified width.
For decimal representations of numbers, this should be done by prepending zero digits from the appropriate set of digit characters, or appending zero digits in the case of the fractional seconds component.
For
timezone
offsets
this
should
be
done
by
first
appending
a
colon
(
:
)
followed
by
two
zero
digits
from
the
appropriate
set
of
digit
characters
if
the
full
representation
does
not
already
include
a
minutes
component
and
if
the
specified
minimum
width
permits
adding
three
characters,
and
then
if
necessary
prepending
zero
digits
from
the
appropriate
set
of
digit
characters
to
the
hour
component.
In other cases, it should be done by appending spaces.
The set of languages, calendars, and countries that are supported in the · date formatting functions · is · implementationdefined · . When any of these arguments is omitted or is an empty sequence, an · implementationdefined · default value is used.
If
the
fallback
representation
uses
a
different
calendar
from
that
requested,
the
output
string
must
identify
the
calendar
actually
used,
for
example
by
prefixing
the
string
with
[Calendar:
X]
(where
X
is
the
calendar
actually
used),
localized
as
appropriate
to
the
requested
language.
If
the
fallback
representation
uses
a
different
language
from
that
requested,
the
output
string
must
identify
the
language
actually
used,
for
example
by
prefixing
the
string
with
xs:time
[Language:
Y]
returned
may
occur
(where
Y
is
the
language
actually
used)
localized
in
an
implementationdependent
way.
If
a
preceding
particular
component
of
the
value
cannot
be
output
in
the
requested
format,
it
should
be
output
in
the
default
format
for
that
component.
The
language
argument
specifies
the
language
to
be
used
for
the
result
string
of
the
function.
The
value
of
the
argument
must
be
either
the
empty
sequence
or
following
day
a
value
that
would
be
valid
for
the
xml:lang
attribute
(see
[XML]).
Note
that
this
permits
the
identification
of
sublanguages
based
on
country
codes
(from
[ISO
31661]
)
as
well
as
identification
of
dialects
and
of
regions
within
a
country.
If
the
language
argument
is
omitted
or
is
set
to
an
empty
sequence,
or
if
it
is
set
to
an
invalid
value
or
a
value
that
the
implementation
does
not
recognize,
then
the
processor
uses
an
·
implementationdefined
·
language.
The language is used to select the appropriate languagedependent forms of:
names (for example, of months)
numbers expressed as words or as ordinals (twenty, 20th, twentieth
)
hour convention (023 vs 124, 011 vs 112)
first day of week, first week of year
Where
appropriate
this
choice
may
also
take
into
account
the
value
of
the
country
argument,
though
this
should
not
be
greater
than
used
to
override
the
language
or
any
sublanguage
that
is
specified
as
part
of
the
argument.
$arg1
.
language
The
result
has
choice
of
the
same
timezone
names
and
abbreviations
used
in
any
given
language
is
·
implementationdefined
·
.
For
example,
one
implementation
might
abbreviate
July
as
while
another
uses
$arg1
Jul
Jly
.
If
In
German,
one
implementation
might
represent
Saturday
as
$arg1
Samstag
has
no
timezone,
while
another
uses
Sonnabend
.
Implementations
may
provide
mechanisms
allowing
users
to
control
such
choices.
Where
ordinal
numbers
are
used,
the
result
selection
of
the
correct
representation
of
the
ordinal
(for
example,
the
linguistic
gender)
may
depend
on
the
component
being
formatted
and
on
its
textual
context
in
the
picture
string.
The
calendar
attribute
specifies
that
the
dateTime
,
date
,
or
time
supplied
in
the
$value
argument
must
be
converted
to
a
value
in
the
specified
calendar
and
then
converted
to
a
string
using
the
conventions
of
that
calendar.
A
calendar
value
must
be
a
valid
lexical
QName.
If
the
QName
does
not
have
a
prefix,
then
it
identifies
a
calendar
with
the
designator
specified
below.
If
the
QName
has
no
timezone.
a
prefix,
then
the
QName
is
expanded
into
an
expandedQName
using
the
inscope
namespaces
from
the
static
context;
the
expandedQName
identifies
the
calendar;
the
behavior
in
this
case
is
·
implementationdefined
·
.
If the calendar attribute is omitted an · implementationdefined · value is used.
Note:
The calendars listed below were known to be in use during the last hundred years. Many other calendars have been used in the past.
This
functions
backs
up
specification
does
not
define
any
of
these
calendars,
nor
the
way
that
they
map
to
the
value
space
of
the
""
operator
on
data
type
in
[XML
Schema
Part
2:
Datatypes
Second
Edition]
.
There
may
be
ambiguities
when
dates
are
recorded
using
different
calendars.
For
example,
the
start
of
a
new
day
is
not
simultaneous
in
different
calendars,
and
may
also
vary
geographically
(for
example,
based
on
the
time
of
sunrise
or
sunset).
Translation
of
dates
is
therefore
more
reliable
when
the
time
of
day
is
also
known,
and
when
the
geographic
location
is
known.
When
translating
dates
between
one
calendar
and
another,
the
processor
may
take
account
of
the
values
of
the
xs:time
xs:date
xs:dayTimeDuration
country
values.
and/or
language
arguments,
with
the
country
argument
taking
precedence.
Information about some of these calendars, and algorithms for converting between them, may be found in [Calendrical Calculations] .
Designator  Calendar 

AD  Anno Domini (Christian Era) 
AH  Anno Hegirae (Muhammedan Era) 
AME  Mauludi Era (solar years since Mohammed's birth) 
AM  Anno Mundi (Jewish Calendar) 
AP  Anno Persici 
AS  Aji Saka Era (Java) 
BE  Buddhist Era 
CB  Cooch Behar Era 
CE  Common Era 
CL  Chinese Lunar Era 
CS  Chula Sakarat Era 
EE  Ethiopian Era 
FE  Fasli Era 
ISO  ISO 8601 calendar 
JE  Japanese Calendar 
KE  Khalsa Era (Sikh calendar) 
KY  Kali Yuga 
ME  Malabar Era 
MS  Monarchic Solar Era 
NS  Nepal Samwat Era 
OS  Old Style (Julian Calendar) 
RS  Rattanakosin (Bangkok) Era 
SE  Saka Era 
SH  Mohammedan Solar Era (Iran) 
SS  Saka Samvat 
TE  Tripurabda Era 
VE  Vikrama Era 
VS  Vikrama Samvat Era 
At
least
one
of
the
above
calendars
must
be
supported.
It
is
·
implementationdefined
·
10.8.13.1
Examples
which
calendars
are
supported.
The
ISO
8601
calendar
(
[ISO
8601]
),
which
is
included
in
the
above
list
and
designated
ISO
,
is
very
similar
to
the
Gregorian
calendar
designated
AD
,
but
it
differs
in
several
ways.
The
ISO
calendar
is
intended
to
ensure
that
date
and
time
formats
can
be
read
easily
by
other
software,
as
well
as
being
legible
for
human
users.
The
ISO
calendar
prescribes
the
use
of
particular
numbering
conventions
as
defined
in
ISO
8601,
rather
than
allowing
these
to
be
localized
on
a
perlanguage
basis.
In
particular
it
provides
a
numeric
'week
date'
format
which
identifies
dates
by
year,
week
of
the
year,
and
day
in
the
week;
in
the
ISO
calendar
the
days
of
the
week
are
numbered
from
1
(Monday)
to
7
(Sunday),
and
week
1
in
any
calendar
year
is
the
week
(from
Monday
to
Sunday)
that
includes
the
first
Thursday
of
that
year.
The
numeric
values
of
the
components
year,
month,
day,
hour,
minute,
and
second
are
the
same
in
the
ISO
calendar
as
the
values
used
in
the
lexical
representation
of
the
date
and
time
as
defined
in
[XML
Schema
Part
2:
Datatypes
Second
Edition]
.
The
era
("E"
component)
with
this
calendar
is
either
a
minus
sign
(for
negative
years)
or
a
zerolength
string
(for
positive
years).
For
dates
before
1
January,
AD
1,
year
numbers
in
the
ISO
and
AD
calendars
are
off
by
one
from
each
other:
ISO
year
0000
is
1
BC,
0001
is
2
BC,
etc.
Note:
The
value
space
of
the
date
and
time
data
types,
as
defined
in
XML
Schema,
is
based
on
absolute
points
in
time.
The
lexical
space
of
these
data
types
defines
a
representation
of
these
absolute
points
in
time
using
the
proleptic
Gregorian
calendar,
that
is,
the
modern
Western
calendar
extrapolated
into
the
past
and
the
future;
but
the
value
space
is
calendarneutral.
The
·
date
formatting
functions
·
produce
a
representation
of
this
absolute
point
in
time,
but
denoted
in
a
possibly
different
calendar.
So,
for
example,
the
date
whose
lexical
representation
in
XML
Schema
is
op:subtractdayTimeDurationfromtime(xs:time("11:12:00"),
xs:dayTimeDuration("P3DT1H15M"))
15020111
returns
(the
day
on
which
Pope
Gregory
XIII
was
born)
might
be
formatted
using
the
Old
Style
(Julian)
calendar
as
1
January
1502
.
This
reflects
the
fact
that
there
was
at
that
time
a
tenday
difference
between
the
two
calendars.
It
would
be
incorrect,
and
would
produce
incorrect
results,
to
represent
this
date
in
an
element
or
attribute
of
type
as
xs:time
xs:date
15020101
,
even
though
this
might
reflect
the
way
the
date
was
recorded
in
contemporary
documents.
When
referring
to
years
occurring
in
antiquity,
modern
historians
generally
use
a
numbering
system
in
which
there
is
no
year
zero
(the
year
before
1
CE
is
thus
1
BCE).
This
is
the
convention
that
should
be
used
when
the
requested
calendar
is
OS
(Julian)
or
AD
(Gregorian).
When
the
requested
calendar
is
ISO,
however,
the
conventions
of
ISO
8601
should
be
followed:
here
the
year
before
+0001
is
numbered
zero.
In
[XML
Schema
Part
2:
Datatypes
Second
Edition]
(version
1.0),
the
value
corresponding
space
for
xs:date
and
xs:dateTime
does
not
include
a
year
zero:
however,
a
future
edition
is
expected
to
endorse
the
ISO
8601
convention.
This
means
that
the
date
on
which
Julius
Caesar
was
assassinated
has
the
ISO
8601
lexical
representation
"09:57:00"
.
00430313,
but
will
be
formatted
as
15
March
44
BCE
in
the
Julian
calendar
or
13
March
44
BCE
in
the
Gregorian
calendar
(dependant
on
the
chosen
localization
of
the
names
of
months
and
eras).
The
intended
use
of
the
op:subtractdayTimeDurationfromtime(xs:time("08:20:0005:00"),
xs:dayTimeDuration("P23DT10H10M"))
country
returns
argument
is
to
identify
the
place
where
an
event
represented
by
the
,xs:time
dateTime
date
,
or
time
supplied
in
the
$value
argument
took
place
or
will
take
place.
If
the
value
corresponding
is
supplied,
and
is
not
the
empty
sequence,
then
it
should
be
a
country
code
defined
in
[ISO
31661]
.
Implementations
may
also
allow
the
use
of
codes
representing
subdivisions
of
a
country
from
ISO
31662,
or
codes
representing
formerly
used
names
of
countries
from
ISO
31663.
This
argument
is
not
intended
to
identify
the
location
of
the
user
for
whom
the
date
or
time
is
being
formatted;
that
should
be
done
by
means
of
the
lexical
representation
"22:10:0005:00"
language
i.e.
attribute.
This
information
may
be
used
to
provide
additional
information
when
converting
dates
between
calendars
or
when
deciding
how
individual
components
of
the
date
and
time
are
to
be
formatted.
For
example,
different
countries
using
the
Old
Style
(Julian)
calendar
started
the
new
year
on
different
days,
and
some
countries
used
variants
of
the
calendar
that
were
out
of
synchronization
as
a
result
of
differences
in
calculating
leap
years.
The
geographical
area
identified
by
a
country
code
is
defined
by
the
boundaries
as
they
existed
at
the
time
of
the
date
to
be
formatted,
or
the
presentday
boundaries
for
dates
in
the
future.
The following examples show a selection of dates and times and the way they might be formatted. These examples assume the use of the Gregorian calendar as the default calendar.
Required Output  Expression 


formatdate($d,
"[Y0001][M01][D01]")

12312002

formatdate($d,
"[M][D][Y]")

31122002

formatdate($d,
"[D][M][Y]")

31
XII
2002

formatdate($d,
"[D1]
[MI]
[Y]")

31st
December,
2002

formatdate($d,
"[D1o]
[MNn],
[Y]",
"en",
(),
())

31
DEC
2002

formatdate($d,
"[D01]
[MN,*3]
[Y0001]",
"en",
(),
())

December
31,
2002

formatdate($d,
"[MNn]
[D],
[Y]",
"en",
(),
())

31
Dezember,
2002

formatdate($d,
"[D]
[MNn],
[Y]",
"de",
(),
())

Tisdag
31
December
2002

formatdate($d,
"[FNn]
[D]
[MNn]
[Y]",
"sv",
(),
())

[20021231]

formatdate($d,
"[[[Y0001][M01][D01]]]")

Two
Thousand
and
Three

formatdate($d,
"[YWw]",
"en",
(),
())

einunddreißigste
Dezember

formatdate($d,
"[Dwo]
[MNn]",
"de",
(),
())

3:58
PM

formattime($t,
"[h]:[m01]
[PN]",
"en",
(),
())

3:58:45
pm

formattime($t,
"[h]:[m01]:[s01]
[Pn]",
"en",
(),
())

3:58:45
PM
PDT

formattime($t,
"[h]:[m01]:[s01]
[PN]
[ZN,*3]",
"en",
(),
())

3:58:45
o'clock
PM
PDT

formattime($t,
"[h]:[m01]:[s01]
o'clock
[PN]
[ZN,*3]",
"en",
(),
())

15:58

formattime($t,"[H01]:[m01]")

15:58:45.762

formattime($t,"[H01]:[m01]:[s01].[f001]")

15:58:45
GMT+02:00

formattime($t,"[H01]:[m01]:[s01]
[z,66]",
"en",
(),
())

15.58
Uhr
GMT+2

formattime($t,"[H01]:[m01]
Uhr
[z]",
"de",
(),
())

3.58pm
on
Tuesday,
31st
December

formatdateTime($dt,
"[h].[m01][Pn]
on
[FNn],
[D1o]
[MNn]")

12/31/2002
at
15:58:45

formatdateTime($dt,
"[M01]/[D01]/[Y0001]
at
[H01]:[m01]:[s01]")

The following examples use calendars other than the Gregorian calendar.
These examples use nonLatin characters which might not display correctly in all browsers, depending on the system configuration.
Description  Request  Result 

Islamic 
formatdate($d,
"[D١]
[Mn]
[Y١]",
"ar",
"AH",
())
 ٢٦ ﺸﻭّﺍﻝ ١٤٢٣ 
Jewish (with Western numbering) 
formatdate($d,
"[D]
[Mn]
[Y]",
"he",
"AM",
())
 26 טבת 5763 
Jewish (with traditional numbering) 
formatdate($d,
"[Dאt]
[Mn]
[Yאt]",
"he",
"AM",
())
 כ״ו טבת תשס״ג 
Julian (Old Style) 
formatdate($d,
"[D]
[MNn]
[Y]",
"en",
"OS",
())
 18 December 2002 
Thai 
formatdate($d,
"[D๑]
[Mn]
[Y๑]",
"th",
"BE",
())
 ๓๑ ธันวาคม ๒๕๔๕ 
In
addition
to
the
xs:QName
constructor
function,
QName
values
can
be
constructed
by
combining
a
namespace
URI,
prefix,
and
local
name,
or
by
resolving
a
lexical
QName
against
the
inscope
namespaces
of
an
element
node.
This
section
defines
additional
constructor
functions
for
QName
as
defined
in
[XML
Schema
Part
2:
Datatypes
Second
Edition]
.
these
functions.
Leading
and
trailing
whitespace,
if
present,
is
stripped
from
string
arguments
before
the
result
is
constructed.
Function  Meaning 

fn:resolveQName

Returns
an
xs:QName
xs:string
that
has
the
lexical
form
xs:QName
(a
string
in
the

fn:QName

xs:QName

Summary:
Returns
an
xs:QName
value
(that
is,
an
expandedQName)
by
taking
an
xs:string
that
has
the
lexical
form
of
an
xs:QName
(a
string
in
the
form
"prefix:localname"
or
"localname")
and
resolving
it
using
the
inscope
namespaces
for
a
given
element.
fn:resolveQName
(
$qname
as
xs:string?
,
$element
as
element()
)
as
xs:QName?
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
zerolength
string
if
it
has
no
prefix,
and
constructs
an
expandedQName
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
a
prefix
and
if
there
is
no
namespace
binding
for
$element
that
matches
this
prefix,
then
an
error
is
raised
[
err:FONS0004
].
If
the
$qname
has
no
prefix,
and
there
is
no
namespace
binding
for
$element
corresponding
to
the
default
(unnamed)
namespace,
then
the
resulting
expandedQName
has
no
namespace
part.
The
prefix
(or
absence
of
a
prefix)
in
the
supplied
$qname
argument
is
retained
in
the
returned
expandedQName,
as
discussed
in
Section
2.1
Terminology
^{
DM
}.
If
$qname
does
not
have
the
correct
lexical
form
for
xs:QName
an
error
is
raised
[
err:FOCA0002
11.1.1.1
Usage
Note
].
Sometimes
the
requirement
is
to
construct
an
xs:QName
without
using
the
default
namespace.
This
can
be
achieved
by
writing:
if (contains($qname, ":")) then fn:resolveQName($qname, $element) elsefn:QName("", $qname)fn:QName("", $qname)
If
the
requirement
is
to
construct
an
xs:QName
using
the
namespaces
in
the
static
context,
then
the
xs:QName
constructor
should
be
used.
Assume
that
the
element
bound
to
$element
has
a
single
namespace
binding
bound
to
the
prefix
eg
.
fn:resolveQName("hello",
$element)
returns
a
QName
with
local
name
"hello"
that
is
in
no
namespace.
fn:resolveQName("eg:myFunc",
$element)
returns
an
xs:QName
whose
namespace
URI
is
specified
by
the
namespace
binding
corresponding
to
the
prefix
"eg"
and
whose
local
name
is
"myFunc".
Constructs
an
xs:QName
value
given
a
namespace
URI
and
a
lexical
QName.
fn:QName
(
$paramURI
as
xs:string?
,
$paramQName
as
xs:string
)
as
xs:QName
Summary:
Returns
an
xs:QName
with
the
The
namespace
URI
given
in
the
returned
QName
is
taken
from
$paramURI
.
If
$paramURI
is
the
zerolength
string
or
the
empty
sequence,
it
represents
"no
namespace";
in
this
case,
if
the
value
of
$paramQName
contains
a
colon
(
:
),
an
error
is
raised
[
err:FOCA0002
].
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
.
If
$paramQName
does
not
have
the
correct
lexical
form
for
an
xs:QName
an
error
is
raised
[
err:FOCA0002
].
If
$paramURI
is
the
zerolength
string
or
the
empty
sequence,
and
the
value
of
$paramQName
contains
a
colon
(
:
),
an
error
is
raised
[
err:FOCA0002
].
Note
that
unlike
the
xs:QName
constructor,
this
function
does
not
require
a
xs:string
string
literal
as
the
argument.
fn:QName("http://www.example.com/example",
"person")
returns
an
xs:QName
with
namespace
URI
=
"http://www.example.com/example",
local
name
=
"person"
and
prefix
=
"".
fn:QName("http://www.example.com/example",
"ht:person")
returns
an
xs:QName
with
namespace
URI
=
"http://www.example.com/example",
local
name
=
"person"
and
prefix
=
"ht".
This
section
discusses
specifies
functions
on
QNames
as
defined
in
[XML
Schema
Part
2:
Datatypes
Second
Edition]
.
Function  Meaning 

op:QNameequal

Returns
true
if
two
supplied
QNames
have
the

fn:prefixfromQName

Returns

fn:localnamefromQName

Returns

fn:namespaceurifromQName

Returns
the
namespace
URI

fn:namespaceuriforprefix

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

fn:inscopeprefixes

Returns
the
prefixes
of
the
inscope
namespaces
for

Returns
true
if
two
supplied
QNames
have
the
same
namespace
URI
and
the
same
local
part.
Defines
the
semantics
of
the
"eq"
and
"ne"
operators
on
values
of
type
xs:QName
.
op:QNameequal
(
$arg1
as
xs:QName
,
$arg2
as
xs:QName
)
as
xs:boolean
Summary:
Returns
The
function
returns
true
if
the
namespace
URIs
of
$arg1
and
$arg2
are
equal
and
the
local
names
of
$arg1
and
$arg2
are
identical
based
on
the
Unicode
code
point
collation
(
http://www.w3.org/2005/xpathfunctions/collation/codepoint
).
equal.
Otherwise,
the
function
returns
false
.
Two
The
namespace
URIs
URI
parts
are
considered
equal
if
they
are
either
both
absent
absent,
or
if
they
are
both
present
and
identical
based
on
equal
under
the
Unicode
code
point
collation.
rules
of
the
fn:codepointequal
function.
The
local
parts
are
also
compared
under
the
rules
of
the
fn:codepointequal
function.
The
prefix
parts
of
$arg1
and
$arg2
,
if
any,
are
ignored.
Returns the prefix component of the supplied QName.
fn:prefixfromQName
(
$arg
as
xs:QName?
)
as
xs:NCName?
Summary:
Returns
an
If
xs:NCName
$arg
representing
is
the
prefix
of
$arg
.
The
empty
sequence
is
returned
if
the
function
returns
the
empty
sequence.
If
$arg
is
has
no
prefix
component
the
function
returns
the
empty
sequence
or
if
sequence.
Otherwise,
the
value
function
returns
an
xs:NCName
representing
the
prefix
component
of
$arg
.
contains
no
prefix.
Returns the local part of the supplied QName.
fn:localnamefromQName
(
$arg
as
xs:QName?
)
as
xs:NCName?
Summary:
Returns
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
.
If
$arg
is
the
empty
sequence,
returns
the
empty
sequence.
The
expression
fn:localnamefromQName(fn:QName("http://www.example.com/example",
"person"))
returns
"person"
.
Returns the namespace URI part of the supplied QName.
fn:namespaceurifromQName
(
$arg
as
xs:QName?
)
as
xs:anyURI?
Summary:
Returns
the
namespace
URI
for
$arg
as
an
xs:string
.
If
$arg
is
the
empty
sequence,
sequence
the
function
returns
the
empty
sequence
is
returned.
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
zerolength
string
is
returned.
xs:anyURI
.
The
expression
fn:namespaceurifromQName(fn:QName("http://www.example.com/example",
"person"))
returns
the
namespace
URI
corresponding
to
.
"http://www.example.com/example"
xs:anyURI("http://www.example.com/example")
Returns
the
namespace
URI
of
one
of
the
inscope
namespaces
for
$element
,
identified
by
its
namespace
prefix.
fn:namespaceuriforprefix
(

$prefix

as
xs:string?
,

$element

as
element()
)
as
xs:anyURI?

If
$element
has
an
inscope
namespace
whose
namespace
prefix
is
equal
to
$prefix
,
it
returns
the
namespace
URI
of
that
namespace.
If
$prefix
is
the
zerolength
string
or
the
empty
sequence,
it
returns
the
namespace
URI
of
the
default
(unnamed)
namespace.
Otherwise,
it
returns
the
empty
sequence.
Prefixes
are
equal
only
if
their
Unicode
code
points
codepoints
match
exactly.
Returns the prefixes of the inscope namespaces for an element node.
fn:inscopeprefixes
(
$element
as
element()
)
as
xs:string*
Summary:
Returns
The
function
returns
a
sequence
of
strings
representing
the
prefixes
of
the
inscope
namespaces
for
$element
.
For
namespaces
namespace
bindings
that
have
a
prefix,
it
the
function
returns
the
prefix
as
an
xs:NCName
.
For
the
default
namespace,
which
has
no
prefix,
it
returns
the
zerolength
string.
The result sequence contains no duplicates.
The ordering of the result sequence is · implementationdependent · .
The
following
comparison
operators
on
xs:base64Binary
and
xs:hexBinary
values
are
defined.
Comparisons
take
two
operands
of
the
same
type;
that
is,
both
operands
must
be
xs:base64Binary
or
both
operands
may
be
xs:hexBinary
.
Each
returns
a
boolean
value.
A
value
of
type
xs:hexBinary
can
be
compared
with
a
value
of
type
xs:base64Binary
by
casting
one
value
to
the
other
type.
See
17.1.7
18.1.7
Casting
to
xs:base64Binary
and
xs:hexBinary
.
Function  Meaning 

op:hexBinaryequal

Returns
true
if
xs:hexBinary
values
contain
the
same
octet
sequence.

op:base64Binaryequal

Returns
true
if
xs:base64Binary
values
contain
the
same
octet
sequence.

Returns
true
if
two
xs:hexBinary
values
contain
the
same
octet
sequence.
Defines
the
semantics
of
the
"eq"
and
"ne"
operators
on
xs:hexBinary
values.
op:hexBinaryequal
(

$value1

as
xs:hexBinary
,

$value2

as
xs:hexBinary
)
as
xs:boolean

Summary:
Returns
The
function
returns
true
if
$value1
and
$value2
are
of
the
same
length,
measured
in
binary
octets,
and
contain
the
same
octets
in
the
same
order.
Otherwise,
it
returns
false
.
This
function
backs
up
Returns
true
if
two
xs:base64Binary
values
contain
the
same
octet
sequence.
Defines
the
semantics
of
the
"eq"
and
"ne"
operators
on
values.
xs:hexBinary
xs:base64Binary
op:base64Binaryequal
(

$value1

as
xs:base64Binary
,

$value2

as
xs:base64Binary
)
as
xs:boolean

Summary:
Returns
The
function
returns
true
if
$value1
and
$value2
are
of
the
same
length,
measured
in
binary
octets,
and
contain
the
same
octets
in
the
same
order.
Otherwise,
it
returns
false
.
This
section
discusses
functions
specifies
operators
that
take
NOTATION
xs:NOTATION
values
as
arguments.
Function  Meaning 

op:NOTATIONequal

Returns
true
if
the
two

Returns
true
if
the
two
xs:NOTATION
values
have
the
same
namespace
URI
and
the
same
local
part.
Defines
the
semantics
of
the
"eq"
and
"ne"
operators
on
values
of
type
xs:NOTATION
.
op:NOTATIONequal
(
$arg1
as
xs:NOTATION
,
$arg2
as
xs:NOTATION
)
as
xs:boolean
Summary:
Returns
The
function
returns
true
if
the
namespace
URIs
of
$arg1
and
$arg2
are
equal
and
the
local
names
of
$arg1
and
$arg2
are
identical
based
on
equal.
Otherwise,
the
Unicode
code
point
collation:
function
returns
.
http://www.w3.org/2005/xpathfunctions/collation/codepoint
false
Otherwise,
returns
false.
Two
The
namespace
URIs
URI
parts
are
considered
equal
if
they
are
either
both
absent
absent,
or
if
they
are
both
present
and
identical
based
on
equal
under
the
Unicode
code
point
collation.
rules
of
the
fn:codepointequal
function.
The
local
parts
are
also
compared
under
the
rules
of
the
fn:codepointequal
function.
The
prefix
parts
of
$arg1
and
$arg2
,
if
any,
are
ignored.
This
section
discusses
specifies
functions
and
operators
on
nodes.
Nodes
are
formally
defined
in
Section
6
Nodes
^{
DM
}.