Please
refer
to
the
errata
for
this
document,
which
may
include
some
normative
corrections.
See
also
translations
.
This
document
is
also
available
in
these
non-normative
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/xpath-functions
.
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/xquery-test-suite/
.
An
implementation
report
is
available
at
http://www.w3.org/XML/Query/test-suite/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/qt-bugzilla
).
If
access
to
that
system
is
not
feasible,
you
may
send
your
comments
to
the
W3C
XSLT/XPath/XQuery
public
comments
mailing
list,
public-qt-comments@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/public-qt-comments/
.
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 add-dayTimeDurations add-dayTimeDuration-to-date add-dayTimeDuration-to-dateTime add-dayTimeDuration-to-time add-yearMonthDurations add-yearMonthDuration-to-date add-yearMonthDuration-to-dateTime adjust-dateTime-to-timezone adjust-date-to-timezone adjust-time-to-timezone analyze-string asin atan avg
base64Binary-equal base-uri boolean boolean-equal boolean-greater-than boolean-less-than
ceiling codepoint-equal codepoints-to-string collection compare concat concatenate contains cos count current-date current-dateTime current-time
data date-equal date-greater-than date-less-than dateTime dateTime-equal dateTime-greater-than dateTime-less-than day-from-date day-from-dateTime days-from-duration dayTimeDuration-greater-than dayTimeDuration-less-than deep-equal default-collation distinct-values divide-dayTimeDuration divide-dayTimeDuration-by-dayTimeDuration divide-yearMonthDuration divide-yearMonthDuration-by-yearMonthDuration doc doc-available document-uri duration-equal
element-with-id empty encode-for-uri ends-with error escape-html-uri exactly-one except exists
false floor format-date format-dateTime format-integer format-number format-time function-arity function-name
gDay-equal generate-id gMonthDay-equal gMonth-equal gYear-equal gYearMonth-equal
hexBinary-equal hours-from-dateTime hours-from-duration hours-from-time
id idref implicit-timezone index-of in-scope-prefixes insert-before intersect iri-to-uri is-same-node
matches max min minutes-from-dateTime minutes-from-duration minutes-from-time month-from-date month-from-dateTime months-from-duration multiply-dayTimeDuration multiply-yearMonthDuration
name namespace-uri namespace-uri-for-prefix namespace-uri-from-QName nilled node-after node-before node-name normalize-space normalize-unicode not NOTATION-equal number numeric-add numeric-divide numeric-equal numeric-greater-than numeric-integer-divide numeric-less-than numeric-mod numeric-multiply numeric-subtract numeric-unary-minus numeric-unary-plus
remove replace resolve-QName resolve-uri reverse root round round-half-to-even
seconds-from-dateTime seconds-from-duration seconds-from-time serialize sin sqrt starts-with static-base-uri string string-join string-length string-to-codepoints subsequence substring substring-after substring-before subtract-dates subtract-dateTimes subtract-dayTimeDuration-from-date subtract-dayTimeDuration-from-dateTime subtract-dayTimeDuration-from-time subtract-dayTimeDurations subtract-times subtract-yearMonthDuration-from-date subtract-yearMonthDuration-from-dateTime subtract-yearMonthDurations sum
tan time-equal time-greater-than time-less-than timezone-from-date timezone-from-dateTime timezone-from-time to tokenize trace translate true
year-from-date year-from-dateTime yearMonthDuration-greater-than yearMonthDuration-less-than years-from-duration
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:node-name
2.2
fn:nilled
2.3
fn:string
2.4
fn:data
2.5
fn:base-uri
2.6
fn:document-uri
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
Built-in
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
User-Defined
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:numeric-add
6.2.2
4.2.2
op:numeric-subtract
6.2.3
4.2.3
op:numeric-multiply
6.2.4
4.2.4
op:numeric-divide
6.2.5
4.2.5
op:numeric-integer-divide
6.2.6
4.2.6
op:numeric-mod
6.2.7
4.2.7
op:numeric-unary-plus
6.2.8
4.2.8
op:numeric-unary-minus
6.3
4.3
Comparison
Operators
on
Numeric
Values
6.3.1
4.3.1
op:numeric-equal
6.3.2
4.3.2
op:numeric-less-than
6.3.3
4.3.3
op:numeric-greater-than
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:round-half-to-even
7
4.5
Formatting
Integers
4.5.1
fn:format-integer
4.6
Formatting
Numbers
4.6.1
Defining
a
Decimal
Format
4.6.2
fn:format-number
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:codepoints-to-string
7.2.2
5.2.2
fn:string-to-codepoints
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:codepoint-equal
7.4
5.4
Functions
on
String
Values
7.4.1
5.4.1
fn:concat
7.4.2
5.4.2
fn:string-join
7.4.3
5.4.3
fn:substring
7.4.4
5.4.4
fn:string-length
7.4.5
5.4.5
fn:normalize-space
7.4.6
5.4.6
fn:normalize-unicode
7.4.7
5.4.7
fn:upper-case
7.4.8
5.4.8
fn:lower-case
7.4.9
5.4.9
fn:translate
7.4.10
fn:encode-for-uri
7.4.11
fn:iri-to-uri
7.4.12
fn:escape-html-uri
7.5
5.5
Functions
Based
on
Substring
Matching
7.5.1
5.5.1
fn:contains
7.5.2
5.5.2
fn:starts-with
7.5.3
5.5.3
fn:ends-with
7.5.4
5.5.4
fn:substring-before
7.5.5
5.5.5
fn:substring-after
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:analyze-string
6
Functions
on
anyURI
that
manipulate
URIs
8.1
6.1
fn:resolve-uri
9
6.2
fn:encode-for-uri
6.3
fn:iri-to-uri
6.4
fn:escape-html-uri
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:boolean-equal
9.2.2
7.2.2
op:boolean-less-than
9.2.3
7.2.3
op:boolean-greater-than
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:yearMonthDuration-less-than
10.4.2
8.3.2
op:yearMonthDuration-greater-than
10.4.3
8.3.3
op:dayTimeDuration-less-than
10.4.4
8.3.4
op:dayTimeDuration-greater-than
10.4.5
8.3.5
op:duration-equal
10.4.6
8.4
Component
Extraction
Functions
on
Durations
8.4.1
fn:years-from-duration
8.4.2
fn:months-from-duration
8.4.3
fn:days-from-duration
8.4.4
fn:hours-from-duration
8.4.5
fn:minutes-from-duration
8.4.6
fn:seconds-from-duration
8.5
Arithmetic
Operators
on
Durations
8.5.1
op:add-yearMonthDurations
8.5.2
op:subtract-yearMonthDurations
8.5.3
op:multiply-yearMonthDuration
8.5.4
op:divide-yearMonthDuration
8.5.5
op:divide-yearMonthDuration-by-yearMonthDuration
8.5.6
op:add-dayTimeDurations
8.5.7
op:subtract-dayTimeDurations
8.5.8
op:multiply-dayTimeDuration
8.5.9
op:divide-dayTimeDuration
8.5.10
op:divide-dayTimeDuration-by-dayTimeDuration
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:dateTime-equal
10.4.7
9.4.2
op:dateTime-less-than
10.4.8
9.4.3
op:dateTime-greater-than
10.4.9
9.4.4
op:date-equal
10.4.10
9.4.5
op:date-less-than
10.4.11
9.4.6
op:date-greater-than
10.4.12
9.4.7
op:time-equal
10.4.13
9.4.8
op:time-less-than
10.4.14
9.4.9
op:time-greater-than
10.4.15
9.4.10
op:gYearMonth-equal
10.4.16
9.4.11
op:gYear-equal
10.4.17
9.4.12
op:gMonthDay-equal
10.4.18
9.4.13
op:gMonth-equal
10.4.19
9.4.14
op:gDay-equal
10.5
9.5
Component
Extraction
Functions
on
Durations,
Dates
and
Times
10.5.1
fn:years-from-duration
10.5.2
fn:months-from-duration
10.5.3
fn:days-from-duration
10.5.4
fn:hours-from-duration
10.5.5
fn:minutes-from-duration
10.5.6
fn:seconds-from-duration
10.5.7
9.5.1
fn:year-from-dateTime
10.5.8
9.5.2
fn:month-from-dateTime
10.5.9
9.5.3
fn:day-from-dateTime
10.5.10
9.5.4
fn:hours-from-dateTime
10.5.11
9.5.5
fn:minutes-from-dateTime
10.5.12
9.5.6
fn:seconds-from-dateTime
10.5.13
9.5.7
fn:timezone-from-dateTime
10.5.14
9.5.8
fn:year-from-date
10.5.15
9.5.9
fn:month-from-date
10.5.16
9.5.10
fn:day-from-date
10.5.17
9.5.11
fn:timezone-from-date
10.5.18
9.5.12
fn:hours-from-time
10.5.19
9.5.13
fn:minutes-from-time
10.5.20
9.5.14
fn:seconds-from-time
10.5.21
9.5.15
fn:timezone-from-time
10.6
Arithmetic
Operators
on
Durations
10.6.1
op:add-yearMonthDurations
10.6.2
op:subtract-yearMonthDurations
10.6.3
op:multiply-yearMonthDuration
10.6.4
op:divide-yearMonthDuration
10.6.5
op:divide-yearMonthDuration-by-yearMonthDuration
10.6.6
op:add-dayTimeDurations
10.6.7
op:subtract-dayTimeDurations
10.6.8
op:multiply-dayTimeDuration
10.6.9
op:divide-dayTimeDuration
10.6.10
op:divide-dayTimeDuration-by-dayTimeDuration
10.7
9.6
Timezone
Adjustment
Functions
on
Dates
and
Time
Values
10.7.1
9.6.1
fn:adjust-dateTime-to-timezone
10.7.2
9.6.2
fn:adjust-date-to-timezone
10.7.3
9.6.3
fn:adjust-time-to-timezone
10.8
9.7
Arithmetic
Operators
on
Durations,
Dates
and
Times
10.8.1
9.7.1
op:subtract-dateTimes
10.8.2
9.7.2
op:subtract-dates
10.8.3
9.7.3
op:subtract-times
10.8.4
9.7.4
op:add-yearMonthDuration-to-dateTime
10.8.5
9.7.5
op:add-dayTimeDuration-to-dateTime
10.8.6
9.7.6
op:subtract-yearMonthDuration-from-dateTime
10.8.7
9.7.7
op:subtract-dayTimeDuration-from-dateTime
10.8.8
9.7.8
op:add-yearMonthDuration-to-date
10.8.9
9.7.9
op:add-dayTimeDuration-to-date
10.8.10
9.7.10
op:subtract-yearMonthDuration-from-date
10.8.11
9.7.11
op:subtract-dayTimeDuration-from-date
10.8.12
9.7.12
op:add-dayTimeDuration-to-time
10.8.13
9.7.13
op:subtract-dayTimeDuration-from-time
11
9.8
Formatting
Dates
and
Times
9.8.1
fn:format-dateTime
9.8.2
fn:format-date
9.8.3
fn:format-time
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:resolve-QName
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:QName-equal
11.2.2
10.2.2
fn:prefix-from-QName
11.2.3
10.2.3
fn:local-name-from-QName
11.2.4
10.2.4
fn:namespace-uri-from-QName
11.2.5
10.2.5
fn:namespace-uri-for-prefix
11.2.6
10.2.6
fn:in-scope-prefixes
12
11
Operators
on
base64Binary
and
hexBinary
12.1
11.1
Comparisons
of
base64Binary
and
hexBinary
Values
12.1.1
11.1.1
op:hexBinary-equal
12.1.2
11.1.2
op:base64Binary-equal
13
12
Operators
on
NOTATION
13.1
Operators
on
NOTATION
13.1.1
12.1
op:NOTATION-equal
14
13
Functions
and
Operators
on
Nodes
14.1
13.1
fn:name
14.2
13.2
fn:local-name
14.3
13.3
fn:namespace-uri
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:is-same-node
14.6.1
Examples
14.7
13.7
op:node-before
14.7.1
Examples
14.8
13.8
op:node-after
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:index-of
14.1.2
fn:distinct-values
15.1.4
14.1.3
fn:empty
15.1.5
14.1.4
fn:exists
15.1.6
fn:distinct-values
14.1.5
fn:index-of
15.1.7
14.1.6
fn:insert-before
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:zero-or-one
15.2.2
14.2.2
fn:one-or-more
15.2.3
14.2.3
fn:exactly-one
15.3
14.3
Equals,
Union,
Intersection
and
Except
15.3.1
14.3.1
fn:deep-equal
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:element-with-id
14.5.4
fn:idref
15.5.4
14.5.5
fn:doc
15.5.5
14.5.6
fn:doc-available
15.5.6
14.5.7
fn:collection
16
14.5.8
fn:uri-collection
14.5.9
fn:generate-id
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:current-dateTime
16.3.1
Examples
16.4
15.4
fn:current-date
16.4.1
Examples
16.5
15.5
fn:current-time
16.5.1
Examples
16.6
15.6
fn:implicit-timezone
16.7
15.7
fn:default-collation
16.8
15.8
fn:static-base-uri
16
Functions
on
Functions
16.1
fn:function-name
16.2
fn:function-arity
16.3
fn:partial-apply
17
Constructor
Functions
17.1
Constructor
Functions
for
XML
Schema
Built-in
Types
17.2
Constructor
Functions
for
xs:QName
and
xs:NOTATION
17.3
Constructor
Functions
for
User-Defined
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
Non-normative
References
B
Change
Log
for
this
Version
of
the
Document
C
Error
Summary
D
C
Compatibility
with
XPath
1.0
(Non-Normative)
E
D
Illustrative
User-written
Functions
(Non-Normative)
E.1
D.1
eg:if-empty
and
eg:if-absent
E.1.1
D.1.1
eg:if-empty
E.1.2
D.1.2
eg:if-absent
E.2
D.2
union,
intersect
and
except
on
sequences
of
values
E.2.1
D.2.1
eg:value-union
E.2.2
D.2.2
eg:value-intersect
E.2.3
D.2.3
eg:value-except
E.3
D.3
eg:index-of-node
E.4
D.4
eg:string-pad
E.5
D.5
eg:distinct-nodes-stable
F
E
Checklist
of
Implementation-Defined
Features
(Non-Normative)
F
Changes
since
previous
Recommendation
(Non-Normative)
F.1
Substantive
changes
F.2
Editorial
changes
G
Function
and
Operator
Quick
Reference
(Non-Normative)
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
built-in
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
cross-document
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 · implementation-defined · which version of Unicode is supported, but it is recommended that the most recent version of Unicode be used.
It is · implementation-defined · 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.
User-written
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/xpath-functions
,
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
built-in
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/xpath-functions
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/xpath-functions/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/xqt-errors
—
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/xqt-errors
,
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:numeric-multiply
(
$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.
User-defined
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:function-name
(
$parameter-name
as
parameter-type
,
...
)
as
return-type
In
this
notation,
function-name
,
in
bold-face,
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
non-normative,
name.
If
there
are
two
or
more
parameter
declarations,
they
are
separated
by
a
comma.
The
return-type
,
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:numeric-function
(
$arg
as
numeric
)
as
...
represents the following four function signatures:
fn:numeric-function
(
$arg
as
xs:integer
)
as
...
fn:numeric-function
(
$arg
as
xs:decimal
)
as
...
fn:numeric-function
(
$arg
as
xs:float
)
as
...
fn:numeric-function
(
$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:timezone-from-dateTime
.
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:function-name
(
$parameter-name
as
parameter-type?
)
as
return-type?
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
"expanded-QName"
user
defined
below.
[Definition]
Expanded-QName
An
expanded-QName
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:local-name).
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
built-in
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
user-defined
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
built-in
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 | |||
user-defined attribute types | |||
comment | |||
document | |||
user-defined document types | |||
element | |||
user-defined element types | |||
processing-instruction | |||
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 | ||
user-defined complex types | ||
xs:untyped | ||
xs:anySimpleType | ||
user-defined 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
built-in
types
derived
from
xs:anyAtomicType
.
the
primitive
simple
types.
This
includes
all
the
built-in
datatypes
defined
in
[XML
Schema
Part
2:
Datatypes
Second
Edition]
built-in
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 "expanded-QName" defined below.
[Definition]
An
expanded-QName
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:local-name).
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
non-ASCII
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 non-conformant 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
top-level
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:current-date
,
fn:collection()
fn:current-dateTime
,
fn:current-dateTime()
fn:current-time
,
fn:current-date
fn:implicit-timezone
fn:adjust-date-to-timezone
,
fn:adjust-dateTime-to-timezone
,
and
fn:current-time()
fn:adjust-time-to-timezone
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:element-with-id
,
fn:lang
,
fn:local-name
,
fn:name
,
fn:namespace-uri
,
fn:normalize-space
,
fn:number
,
fn:root
,
fn:string
,
and
fn:string-length
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
string-handling
operators
and
functions
depend
on
the
default
collation
and
the
in-scope
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:default-collation
Functions
such
as
,
fn:last()
fn:static-base-uri
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:distinct-values
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]
·
implementation-defined
·
or
·
implementation-dependent
·
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
ordering-unstable
.
The
function
fn:analyze-string
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
identity-unstable
.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)
·
implementation-defined
·
;
for
example
it
or
·
implementation-dependent
·
,
this
does
not
require
non-ASCII
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:node-name
|
node-name
|
an optional node |
zero
or
one
xs:QName
|
fn:nilled
|
nilled
|
a node |
an
optional
xs:boolean
|
fn:string
|
string-value
|
an optional item or no argument |
xs:string
|
fn:data
|
typed-value
|
zero or more items | a sequence of atomic values |
fn:base-uri
|
base-uri
|
an optional node or no argument |
zero
or
one
xs:anyURI
|
fn:document-uri
|
document-uri
|
an optional node |
zero
or
one
xs:anyURI
|
Returns
the
name
of
a
node,
as
an
xs:QName
.
fn:node-name
(
$arg
as
node()?
)
as
xs:QName?
Summary:
Returns
an
expanded-QName
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:node-name
accessor
as
defined
in
[xpath-datamodel]
(see
Section
5.11
node-name
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
[xpath-datamodel]
(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
[xpath-datamodel]
.
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
zero-argument
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
zero-length
string
is
returned.
string.
If
$arg
is
a
node,
the
function
returns
the
string-value
of
the
node,
as
obtained
using
the
dm:string-value
accessor
defined
in
the
[xpath-datamodel]
(see
Section
5.13
string-value
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 zero-argument 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:typed-value
accessor
as
defined
in
[xpath-datamodel]
(See
Section
5.15
typed-value
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:base-uri
()
as
xs:anyURI?
fn:base-uri
(
$arg
as
node()?
)
as
xs:anyURI?
Summary:
Returns
the
value
The
zero-argument
version
of
the
base-uri
URI
property
for
$arg
as
defined
by
the
accessor
function
dm:base-uri()
for
that
kind
returns
the
base
URI
of
node
in
Section
5.2
base-uri
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:base-uri(.)
.
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 single-argument version of the function behaves as follows:
$arg
is
the
empty
sequence,
the
function
returns
the
empty
dm:base-uri
accessor
applied
to
the
node
$arg
.
This
accessor
is
Note:
See
also
fn:static-base-uri
.
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:document-uri
(
$arg
as
node()?
)
as
xs:anyURI?
Summary:
Returns
the
value
of
the
document-uri
property
for
If
$arg
as
defined
by
is
the
empty
sequence,
the
dm:document-uri
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:document-uri
document-uri
of
the
document
node.
applied
to
$arg
,
as
defined
in
[xpath-datamodel]
(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:document-uri($D)
returns
the
empty
sequence,
or
that
the
following
expression
is
true:
fn:doc(fn:document-uri($D))
is
$D
.
It
is
implementation-defined
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/xqt-errors
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
application-defined
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
,
|
|
$error-object
|
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/xqt-errors', '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/xqt-errors', '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/xqt-errors
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
natural-language
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
$error-object
$error-object
,
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/xqt-errors#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
·
implementation-defined
·
.
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
754-1985]
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
754-1985]
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
754-1985]
.
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:numeric-add
|
Addition |
op:numeric-subtract
|
Subtraction |
op:numeric-multiply
|
Multiplication |
op:numeric-divide
|
Division |
op:numeric-integer-divide
|
Integer division |
op:numeric-mod
|
Modulus |
op:numeric-unary-plus
|
Unary plus |
op:numeric-unary-minus
|
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:numeric-divide
,
which
returns
an
xs:decimal
if
called
with
two
xs:integer
operands
and
op:numeric-integer-divide
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:numeric-divide(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
754-1985]
.
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
754-1985]
.
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) non-infinite number.
For
xs:float
and
xs:double
operations,
underflow
behavior
·
must
·
be
conformant
with
[IEEE
754-1985]
.
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
limited-precision
integer
operations
·
must
·
select
from
the
following
options:
They · may · choose to always raise an error [ err:FOAR0002 ].
They · may · provide an · implementation-defined · 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:numeric-add
,
op:numeric-subtract
,
op:numeric-multiply
,
op:numeric-divide
,
op:numeric-integer-divide
and
op:numeric-mod
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:numeric-unary-plus
and
op:numeric-unary-minus
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
·
implementation-defined
·
.
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
·
implementation-defined
·
manner.
Returns
the
arithmetic
sum
of
its
operands:
(
$arg1
+
$arg2
).
Defines the semantics of the "+" operator applied to numeric values
op:numeric-add
(
$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:numeric-subtract
(
$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:numeric-multiply
(
$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
non-zero
number
and
the
other
is
an
infinity,
an
infinity
with
the
appropriate
sign
is
returned.
Returns
the
arithmetic
quotient
of
its
operands:
(
$arg1
div
$arg2
).
Defines the semantics of the "div" operator applied to numeric values.
op:numeric-divide
(
$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
754-1985]
.
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:numeric-integer-divide
(
$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
·
implementation-dependent
·
or
·
implementation-defined
·
behavior
does
not
affect
the
outcome,
for
example,
the
implementation-defined
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:numeric-integer-divide(10,3)
returns
3
.
The
expression
op:numeric-integer-divide(3,-2)
returns
-1
.
The
expression
op:numeric-integer-divide(-3,2)
returns
-1
.
The
expression
op:numeric-integer-divide(-3,-2)
returns
1
.
The
expression
op:numeric-integer-divide(9.0,3)
returns
3
.
The
expression
op:numeric-integer-divide(-3.5,3)
returns
-1
.
The
expression
op:numeric-integer-divide(3.0,4)
returns
0
.
The
expression
op:numeric-integer-divide(3.1E1,6)
returns
5
.
The
expression
op:numeric-integer-divide(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:numeric-mod
(
$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
754-1985]
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:numeric-mod(10,3)
returns
1
.
The
expression
op:numeric-mod(6,-2)
returns
0
.
The
expression
op:numeric-mod(4.5,1.2)
returns
0.9
.
The
expression
op:numeric-mod(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:numeric-unary-plus
(
$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:numeric-unary-minus
(
$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:numeric-equal
|
$arg1
is
equal
to
the
value
of
$arg2
.
|
op:numeric-less-than
|
true
if
and
only
if
$arg1
is
numerically
less
than
$arg2
.
|
op:numeric-greater-than
|
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:numeric-equal
(
$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:numeric-less-than
(
$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:numeric-greater-than
(
$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:numeric-greater-than($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:numeric-less-than($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:round-half-to-even
|
|
Note:
fn:round
and
fn:round-half-to-even
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:round-half-to-even 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:round-half-to-even 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:round-half-to-even 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
single-argument
version
of
this
function
produces
the
same
result
as
the
two-argument
version
with
$precision=0
(that
is,
it
rounds
to
a
whole
number).
When
$arg
is
of
type
xs:float
and
xs:double
:
If
$arg
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:round-half-to-even functions FS
This
function
is
typically
used
with
a
non-zero
$precision
in
financial
applications
where
the
argument
is
of
type
xs:decimal
.
For
arguments
of
type
xs:float
and
xs:double
the
results
may
be
counter-intuitive.
For
example,
consider
round(35.425e0,
2)
.
The
result
is
not
35.43,
as
might
be
expected,
but
35.42.
This
is
because
the
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:round-half-to-even
(
$arg
as
numeric?
)
as
numeric?
fn:round-half-to-even
(
$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:round-half-to-even 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.
counter-intuitive.
For
example,
consider
.
The
result
is
not
150.02
as
might
be
expected,
but
150.01.
This
is
because
the
conversion
of
the
round-half-to-even(xs:float(150.0150),
round-half-to-even(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:round-half-to-even(0.5)
returns
0.0
.
The
expression
fn:round-half-to-even(1.5)
returns
2.0
.
The
expression
fn:round-half-to-even(2.5)
returns
2.0
.
The
expression
fn:round-half-to-even(3.567812e+3,
2)
returns
3567.81e0
.
The
expression
fn:round-half-to-even(4.7564e-3,
2)
returns
0.0e0
.
The
expression
fn:round-half-to-even(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:format-integer
(
$value
as
xs:integer?
,
$picture
as
xs:string
)
as
xs:string
fn:format-integer
(
|
$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
format-dateTime
,
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
zero-length
string.
In
all
other
cases,
the
$picture
argument
describes
the
format
in
which
$value
is
output.
The
rules
that
follow
describe
how
non-negative
numbers
are
output.
If
the
value
of
$value
is
negative,
the
rules
below
are
applied
to
the
absolute
value
of
$value
,
and
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
١
(Arabic-Indic
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
non-alphanumeric,
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
lower-case
words,
for
example
in
English,
one
two
three
four
...
A
format
token
W
generates
numbers
written
as
upper-case
words,
for
example
in
English,
ONE
TWO
THREE
FOUR
...
A
format
token
Ww
generates
numbers
written
as
title-case
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
·
implementation-defined
·
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
·
implementation-defined
·
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
language-sensitive.
This
applies
especially
to
the
sequence
selected
by
the
tokens
w
,
W
and
Ww
.
It
also
applies
to
other
sequences,
for
example
different
languages
using
the
Cyrillic
alphabet
use
different
sequences
of
characters,
each
starting
with
the
letter
#x410
(Cyrillic
capital
letter
A).
In
such
cases,
the
$language
argument
specifies
which
language's
conventions
are
to
be
used;
it
has
the
same
range
of
values
as
xml:lang
(see
[REC-xml]
).
If
no
$language
argument
is
specified,
the
language
that
is
used
is
·
implementation-defined
·
.
The
set
of
languages
for
which
numbering
is
supported
is
·
implementation-defined
·
.
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
·
implementation-defined
·
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
format-integer(123,
'0000')
returns
"0123"
.
format-integer(123,
'w')
might
return
"one
hundred
and
twenty-three"
The
expression
format-integer(21,
'1o',
'en')
returns
"21st"
.
format-integer(14,
'Wwo(-e)',
'de')
might
return
"Vierzehnte"
The
expression
format-integer(7,
'a')
returns
"g"
.
The
expression
format-integer(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:format-number
| 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:format-integer
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 implementation-defined.
Each decimal format provides a set of named variables, described in the following table:
Name | Type | Usage (non-normative) |
---|---|---|
decimal-separator-sign | A single character | Defines the character used to represent the decimal point (typically ".") both in the picture string and in the formatted number |
grouping-separator-sign | 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"minus-sign | 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
|
percent-sign | A single character | Defines the character used as a percent sign (typically "%") both in the picture string and in the formatted number |
per-mille-sign | Defines the character used as a per-mille sign (typically "‰", x2030) both in the picture string and in the formatted number | |
mandatory-digit-sign | 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. |
optional-digit-sign | A single character | Defines the character used in the picture string to represent an optional digit (typically "#") |
pattern-separator-sign | 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 mandatory-digit-sign .
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 decimal-separator-sign , grouping-separator-sign , percent-sign , per-mille-sign , optional-digit-sign , and pattern-separator-sign . 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:format-number
(
$value
as
numeric?
,
$picture
as
xs:string
)
as
xs:string
fn:format-number
(
|
$value
|
as
numeric?
, |
$picture
|
as
xs:string
, | |
$decimal-format-name
|
as
xs:string
)
as
xs:string
|
The
function
formats
$value
as
a
string
using
the
·
picture
string
·
specified
by
the
$picture
argument
and
the
decimal-format
named
by
the
$decimal-format-name
argument,
or
the
default
decimal-format,
if
there
is
no
$decimal-format-name
argument.
The
syntax
of
the
picture
string
is
described
in
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
$decimal-format-name
must
be
a
lexical
QName,
which
is
expanded
using
the
in-scope
namespaces
from
the
static
context.
The
default
namespace
is
not
used
(no
prefix
means
no
namespace).
The
evaluation
of
the
format-number
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
$decimal-format-name
argument
is
not
a
valid
lexical
QName,
or
if
its
prefix
has
not
been
declared
in
an
in-scope
namespace
declaration,
or
if
the
static
context
does
not
contain
a
declaration
of
a
decimal-format
with
a
matching
expanded
QName.
If
the
processor
is
able
to
detect
the
error
statically
(for
example,
when
the
argument
is
supplied
as
a
string
literal),
then
the
processor
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
format-number
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
format-number
(which
previously
used
'000')
with
format-dateTime
(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 decimal-separator-sign , grouping-sign , decimal-digit-family , optional-digit-sign and pattern-separator-sign are classified as active characters, and all other characters (including the percent-sign and per-mille-sign ) are classified as passive characters.
The integer part of the sub-picture is defined as the part that appears to the left of the decimal-separator-sign if there is one, or the entire sub-picture otherwise. The fractional part of the sub-picture is defined as the part that appears to the right of the decimal-separator-sign if there is one; it is a zero-length 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 picture-string consists either of a sub-picture, or of two sub-pictures separated by a pattern-separator-sign . A picture-string must not contain more than one pattern-separator-sign . If the picture-string contains two sub-pictures, the first is used for positive values and the second for negative values.
A sub-picture must not contain more than one decimal-separator-sign .
A sub-picture must not contain more than one percent-sign or per-mille-sign , and it must not contain one of each.
A sub-picture must contain at least one character that is an optional-digit-sign or a member of the decimal-digit-family .
A sub-picture must not contain a passive character that is preceded by an active character and that is followed by another active character.
A sub-picture must not contain a grouping-separator-sign adjacent to a decimal-separator-sign .
The integer part of a sub-picture must not contain a member of the decimal-digit-family that is followed by an optional-digit-sign . The fractional part of a sub-picture must not contain an optional-digit-sign that is followed by a member of the decimal-digit-family .
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 sub-picture. If there are two sub-pictures, then these rules are applied to one sub-picture 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 sub-picture, then the values for both cases are derived from this sub-picture.
The variables are as follows:
The integer-part-grouping-positions is a sequence of integers representing the positions of grouping separators within the integer part of the sub-picture. For each grouping-separator-sign that appears within the integer part of the sub-picture, this sequence contains an integer that is equal to the total number of optional-digit-sign and decimal-digit-family characters that appear within the integer part of the sub-picture and to the right of the grouping-separator-sign . In addition, if these integer-part-grouping-positions 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 minimum-integer-part-size is an integer indicating the minimum number of digits that will appear to the left of the decimal-separator-sign . It is normally set to the number of decimal-digit-family characters found in the integer part of the sub-picture. But if the sub-picture contains no decimal-digit-family character and no decimal-separator-sign , 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 optional-digit-sign and decimal-digit-family characters in the subpicture.
The prefix is set to contain all passive characters in the sub-picture to the left of the leftmost active character. If the picture string contains only one sub-picture, the prefix for the negative sub-picture is set by concatenating the minus-sign character and the prefix for the positive sub-picture (if any), in that order.
The fractional-part-grouping-positions is a sequence of integers representing the positions of grouping separators within the fractional part of the sub-picture. For each grouping-separator-sign that appears within the fractional part of the sub-picture, this sequence contains an integer that is equal to the total number of optional-digit-sign and decimal-digit-family characters that appear within the fractional part of the sub-picture and to the left of the grouping-separator-sign .
The minimum-fractional-part-size is set to the number of decimal-digit-family characters found in the fractional part of the sub-picture.
The maximum-fractional-part-size is set to the total number of optional-digit-sign and decimal-digit-family characters found in the fractional part of the sub-picture.
The suffix is set to contain all passive characters to the right of the rightmost active character in the fractional part of the sub-picture.
Note:
If
there
is
only
one
sub-picture,
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
minus-sign
character.
This
section
describes
the
second
phase
of
processing
of
the
format-number
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
format-number
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 NaN-symbol (with no prefix or suffix ).
In the rules below, the positive sub-picture and its associated variables are used if the input number is positive, and the negative sub-picture 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 infinity-symbol , and the appropriate suffix .
If the sub-picture contains a percent-sign , the number is multiplied by 100. If the sub-picture contains a per-mille-sign , 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
round-half-to-even(xs:decimal(150.0150),
2)
maximum-fractional-part-size
xs:decimal
value,
as
described
above,
and
then
calling
the
function
fn:round-half-to-even
with
this
converted
number
as
the
first
argument
and
the
maximum-fractional-part-size
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 decimal-digit-family to represent the ten decimal digits, and the decimal-separator-sign to separate the integer part and the fractional part. (The value zero will at this stage be represented by a decimal-separator-sign on its own.)
If the number of digits to the left of the decimal-separator-sign is less than minimum-integer-part-size , leading zero-digit-sign characters are added to pad out to that size.
If the number of digits to the right of the decimal-separator-sign is less than minimum-fractional-part-size , trailing zero-digit-sign characters are added to pad out to that size.
For each integer N in the integer-part-grouping-positions list, a grouping-separator-sign 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 decimal-separator-sign , if there is such a digit.
For each integer N in the fractional-part-grouping-positions list, a grouping-separator-sign 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 decimal-separator-sign , if there is such a digit.
If there is no decimal-separator-sign in the sub-picture, or if there are no digits to the right of the decimal-separator-sign character in the string, then the decimal-separator-sign 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
·
implementation-dependent
·
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:round-half-to-even(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:round-half-to-even(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:round-half-to-even(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
·
implementation-dependent
·
.
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:round-half-to-even(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
·
implementation-dependent
·
.
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:round-half-to-even(4.7564E-3,
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
·
implementation-dependent
·
.
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:round-half-to-even(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 user-defined types derived by restriction from the above types.
It is · implementation-defined · 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
non-negative
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)]
[REC-xml]
.
[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:string-length
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
16-bit
values
known
as
a
surrogate.
surrogate
pair.
A
surrogate
pair
counts
as
one
character,
not
two.
Function | Meaning |
---|---|
fn:codepoints-to-string
|
Creates
an
xs:string
from
a
sequence
of
[The
Unicode
|
fn:string-to-codepoints
|
Returns
the
sequence
of
[The
Unicode
xs:string
value.
|
Creates
an
xs:string
from
a
sequence
of
[The
Unicode
Standard]
codepoints.
fn:codepoints-to-string
(
$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
zero-length
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:codepoints-to-string((2309,
2358,
2378,
2325))
returns
"अशॊक"
.
Returns
the
sequence
of
[The
Unicode
Standard]
codepoints
that
constitute
an
xs:string
value.
fn:string-to-codepoints
(
$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
zero-length
string
or
the
empty
sequence,
the
function
returns
the
empty
sequence
is
returned.
sequence.
The
expression
fn:string-to-codepoints("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:codepoint-equal
| Returns true if two strings are equal, considered codepoint-by-codepoint. |
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
codepoint-by-codepoint
or
in
a
linguistically
appropriate
manner,
as
defined
by
the
collation.
Some
collations,
especially
those
based
on
the
[Unicode
Collation
Algorithm]
can
be
"tailored"
for
various
purposes.
This
document
does
not
discuss
such
tailoring,
nor
does
it
provide
a
mechanism
to
perform
tailoring.
Instead,
it
assumes
that
the
collation
argument
to
the
various
functions
below
is
a
tailored
and
named
collation.
A
specific
The
·
Unicode
codepoint
collation
with
·
is
a
distinguished
name,
http://www.w3.org/2005/xpath-functions/collation/codepoint
,
provides
the
ability
to
compare
strings
based
on
code
point
values.
Every
implementation
of
XQuery/XPath
must
support
the
collation
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
base-uri
property
in
the
static
context.
This
specification
also
defines
the
manner
in
which
a
default
collation
is
determined
if
the
collation
argument
is
not
specified
in
invocations
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/xpath-functions/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:string-to-codepoints
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
·
implementation-defined
·
,
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:codepoint-equal
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
"ß"
("sharp-s").
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
"ß"
("sharp-s").
(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
"ß"
("sharp-s")
with
less
strength
than
the
differences
between
the
base
characters,
such
as
the
final
"n".
).
if
Returns true if two strings are equal, considered codepoint-by-codepoint.
fn:codepoint-equal
(
|
$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/xpath-functions/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:string-join
|
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:string-join
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
zero-length
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:normalize-unicode
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 normalize-unicode(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
',
'marble-hearted',
'
fiend!')
returns
"
.
Ingratitude,
"Ingratitude,
thou
marble-hearted
fiend!
".
fiend!"
Returns a string created by concatenating the items in a sequence, with a defined separator between adjacent items.
fn:string-join
(
$arg1
as
xs:string*
)
as
xs:string
fn:string-join
(
$arg1
as
xs:string*
,
$arg2
as
xs:string
)
as
xs:string
Summary:
Returns
The
effect
of
calling
the
single-argument
version
of
this
function
is
the
same
as
calling
the
two-argument
version
with
$arg2
set
to
a
zero-length
string.
The
function
returns
an
xs:string
created
by
concatenating
the
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
zero-length
string,
then
the
members
of
$arg1
are
concatenated
without
a
separator.
If
the
value
of
$arg1
is
the
empty
sequence,
the
function
returns
the
zero-length
string
is
returned.
string.
The
expression
fn:string-join(('Now',
'is',
'the',
'time',
'...'),
'
')
returns
"
.
Now
"Now
is
the
time
...
".
..."
The
expression
fn:string-join(('Blow,
',
'blow,
',
'thou
',
'winter
',
'wind!'),
'')
returns
"
.
Blow,
"Blow,
blow,
thou
winter
wind!
".
wind!"
The
expression
fn:string-join((),
'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:string-join(for
$n
in
ancestor-or-self::*
return
name($n),
fn:string-join(ancestor-or-self::*/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
zero-length
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:numeric-less-than()
op:numeric-less-than
apply.
op:numeric-greater-than()
op:numeric-greater-than
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:string-length
()
as
xs:integer
fn:string-length
(
$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
zero-argument
version
of
the
function
is
equivalent
to
calling
fn:string-length(fn:string(.))
.
If
the
value
of
$arg
is
the
empty
sequence,
the
function
returns
the
xs:integer
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:string-length("Harp
not
on
that
string,
madam;
that
is
past.")
returns
45
.
The
expression
fn:string-length(())
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:normalize-space
()
as
xs:string
fn:normalize-space
(
$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
zero-length
string.
The
function
returns
a
string
constructed
by
stripping
leading
and
trailing
whitespace
from
the
value
of
$arg
,
and
replacing
sequences
of
one
or
more
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]
[REC-xml]
.
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:normalize-space("
The
wealthy
curled
darlings
definition
of
our
nation.
")
whitespace
is
unchanged
in
[Extensible
Markup
Language
(XML)
1.1
Recommendation]
.
The
expression
fn:normalize-space(" The wealthy curled darlings
of our nation. ")
returns
"
.
The
"The
wealthy
curled
darlings
of
our
nation.
".
nation."
The
expression
fn:normalize-space(())
returns
"".
""
.
Returns
the
value
of
$arg
after
applying
Unicode
normalization.
fn:normalize-unicode
(
$arg
as
xs:string?
)
as
xs:string
fn:normalize-unicode
(
|
$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
zero-length
string.
If
the
single-argument
version
of
the
function
is
used,
the
result
is
the
same
as
calling
the
two-argument
version
with
$normalizationForm
set
to
the
string
"NFC".
Otherwise,
the
function
returns
the
value
of
$arg
normalized
according
to
the
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:upper-case(fn:normalize-space($normalizationForm))
is
the
empty
sequence,
returns
the
zero-length
string.
.
See [Character Model for the World Wide Web 1.0: Normalization] for a description of the normalization forms.
If
the
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
"FULLY-NORMALIZED",
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
zero-length
string,
no
normalization
is
performed
and
$arg
is
returned.
Conforming implementations · must · support normalization form "NFC" and · may · support normalization forms "NFD", "NFKC", "NFKD", and "FULLY-NORMALIZED". They · may · also support other normalization forms with · implementation-defined · 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:upper-case
(
$arg
as
xs:string?
)
as
xs:string
Summary:
Returns
If
the
value
of
$arg
is
the
empty
sequence,
the
zero-length
string
is
returned.
Otherwise,
the
function
returns
the
value
of
$arg
after
translating
every
character
to
its
upper-case
correspondent
as
defined
in
the
appropriate
case
mappings
section
in
the
Unicode
standard
[The
Unicode
Standard]
.
For
versions
of
Unicode
beginning
with
the
2.1.8
update,
only
locale-insensitive
case
mappings
should
be
applied.
Beginning
with
version
3.2.0
(and
likely
future
versions)
of
Unicode,
precise
mappings
are
described
in
default
case
operations,
which
are
full
case
mappings
in
the
absence
of
tailoring
for
particular
languages
and
environments.
Every
lower-case
character
that
does
not
have
an
upper-case
correspondent,
as
well
as
every
upper-case
character,
is
included
in
the
returned
value
in
its
original
form.
Case
mappings
may
change
the
length
of
a
string.
In
general,
the
two
fn:upper-case
and
fn:lower-case
functions
are
not
inverses
of
each
other
other:
fn:lower-case(fn:upper-case($arg))
is
not
guaranteed
to
return
$arg
,
nor
is
fn:upper-case(fn:lower-case($arg))
.
The
Latin
small
letter
dotless
i
(as
used
in
Turkish)
is
perhaps
the
most
prominent
lower-case
letter
which
will
not
round-trip.
The
Latin
capital
letter
i
with
dot
above
is
the
most
prominent
upper-case
letter
which
will
not
round
trip;
there
are
others.
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:upper-case("abCd0")
returns
"ABCD0"
.
Converts a string to lower case.
fn:lower-case
(
$arg
as
xs:string?
)
as
xs:string
Summary:
Returns
If
the
value
of
$arg
is
the
empty
sequence,
the
zero-length
string
is
returned.
Otherwise,
the
function
returns
the
value
of
$arg
after
translating
every
character
to
its
lower-case
correspondent
as
defined
in
the
appropriate
case
mappings
section
in
the
Unicode
standard
[The
Unicode
Standard]
.
For
versions
of
Unicode
beginning
with
the
2.1.8
update,
only
locale-insensitive
case
mappings
should
be
applied.
Beginning
with
version
3.2.0
(and
likely
future
versions)
of
Unicode,
precise
mappings
are
described
in
default
case
operations,
which
are
full
case
mappings
in
the
absence
of
tailoring
for
particular
languages
and
environments.
Every
upper-case
character
that
does
not
have
a
lower-case
correspondent,
as
well
as
every
lower-case
character,
is
included
in
the
returned
value
in
its
original
form.
Case
mappings
may
change
the
length
of
a
string.
In
general,
the
two
fn:upper-case
and
fn:lower-case
functions
are
not
inverses
of
each
other
other:
fn:lower-case(fn:upper-case($arg))
is
not
guaranteed
to
return
$arg
,
nor
is
fn:upper-case(fn:lower-case($arg))
.
The
Latin
small
letter
dotless
i
(as
used
in
Turkish)
is
perhaps
the
most
prominent
lower-case
letter
which
will
not
round-trip.
The
Latin
capital
letter
i
with
dot
above
is
the
most
prominent
upper-case
letter
which
will
not
round
trip;
there
are
others.
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:lower-case("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
zero-length
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
zero-length
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("code-point",
"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 · implementation-defined · property of the collation.
Function | Meaning |
---|---|
fn:contains
|
contains
as
a
substring,
taking
collations
into
account.
|
fn:starts-with
|
as
a
leading
substring,
taking
collations
into
account.
|
fn:ends-with
|
as
a
trailing
substring,
taking
collations
into
account.
|
fn:substring-before
|
Returns
the
that
,
taking
collations
into
account.
|
fn:substring-after
|
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
zero-length
string.
If
the
value
of
$arg2
is
the
zero-length
string,
then
the
function
returns
true
.
If
the
value
of
$arg1
is
the
zero-length
string,
the
function
returns
false
.
The
collation
used
by
the
invocation
of
this
function
is
determined
according
to
the
rules
in
7.3.1
Collations
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",
"-d-e-f-",
returns
"CollationA")
"http://example.com/CollationA")
.
true
true()
The
expression
fn:contains
(
"a*b*c*d*e*f*g*h*i*",
"d-ef-",
returns
"CollationA")
"http://example.com/CollationA")
.
true
true()
The
expression
fn:contains
(
"abcd***e---f*--*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
zero-length
string.
string.).
Returns
true
if
the
string
$arg1
contains
$arg2
as
a
leading
substring,
taking
collations
into
account.
fn:starts-with
(
$arg1
as
xs:string?
,
$arg2
as
xs:string?
)
as
xs:boolean
fn:starts-with
(
|
$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
zero-length
string.
If
the
value
of
$arg2
is
the
zero-length
string,
then
the
function
returns
true
.
If
the
value
of
$arg1
is
the
zero-length
string
and
the
value
of
$arg2
is
not
the
zero-length
string,
then
the
function
returns
false
.
The
collation
used
by
the
invocation
of
this
function
is
determined
according
to
the
rules
in
7.3.1
Collations
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:starts-with("tattoo",
"tat")
returns
.
true
true()
The
expression
fn:starts-with
(
"tattoo",
"att")
returns
.
false
false()
The
expression
fn:starts-with
((),
())
returns
.
true
true()
The
expression
fn:starts-with
(
"abcdefghi",
"-a-b-c-",
returns
"CollationA")
"http://example.com/CollationA")
.
true
true()
The
expression
fn:starts-with
(
"a*b*c*d*e*f*g*h*i*",
"a-bc-",
returns
"CollationA")
"http://example.com/CollationA")
.
true
true()
The
expression
fn:starts-with
(
"abcd***e---f*--*ghi",
"abcdef",
returns
"CollationA")
"http://example.com/CollationA")
.
true
true()
The
expression
fn:starts-with
(
(),
"--***-*---",
returns
"CollationA")
"http://example.com/CollationA")
.
true
true()
The
(The
second
argument
contains
only
ignorable
collation
units
and
is
equivalent
to
the
zero-length
string.
string.).
The
expression
fn:starts-with
(
"-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:ends-with
(
$arg1
as
xs:string?
,
$arg2
as
xs:string?
)
as
xs:boolean
fn:ends-with
(
|
$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
zero-length
string.
If
the
value
of
$arg2
is
the
zero-length
string,
then
the
function
returns
true
.
If
the
value
of
$arg1
is
the
zero-length
string
and
the
value
of
$arg2
is
not
the
zero-length
string,
then
the
function
returns
false
.
The
collation
used
by
the
invocation
of
this
function
is
determined
according
to
the
rules
in
7.3.1
Collations
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:ends-with
(
"tattoo",
"tattoo")
returns
.
true
true()
The
expression
fn:ends-with
(
"tattoo",
"atto")
returns
.
false
false()
The
expression
fn:ends-with
((),
())
returns
.
true
true()
The
expression
fn:ends-with
(
"abcdefghi",
"-g-h-i-",
returns
"CollationA")
"http://example.com/CollationA")
.
true
true()
The
expression
fn:ends-with
(
"abcd***e---f*--*ghi",
"defghi",
returns
"CollationA")
"http://example.com/CollationA")
.
true
true()
The
expression
fn:ends-with
(
"abcd***e---f*--*ghi",
"defghi",
returns
"CollationA")
"http://example.com/CollationA")
.
true
true()
The
expression
fn:ends-with
(
(),
"--***-*---",
returns
"CollationA")
"http://example.com/CollationA")
.
true
true()
The
(The
second
argument
contains
only
ignorable
collation
units
and
is
equivalent
to
the
zero-length
string.
string.).
The
expression
fn:ends-with
(
"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:substring-before
(
$arg1
as
xs:string?
,
$arg2
as
xs:string?
)
as
xs:string
fn:substring-before
(
|
$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
zero-length
string.
If
the
value
of
$arg2
is
the
zero-length
string,
then
the
function
returns
the
zero-length
string.
If
the
value
of
$arg1
does
not
contain
a
string
that
is
equal
to
the
value
of
$arg2
,
then
the
function
returns
the
zero-length
string.
The
collation
used
by
the
invocation
of
this
function
is
determined
according
to
the
rules
in
7.3.1
Collations
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:substring-before
(
"tattoo",
"attoo")
returns
"
.
t
".
"t"
The
expression
fn:substring-before
(
"tattoo",
"tatto")
returns
"".
""
.
The
expression
fn:substring-before
((),
())
returns
"".
""
.
The
expression
fn:substring-before
(
"abcdefghi",
"--d-e-",
returns
"CollationA")
"http://example.com/CollationA")
"
.
abc
".
"abc"
The
expression
fn:substring-before
(
"abc--d-e-fghi",
"--d-e-",
returns
"CollationA")
"http://example.com/CollationA")
"
.
abc--
".
"abc--"
The
expression
fn:substring-before
(
"a*b*c*d*e*f*g*h*i*",
"***cde",
returns
"CollationA")
"http://example.com/CollationA")
"
.
a*b*
".
"a*b*"
The
expression
fn:substring-before
(
"Eureka!",
"--***-*---",
returns
"CollationA")
"http://example.com/CollationA")
"".
The
""
.
(The
second
argument
contains
only
ignorable
collation
units
and
is
equivalent
to
the
zero-length
string.
string.).
Returns
the
part
of
$arg1
that
follows
the
first
occurrence
of
$arg2
,
taking
collations
into
account.
fn:substring-after
(
$arg1
as
xs:string?
,
$arg2
as
xs:string?
)
as
xs:string
fn:substring-after
(
|
$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
zero-length
string.
If
the
value
of
$arg2
is
the
zero-length
string,
then
the
function
returns
the
value
of
$arg1
.
If
the
value
of
$arg1
does
not
contain
a
string
that
is
equal
to
the
value
of
$arg2
,
then
the
function
returns
the
zero-length
string.
The
collation
used
by
the
invocation
of
this
function
is
determined
according
to
the
rules
in
7.3.1
Collations
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:substring-after("tattoo",
"tat")
returns
"
.
too
".
"too"
The
expression
returns
fn:substring-after
(
"tattoo",
fn:substring-after("tattoo",
"tattoo")
"".
""
.
The
expression
returns
fn:substring-after
((),
fn:substring-after((),
())
"".
""
.
The
expression
returns
fn:substring-after
(
"abcdefghi",
fn:substring-after("abcdefghi",
"--d-e-",
"CollationA")
"http://example.com/CollationA")
"
.
fghi
".
"fghi"
The
expression
returns
fn:substring-after
(
"abc--d-e-fghi",
fn:substring-after("abc--d-e-fghi",
"--d-e-",
"CollationA")
"http://example.com/CollationA")
"
.
-fghi
".
"-fghi"
The
expression
fn:substring-after
(
"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:substring-after
(
"Eureka!",
"--***-*---",
returns
"CollationA")
"http://example.com/CollationA")
"
.
(The
second
argument
contains
only
ignorable
collation
units
and
is
equivalent
to
the
zero-length
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 widely-used 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
meta-characters,
^
and
$
are
added.
By
default,
the
meta-character
^
matches
the
start
of
the
entire
string,
while
$
matches
the
end
of
the
entire
string.
In
multi-line
mode,
^
matches
the
start
of
any
line
(that
is,
the
start
of
the
entire
string,
and
the
position
immediately
after
a
newline
character),
while
$
matches
the
end
of
any
line
(that
is,
the
end
of
the
entire
string,
and
the
position
immediately
before
a
newline
character).
Newline
here
means
the
character
#x0A
only.
This means that the production in [XML Schema Part 2: Datatypes Second Edition] :
[10]
Char
::=
[^.\?*+()|#x5B#x5D]
is modified to read:
[10]
Char
::=
[^.\?*+{}()|^$#x5B#x5D]
The
characters
#x5B
and
#x5D
correspond
to
"
[
"
and
"
]
"
respectively.
Note:
The definition of Char (production [10]) in [XML Schema Part 2: Datatypes Second Edition] has a known error in which it omits the left brace ("{") and right brace ("}"). That error is corrected here.
The following production:
[11]
charClass
::=
charClassEsc
|
charClassExpr
|
WildCardEsc
is modified to read:
[11]
charClass
::=
charClassEsc
|
charClassExpr
|
WildCardEsc
|
"^"
|
"$"
Reluctant
quantifiers
are
supported.
They
are
indicated
by
a
"
?
"
following
a
quantifier.
Specifically:
X??
matches
X,
once
or
not
at
all
X*?
matches
X,
zero
or
more
times
X+?
matches
X,
one
or
more
times
X{n}?
matches
X,
exactly
n
times
X{n,}?
matches
X,
at
least
n
times
X{n,m}?
matches
X,
at
least
n
times,
but
not
more
than
m
times
The
effect
of
these
quantifiers
is
that
the
regular
expression
matches
the
shortest
possible
substring
consistent
with
the
match
as
a
whole
succeeding.
Without
the
"
?
",
the
regular
expression
matches
the
longest
possible
substring.
To achieve this, the production in [XML Schema Part 2: Datatypes Second Edition] :
[4]
quantifier
::=
[?*+]
|
(
'{'
quantity
'}'
)
is changed to:
[4]
quantifier
::=
(
[?*+]
|
(
'{'
quantity
'}'
)
)
'?'?
Note:
Reluctant
quantifiers
have
no
effect
on
the
results
of
the
boolean
fn:matches
function,
since
this
function
is
only
interested
in
discovering
whether
a
match
exists,
and
not
where
it
exists.
Sub-expressions
(groups)
within
the
regular
expression
are
recognized.
The
regular
expression
syntax
defined
by
[XML
Schema
Part
2:
Datatypes
Second
Edition]
allows
a
regular
expression
to
contain
parenthesized
sub-expressions,
but
attaches
no
special
significance
to
them.
The
function
described
below
allows
access
to
the
parts
of
the
input
string
that
matched
a
sub-expression
(called
captured
substrings).
The
sub-expressions
are
numbered
according
to
the
position
of
the
opening
parenthesis
in
left-to-right
order
within
the
top-level
regular
expression:
the
first
opening
parenthesis
identifies
captured
substring
1,
the
second
identifies
captured
substring
2,
and
so
on.
0
identifies
the
substring
captured
by
the
entire
regular
expression.
If
a
sub-expression
matches
more
than
one
substring
(because
it
is
within
a
construct
that
allows
repetition),
then
only
the
last
substring
that
it
matched
will
be
captured.
fn:replace()
fn:replace
Non-capturing
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.
Back-references
are
allowed.
allowed
outside
a
character
class
expression.
A
back-reference
is
an
additional
kind
of
atom.
The
construct
where
\n
\N
is
a
single
digit
is
always
recognized
as
a
back-reference;
if
this
is
followed
by
further
digits,
these
digits
are
taken
to
be
part
of
the
back-reference
if
and
only
if
the
resulting
number
n
N
NN
is
such
that
the
back-reference
is
preceded
by
sufficiently
many
capturing
subexpressions.
NN
or
more
unescaped
opening
parentheses.
The
regular
expression
is
invalid
if
a
back-reference
refers
to
a
subexpression
that
does
not
exist
or
whose
closing
right
parenthesis
occurs
after
the
back-reference.
A
back-reference
matches
the
string
that
was
matched
by
the
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
back-reference.
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
back-reference
is
interpreted
as
matching
a
zero-length
string.
n
N
Back-references 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
::=
"\"
[1-9][0-9]*
Note:
Within
a
character
class
expression,
\
followed
by
a
digit
is
invalid.
Some
other
regular
expression
languages
interpret
this
as
an
octal
character
reference.
Single
character
escapes
are
extended
to
allow
the
$
character
to
be
escaped.
The
following
production
is
changed:
[24]SingleCharEsc
::=
'\'
[nrt\|.?*+(){}#x2D#x5B#x5D#x5E]
to
[24]SingleCharEsc
::=
'\'
[nrt\|.?*+(){}$#x2D#x5B#x5D#x5E]
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
"dot-all"
mode.
(Perl
calls
this
the
single-line
mode.)
If
the
s
flag
is
not
specified,
the
meta-character
.
matches
any
character
except
a
newline
(
#x0A
)
character.
In
dot-all
mode,
the
meta-character
.
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
dot-all
mode
is
enabled.
m
:
If
present,
the
match
operates
in
multi-line
mode.
By
default,
the
meta-character
^
matches
the
start
of
the
entire
string,
while
$
matches
the
end
of
the
entire
string.
In
multi-line
mode,
^
matches
the
start
of
any
line
(that
is,
the
start
of
the
entire
string,
and
the
position
immediately
after
a
newline
character),
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
case-insensitive
mode.
The
detailed
rules
are
as
follows.
In
these
rules,
a
character
C2
is
considered
to
be
a
case-variant
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:lower-case(C1)
eq
fn:lower-case(C2)
or
fn:upper-case(C1)
eq
fn:upper-case(C2)
Note that the case-variants 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
case-variants.
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
case-variants.
For
example,
the
regular
expression
"[A-Z]"
will
match
all
the
letters
A-Z
and
all
the
letters
a-z.
It
will
also
match
certain
other
characters
such
as
#x212A
(KELVIN
SIGN),
since
fn:lower-case("#x212A")
is
"k".
This
rule
applies
also
to
a
character
range
used
in
a
character
class
subtraction
(
charClassSub
):
thus
[A-Z-[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 case-variants of "Q" in Unicode).
A
back-reference
is
compared
using
case-blind
comparison:
that
is,
each
character
must
either
be
the
same
as
the
corresponding
character
of
the
previously
matched
string,
or
must
be
a
case-variant
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
upper-case
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
zero-length
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
zero-length
string.
The
function
returns
true
if
$input
or
some
substring
of
$input
matches
the
regular
expression
supplied
as
$pattern
.
Otherwise,
the
function
returns
false
.
The
matching
rules
are
influenced
by
the
value
of
$flags
if
present.
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
zero-length
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
zero-length
string.
The
function
returns
the
xs:string
that
is
obtained
by
replacing
each
non-overlapping
substring
of
$input
that
matches
the
given
$pattern
with
an
occurrence
of
the
$replacement
string.
If
two
overlapping
substrings
of
$input
both
match
the
$pattern
,
then
only
the
first
one
(that
is,
the
one
whose
first
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
sub-expression
in
the
regular
expression.
For
each
match
of
the
pattern,
these
variables
are
assigned
the
value
of
the
content
matched
by
the
relevant
sub-expression,
and
the
modified
replacement
string
is
then
substituted
for
the
characters
in
$input
that
matched
the
pattern.
$0
refers
to
the
substring
captured
by
the
regular
expression
as
a
whole.
More
specifically,
the
rules
are
as
follows,
where
S
is
the
number
of
parenthesized
sub-expressions
in
the
regular
expression,
and
N
is
the
decimal
number
formed
by
taking
all
the
digits
that
consecutively
follow
the
$
character:
If
N
=
0
,
then
the
variable
is
replaced
by
the
substring
matched
by
the
regular
expression
as
a
whole.
If
1
<=
N
<=
S
,
then
the
variable
is
replaced
by
the
substring
captured
by
the
Nth
parenthesized
sub-expression.
If
the
Nth
parenthesized
sub-expression
was
not
matched,
then
the
variable
is
replaced
by
the
zero-length
string.
If
S
<
N
<=
9
,
then
the
variable
is
replaced
by
the
zero-length
string.
Otherwise
(if
N
>
S
and
N
>
9
),
the
last
digit
of
N
is
taken
to
be
a
literal
character
to
be
included
"as
is"
in
the
replacement
string,
and
the
rules
are
reapplied
using
the
number
N
formed
by
stripping
off
this
last
digit.
For
example,
if
the
replacement
string
is
"
$23
"
and
there
are
5
substrings,
the
result
contains
the
value
of
the
substring
that
matches
the
second
sub-expression,
followed
by
the
digit
"
3
".
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
zero-length
string,
that
is,
if
the
expression
fn:matches("",
$pattern,
$flags)
returns
true
.
It
is
not
an
error,
however,
if
a
captured
substring
is
zero-length.
An
error
is
raised
[
err:FORX0004
]
if
the
value
of
$replacement
contains
a
"
$
"
character
that
is
not
immediately
followed
by
a
digit
0-9
and
not
immediately
preceded
by
a
"\".
An
error
is
raised
[
err:FORX0004
]
if
the
value
of
$replacement
contains
a
"
\
"
character
that
is
not
part
of
a
"
\\
"
pair,
unless
it
is
immediately
followed
by
a
"
$
"
character.
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
zero-length
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
zero-length
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
zero-length
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
zero-length
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
zero-length
string.
Zero-length
strings
will
also
occur
in
the
result
sequence
if
a
separator
occurs
at
the
end
of
the
$input
string,
or
if
two
adjacent
substrings
match
the
supplied
$pattern
.
If
two
alternatives
within
the
supplied
$pattern
both
match
at
the
same
position
in
the
$input
string,
then
the
match
that
is
chosen
is
the
first.
For
example:
fn:tokenize("abracadabra", "(ab)|(a)") returns ("", "r", "c", "d", "r", "")
An
error
is
raised
[
err:FORX0002
]
if
the
value
of
$pattern
is
invalid
according
to
the
rules
described
in
section
7.6.1
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
zero-length
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:analyze-string
(
|
$input
|
as
xs:string?
, |
$pattern
|
as
xs:string
)
as
element(fn:analyze-string-result)
|
fn:analyze-string
(
|
$input
|
as
xs:string?
, |
$pattern
|
as
xs:string
, | |
$flags
|
as
xs:string
)
as
element(fn:analyze-string-result)
|
The
effect
of
calling
the
first
version
of
this
function
(omitting
the
argument
$flags
)
is
the
same
as
the
effect
of
calling
the
second
version
with
the
$flags
argument
set
to
a
zero-length
string.
Flags
are
defined
in
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
zero-length
string.
In
this
situation
the
result
will
be
an
element
node
with
no
children.
The
function
returns
an
element
node
whose
local
name
is
analyze-string-result
.
This
element
and
all
its
descendant
elements
have
the
namespace
URI
http://www.w3.org/2005/xpath-functions
.
The
namespace
prefix
is
·
implementation
dependent
·
.
The
children
of
this
element
are
a
sequence
of
fn:match
and
fn:non-match
elements.
This
sequence
is
formed
by
breaking
the
$input
string
into
a
sequence
of
strings,
returning
any
substring
that
matches
$pattern
as
the
content
of
a
match
element,
and
any
intervening
substring
as
the
content
of
a
non-match
element.
More
specifically,
the
function
starts
at
the
beginning
of
the
input
string
and
attempts
to
find
the
first
substring
that
matches
the
regular
expression.
If
there
are
several
matches,
the
first
match
is
defined
to
be
the
one
whose
starting
position
comes
first
in
the
string.
If
several
alternatives
within
the
regular
expression
both
match
at
the
same
position
in
the
input
string,
then
the
match
that
is
chosen
is
the
first
alternative
that
matches.
For
example,
if
the
input
string
is
The
quick
brown
fox
jumps
and
the
regular
expression
is
jump|jumps
,
then
the
match
that
is
chosen
is
jump
.
Having found the first match, the instruction proceeds to find the second and subsequent matches by repeating the search, starting at the first 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:non-match
children
of
the
returned
element
node;
the
string
value
of
the
fn:match
or
fn:non-match
element
will
be
the
corresponding
substring
of
$input
,
and
the
string
value
of
the
returned
element
node
will
therefore
be
the
same
as
$input
.
The
content
of
an
fn:non-match
element
is
always
a
single
text
node.
The
content
of
a
fn:match
element,
however,
is
in
general
a
sequence
of
text
nodes
and
fn:group
element
children.
An
fn:group
element
with
a
nr
attribute
having
the
integer
value
N
identifies
the
substring
captured
by
the
Nth
parenthesized
sub-expression
in
the
regular
expression.
For
each
capturing
subexpression
there
will
be
at
most
one
corresponding
fn:group
element
in
each
fn:match
element
in
the
result.
If the function is called twice with the same arguments, it is · 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="UTF-8"?> <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" targetNamespace="http://www.w3.org/2005/xpath-functions" xmlns:fn="http://www.w3.org/2005/xpath-functions" elementFormDefault="qualified"> <xs:element name="analyze-string-result" type="fn:analyze-string-result-type"/> <xs:element name="match" type="fn:match-type"/> <xs:element name="non-match" type="xs:string"/> <xs:element name="group" type="fn:group-type"/> <xs:complexType name="analyze-string-result-type" mixed="true"> <xs:choice minOccurs="0" maxOccurs="unbounded"> <xs:element ref="fn:match"/> <xs:element ref="fn:non-match"/> </xs:choice> </xs:complexType> <xs:complexType name="match-type" mixed="true"> <xs:sequence> <xs:element ref="fn:group" minOccurs="0" maxOccurs="unbounded"/> </xs:sequence> </xs:complexType> <xs:complexType name="group-type" 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
zero-length
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:analyze-string("The
cat
sat
on
the
mat.",
"\w+")
returns
<analyze-string-result
xmlns="http://www.w3.org/2005/xpath-functions">
<match>The</match>
<non-match>
</non-match>
<match>cat</match>
<non-match>
</non-match>
<match>sat</match>
<non-match>
</non-match>
<match>on</match>
<non-match>
</non-match>
<match>the</match>
<non-match>
</non-match>
<match>mat</match>
<non-match>.</non-match>
</analyze-string-result>
.
The
expression
fn:analyze-string("2008-12-03",
"^(\d+)\-(\d+)\-(\d+)$")
returns
<analyze-string-result
xmlns="http://www.w3.org/2005/xpath-functions">
<match><group
nr="1">2008</group>-<group
nr="2">12</group>-<group
nr="3">03</group></match>
</analyze-string-result>
.
The
expression
fn:analyze-string("A1,C15,,D24,
X50,",
"([A-Z])([0-9]+)")
returns
<analyze-string-result
xmlns="http://www.w3.org/2005/xpath-functions">
<match><group
nr="1">A</group><group
nr="2">1</group></match>
<non-match>,</non-match>
<match><group
nr="1">C</group><group
nr="2">15</group></match>
<non-match>,,</non-match>
<match><group
nr="1">D</group><group
nr="2">24</group></match>
<non-match>,
</non-match>
<match><group
nr="1">X</group><group
nr="2">50</group></match>
<non-match>,</non-match>
</analyze-string-result>
.
This
section
specifies
functions
that
take
anyURI
manipulate
URI
values,
either
as
arguments.
instances
of
xs:anyURI
or
as
strings.
Function | Meaning |
---|---|
fn:resolve-uri
|
|
|
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:escape-html-uri
|
Escapes
a
|
Resolves a relative URI reference against an absolute URI.
fn:resolve-uri
(
$relative
as
xs:string?
)
as
xs:anyURI?
fn:resolve-uri
(
$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
base-uri
property
from
the
static
context.
If
the
base-uri
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
base-uri
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
base-uri
property
from
the
static
context.
If
the
base-uri
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
non-hierarchic
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:encode-for-uri
(
$uri-part
as
xs:string?
)
as
xs:string
If
$uri-part
is
the
empty
sequence,
the
function
returns
the
zero-length
string.
This
function
applies
the
URI
escaping
rules
defined
in
section
2
of
[RFC
3986]
to
the
xs:string
supplied
as
$uri-part
.
The
effect
of
the
function
is
to
escape
reserved
characters.
Each
such
character
in
the
string
is
replaced
with
its
percent-encoded
form
as
described
in
[RFC
3986]
.
Since [RFC 3986] recommends that, for consistency, URI producers and normalizers should use uppercase hexadecimal digits for all percent-encodings, this function must always generate hexadecimal values using the upper-case letters A-F.
All characters are escaped except those identified as "unreserved" by [RFC 3986] , that is the upper- and lower-case letters A-Z, the digits 0-9, HYPHEN-MINUS ("-"), LOW LINE ("_"), FULL STOP ".", and TILDE "~".
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:encode-for-uri("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/",
encode-for-uri("~bébé"))
returns
"http://www.example.com/~b%C3%A9b%C3%A9"
.
The
expression
concat("http://www.example.com/",
encode-for-uri("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:iri-to-uri
(
$iri
as
xs:string?
)
as
xs:string
If
$iri
is
the
empty
sequence,
the
function
returns
the
zero-length
string.
Otherwise,
the
function
converts
the
value
of
$iri
into
a
URI
according
to
the
rules
given
in
Section
3.1
of
[RFC
3987]
by
percent-encoding
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
percent-encoded
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 percent-encodings, this function must always generate hexadecimal values using the upper-case letters A-F.
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
percent-encoded.
In
addition,
characters
outside
the
range
x20-
x7E
will
be
percent-encoded
because
they
are
invalid
in
a
URI.
Since this function does not escape the PERCENT SIGN "%" and this character is not allowed in data within a URI, users wishing to convert character strings (such as file names) that include "%" to a URI should manually escape "%" by replacing it with "%25".
The
expression
fn:iri-to-uri
("http://www.example.com/00/Weather/CA/Los%20Angeles#ocean")
returns
"http://www.example.com/00/Weather/CA/Los%20Angeles#ocean"
.
The
expression
fn:iri-to-uri
("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:escape-html-uri
(
$uri
as
xs:string?
)
as
xs:string
If
$uri
is
the
empty
sequence,
the
function
returns
the
zero-length
string.
Otherwise,
the
function
escapes
all
characters
except
printable
characters
of
the
US-ASCII
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
UTF-8,
and
then
representing
each
of
these
octets
in
the
form
%HH,
where
HH
is
the
hexadecimal
representation
of
the
octet.
This
function
must
always
generate
hexadecimal
values
using
the
upper-case
letters
A-F.
The behavior of this function corresponds to the recommended handling of non-ASCII characters in URI attribute values as described in [HTML 4.0] Appendix B.2.1.
The
expression
fn:escape-html-uri
("http://www.example.com/00/Weather/CA/Los
Angeles#ocean")
returns
"http://www.example.com/00/Weather/CA/Los
Angeles#ocean"
.
The
expression
fn:escape-html-uri
("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:boolean-equal
|
|
op:boolean-less-than
|
|
op:boolean-greater-than
|
|
The
ordering
operators
op:boolean-less-than
and
op:boolean-greater-than
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:boolean-equal
(
$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:boolean-less-than
(
$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:boolean-greater-than
(
$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:boolean-greater-than($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:boolean-less-than($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
YYYY-MM-DDThh: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
·
implementation-defined
·
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
user-defined
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 non-normative 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; P-1347M 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
non-canonical
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. P-134D 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 non-canonical 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:yearMonthDuration-less-than
|
$arg2
.
|
op:yearMonthDuration-greater-than
|
$arg2
.
|
op:dayTimeDuration-less-than
|
$arg2
.
|
op:dayTimeDuration-greater-than
|
$arg2
.
|
op:duration-equal
|
$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:yearMonthDuration-less-than
(
|
$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:yearMonthDuration-greater-than
(
|
$arg1
|
as
xs:yearMonthDuration
, |
$arg2
|
as
xs:yearMonthDuration
)
as
xs:boolean
|
The
function
call
op:yearMonthDuration-greater-than($A,
$B)
is
defined
to
return
the
same
result
as
op:yearMonthDuration-less-than($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:dayTimeDuration-less-than
(
|
$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:dayTimeDuration-greater-than
(
|
$arg1
|
as
xs:dayTimeDuration
, |
$arg2
|
as
xs:dayTimeDuration
)
as
xs:boolean
|
The
function
call
op:dayTimeDuration-greater-than($A,
$B)
is
defined
to
return
the
same
result
as
op:dayTimeDuration-less-than($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:duration-equal
(
$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
zero-length
duration,
no
instance
of
xs:dayTimeDuration
can
ever
be
equal
to
an
instance
of
xs:yearMonthDuration
.
The
expression
op:duration-equal(xs:duration("P1Y"),
xs:duration("P12M"))
returns
true()
.
The
expression
op:duration-equal(xs:duration("PT24H"),
xs:duration("P1D"))
returns
true()
.
The
expression
op:duration-equal(xs:duration("P1Y"),
xs:duration("P365D"))
returns
false()
.
The
expression
op:duration-equal(xs:yearMonthDuration("P0Y"),
xs:dayTimeDuration("P0D"))
returns
true()
.
The
expression
op:duration-equal(xs:yearMonthDuration("P1Y"),
xs:dayTimeDuration("P365D"))
returns
false()
.
The
expression
op:duration-equal(xs:yearMonthDuration("P2Y"),
xs:yearMonthDuration("P24M"))
returns
true()
.
The
expression
op:duration-equal(xs:dayTimeDuration("P10D"),
xs:dayTimeDuration("PT240H"))
returns
true()
.
The
expression
op:duration-equal(xs:duration("P2Y0M0DT0H0M0S"),
xs:yearMonthDuration("P24M"))
returns
true()
.
The
expression
op:duration-equal(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:years-from-duration
| Returns the number of years in a duration. |
|
|
fn:days-from-duration
| Returns the number of days in a duration. |
fn:hours-from-duration
| Returns the number of hours in a duration. |
fn:minutes-from-duration
| Returns the number of minutes in a duration. |
fn:seconds-from-duration
| Returns the number of seconds in a duration. |
Returns the number of years in a duration.
fn:years-from-duration
(
$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:years-from-duration(xs:yearMonthDuration("P20Y15M"))
returns
21
.
The
expression
fn:years-from-duration(xs:yearMonthDuration("-P15M"))
returns
-1
.
The
expression
fn:years-from-duration(xs:dayTimeDuration("-P2DT15H"))
returns
0
.
Returns the number of months in a duration.
fn:months-from-duration
(
$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:months-from-duration(xs:yearMonthDuration("P20Y15M"))
returns
3
.
The
expression
fn:months-from-duration(xs:yearMonthDuration("-P20Y18M"))
returns
-6
.
The
expression
fn:months-from-duration(xs:dayTimeDuration("-P2DT15H0M0S"))
returns
0
.
Returns the number of days in a duration.
fn:days-from-duration
(
$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:days-from-duration(xs:dayTimeDuration("P3DT10H"))
returns
3
.
The
expression
fn:days-from-duration(xs:dayTimeDuration("P3DT55H"))
returns
5
.
The
expression
fn:days-from-duration(xs:yearMonthDuration("P3Y5M"))
returns
0
.
Returns the number of hours in a duration.
fn:hours-from-duration
(
$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:hours-from-duration(xs:dayTimeDuration("P3DT10H"))
returns
10
.
The
expression
fn:hours-from-duration(xs:dayTimeDuration("P3DT12H32M12S"))
returns
12
.
The
expression
fn:hours-from-duration(xs:dayTimeDuration("PT123H"))
returns
3
.
The
expression
fn:hours-from-duration(xs:dayTimeDuration("-P3DT10H"))
returns
-10
.
Returns the number of minutes in a duration.
fn:minutes-from-duration
(
$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:minutes-from-duration(xs:dayTimeDuration("P3DT10H"))
returns
0
.
The
expression
fn:minutes-from-duration(xs:dayTimeDuration("-P5DT12H30M"))
returns
-30
.
Returns the number of seconds in a duration.
fn:seconds-from-duration
(
$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:seconds-from-duration(xs:dayTimeDuration("P3DT10H12.5S"))
returns
12.5
.
The
expression
fn:seconds-from-duration(xs:dayTimeDuration("-PT256S"))
returns
-16.0
.
Function | Meaning |
---|---|
op:add-yearMonthDurations
|
Returns
the
result
of
adding
two
xs:yearMonthDuration
values.
|
op:subtract-yearMonthDurations
|
Returns
the
result
of
subtracting
one
xs:yearMonthDuration
value
from
another.
|
op:multiply-yearMonthDuration
|
Returns
the
result
of
multiplying
the
value
of
$arg1
by
$arg2
.
The
result
is
rounded
to
the
nearest
month.
|
op:divide-yearMonthDuration
|
Returns
the
result
of
dividing
the
value
of
$arg1
by
$arg2
.
The
result
is
rounded
to
the
nearest
month.
|
op:divide-yearMonthDuration-by-yearMonthDuration
|
Returns
the
ratio
of
two
xs:yearMonthDuration
values.
|
op:add-dayTimeDurations
|
Returns
the
sum
of
two
xs:dayTimeDuration
values.
|
op:subtract-dayTimeDurations
|
Returns
the
result
of
subtracting
one
xs:dayTimeDuration
from
another.
|
op:multiply-dayTimeDuration
|
Returns
the
result
of
multiplying
a
xs:dayTimeDuration
by
a
number.
|
op:divide-dayTimeDuration
|
Returns
the
result
of
multiplying
a
xs:dayTimeDuration
by
a
number.
|
op:divide-dayTimeDuration-by-dayTimeDuration
|
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:add-yearMonthDurations
(
|
$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:add-yearMonthDurations(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:subtract-yearMonthDurations
(
|
$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:subtract-yearMonthDurations(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:multiply-yearMonthDuration
(
|
$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
zero-length
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:multiply-yearMonthDuration(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:divide-yearMonthDuration
(
|
$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
zero-length
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:divide-yearMonthDuration(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:divide-yearMonthDuration-by-yearMonthDuration
(
|
$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:numeric-divide
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:divide-yearMonthDuration-by-yearMonthDuration(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:divide-yearMonthDuration-by-yearMonthDuration(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:add-dayTimeDurations
(
|
$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:add-dayTimeDurations(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:subtract-dayTimeDurations
(
|
$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:subtract-dayTimeDurations(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:multiply-dayTimeDuration
(
|
$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
zero-length
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:multiply-dayTimeDuration(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:divide-dayTimeDuration
(
|
$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
zero-length
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:divide-dayTimeDuration(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:divide-dayTimeDuration-by-dayTimeDuration
(
|
$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:numeric-divide
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:round-half-to-even(
op:divide-dayTimeDuration-by-dayTimeDuration(
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:divide-dayTimeDuration-by-dayTimeDuration(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 YYYY-MM-DDThh:mm:ss.s for dateTime, by allowing a preceding minus sign, more than four digits to represent the year field — no maximum is specified — and an unlimited number of digits for fractional seconds. Leap seconds are not supported.
All minimally conforming processors · must · support positive year values with a minimum of 4 digits (i.e., YYYY) and a minimum fractional second precision of 1 millisecond or three digits (i.e., s.sss). However, conforming processors · may · set larger · implementation-defined · limits on the maximum number of digits they support in these two situations. Processors · may · also choose to support the year 0000 and years with negative values. The results of operations on dates that cross the year 0000 are · implementation-defined · .
A processor that limits the number of digits in date and time datatype representations may encounter overflow and underflow conditions when it tries to execute the functions in 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
1999-05-31T05:00:00
is
represented
in
the
datamodel
by
{1999,
5,
31,
5,
0,
0.0,
()}
.
An
xs:dateTime
with
lexical
representation
1999-05-31T13:20:00-05:00
is
represented
by
{1999,
5,
31,
13,
20,
0.0,
-PT5H}
.
An
xs:dateTime
with
lexical
representation
1999-12-31T24:00:00
is
represented
by
{2000,
1,
1,
0,
0,
0.0,
()}
.
An
xs:date
with
lexical
representation
2005-02-28+8:00
is
represented
by
{2005,
2,
28,
(),
(),
(),
PT8H}
.
An
xs:time
with
lexical
representation
24:00:00
is
represented
by
{(),
(),
(),
0,
0,
0,
()}
.
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("1999-12-31"),
xs:time("12:00:00"))
returns
xs:dateTime("1999-12-31T12:00:00")
.
The
expression
fn:dateTime(xs:date("1999-12-31"),
xs:time("24:00:00"))
returns
xs:dateTime("1999-12-31T00:00:00")
.
(This
is
because
"24:00:00"
is
an
alternate
lexical
form
for
"00:00:00"
).
Function | Meaning |
---|---|
op:dateTime-equal
|
Returns
true
if
the
two
supplied
xs:dateTime
values
refer
to
the
same
instant
in
time.
|
op:dateTime-less-than
|
|
op:dateTime-greater-than
|
|
op:date-equal
|
true
if
and
only
if
the
starting
instants
of
the
two
supplied
xs:date
values
are
the
same.
|
op:date-less-than
|
$arg1
is
less
than
the
starting
instant
of
$arg2
.
Returns
false
otherwise.
|
op:date-greater-than
|
$arg1
is
greater
than
the
starting
instant
of
$arg2
.
Returns
false
otherwise.
|
op:time-equal
|
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:time-less-than
|
true
if
the
first
xs:time
|
op:time-greater-than
|
true
if
the
first
xs:time
|
op:gYearMonth-equal
|
xs:gYearMonth
values
have
the
same
starting
instant.
|
op:gYear-equal
|
xs:gYear
values
have
the
same
starting
instant.
|
op:gMonthDay-equal
|
xs:gMonthDay
values
have
the
same
starting
instant,
when
considered
as
days
in
the
same
year.
|
op:gMonth-equal
|
xs:gMonth
values
have
the
same
starting
instant,
when
considered
as
months
in
the
same
year.
|
op:gDay-equal
|
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
1972-12-31T00:00:00
and
1972-01-01T00:00:00
xs:date
value
to
be
compared
is
1993-03-31
.
Filling
in
the
time
components
from
the
reference
xs:dateTime
2009-03-12
we
get
is
1993-03-31T00:00:00
2009-03-12T00: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
1972-01-01T13:30:02
;
and
the
missing
components
from
starting
instant
corresponding
to
the
reference
xs:dateTime
gMonthDay
and
we
get
value
1972-12-31T12:30:00
--02-29
which
is
the
time
on
that
day.
For
an
xs:gYearMonth
1972-02-29T00: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
1976-02
we
fill
in
1972-12-31T00: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
1976-02-29T00: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
1972-12-31T00:00:00
1972-01-01T00: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
1972-12-31T00:00:00
1972-01-01T00: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:yearMonthDuration-greater-than
op:yearMonthDuration-greater-than
(
$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:dayTimeDuration-less-than
op:dayTimeDuration-less-than
(
$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:dayTimeDuration-greater-than
op:dayTimeDuration-greater-than
(
$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:duration-equal
op:dateTime-equal
(
$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
zero-length
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:duration-equal(xs:duration("P1Y"),
xs:duration("P12M"))
returns
true
.
op:duration-equal(xs:duration("PT24H"),
xs:duration("P1D"))
returns
true
.
op:duration-equal(xs:duration("P1Y"),
xs:duration("P365D"))
returns
false
.
op:duration-equal(xs:yearMonthDuration("P0Y"),
xs:dayTimeDuration("PT0D"))
returns
true
.
op:duration-equal(xs:yearMonthDuration("P1Y"),
xs:dayTimeDuration("PT365D"))
returns
false
.
op:duration-equal(xs:yearMonthDuration("P2Y"),
xs:yearMonthDuration("P24M"))
returns
true
.
op:duration-equal(xs:dayTimeDuration("PT10D"),
xs:dayTimeDuration("PT240H"))
returns
true
.
op:duration-equal(xs:duration("P2Y0M0DT0H0M0S"),
xs:yearMonthDuration("P24M"))
then
returns
true
if
and
only
if
the
effective
value
of
.
op:duration-equal(xs:duration("P0Y0M10D"),
xs:dayTimeDuration("PT240H"))
returns
true
.
10.4.6
op:dateTime-equal
op:dateTime-equal
(
$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:dateTime-equal(xs:dateTime("2002-04-02T12:00:00-01:00"),
xs:dateTime("2002-04-02T17:00:00+04:00"))
returns
.
true
true()
The
expression
op:dateTime-equal(xs:dateTime("2002-04-02T12:00:00"),
xs:dateTime("2002-04-02T23:00:00+06:00"))
returns
.
true
true()
The
expression
op:dateTime-equal(xs:dateTime("2002-04-02T12:00:00"),
xs:dateTime("2002-04-02T17:00:00"))
returns
.
false
false()
The
expression
op:dateTime-equal(xs:dateTime("2002-04-02T12:00:00"),
xs:dateTime("2002-04-02T12:00:00"))
returns
.
true
true()
The
expression
op:dateTime-equal(xs:dateTime("2002-04-02T23:00:00-04:00"),
xs:dateTime("2002-04-03T02:00:00-01:00"))
returns
.
true
true()
The
expression
op:dateTime-equal(xs:dateTime("1999-12-31T24:00:00"),
xs:dateTime("2000-01-01T00:00:00"))
returns
.
true
true()
The
expression
op:dateTime-equal(xs:dateTime("2005-04-04T24:00:00"),
xs:dateTime("2005-04-04T00: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:dateTime-less-than
(
$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:dateTime-greater-than
(
|
$arg1
|
as
xs:dateTime
,
|
$arg2
|
as
xs:dateTime
)
as
xs:boolean
|
The
function
call
op:dateTime-greater-than($A,
$B)
is
defined
to
return
the
same
result
as
op:dateTime-less-than($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:date-equal
(
$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:dateTime-equal
.
This
function
backs
up
returns
the
"eq",
"ne",
"le"
and
"ge"
operators
on
xs:date
values.
result
of
the
expression:
op:dateTime-equal(xs:dateTime($arg1), xs:dateTime($arg2))
The
expression
op:date-equal(xs:date("2004-12-25Z"),
xs:date("2004-12-25+07:00"))
returns
.
false
false()
The
(The
starting
instants
are
xs:dateTime("2004-12-25T00:00:00Z")
and
xs:dateTime("2004-12-25T00:00:00+07:00")
.
These
are
normalized
to
xs:dateTime("2004-12-25T00:00:00Z")
and
xs:dateTime("2004-12-24T17:00:00Z")
.
).
The
expression
op:date-equal(xs:date("2004-12-25-12:00"),
xs:date("2004-12-26+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:date-less-than
(
$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:dateTime-less-than
.
This
function
backs
up
returns
the
"lt"
and
"le"
operators
on
xs:date
values.
result
of
the
expression:
op:dateTime-less-than(xs:dateTime($arg1), xs:dateTime($arg2))
The
expression
op:date-less-than(xs:date("2004-12-25Z"),
xs:date("2004-12-25-05:00"))
returns
.
true
true()
The
expression
op:date-less-than(xs:date("2004-12-25-12:00"),
xs:date("2004-12-26+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:date-greater-than
(
$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:date-greater-than($A,
$B)
xs:dateTime
at
time
00:00:00
on
that
date.
The
two
starting
instants
are
compared
using
op:dateTime-greater-than
same
result
as
.
This
function
backs
up
the
"gt"
and
"ge"
operators
on
xs:date
op:date-less-than($B,
$A)
values.
10.4.11.1
The
expression
op:date-greater-than(xs:date("2004-12-25Z"),
xs:date("2004-12-25+07:00"))
returns
.
true
true()
The
expression
op:date-greater-than(xs:date("2004-12-25-12:00"),
xs:date("2004-12-26+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:time-equal
(
$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:dateTime-equal
.
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:dateTime-equal( fn:dateTime(xs:date('1972-12-31'), $arg1), fn:dateTime(xs:date('1972-12-31'), $arg2))
Assume
that
the
date
components
from
the
reference
xs:dateTime
correspond
to
1972-12-31
.
The
expression
op:time-equal(xs:time("08:00:00+09:00"),
xs:time("17:00:00-06:00"))
returns
.
false
false()
The
(The
xs:dateTime
s
calculated
using
the
reference
date
components
are
1972-12-31T08:00:00+09:00
and
1972-12-31T17:00:00-06:00
.
These
normalize
to
1972-12-30T23:00:00Z
and
1972-12-31T23:00:00
.
).
The
expression
op:time-equal(xs:time("21:30:00+10:30"),
xs:time("06:00:00-05:00"))
returns
.
true
true()
The
expression
op:time-equal(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:time-less-than
(
$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:dateTime-less-than
.
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:dateTime-less-than( fn:dateTime(xs:date('1972-12-31'), $arg1), fn:dateTime(xs:date('1972-12-31'), $arg2))
Assume
that
the
dynamic
context
provides
an
implicit
timezone
value
of
-05:00
.
The
expression
op:time-less-than(xs:time("12:00:00"),
xs:time("23:00:00+06:00"))
returns
.
false
false()
The
expression
op:time-less-than(xs:time("11:00:00"),
xs:time("17:00:00Z"))
returns
.
true
true()
The
expression
op:time-less-than(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:time-greater-than
(
$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:time-greater-than($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:dateTime-greater-than
result
as
.
This
function
backs
up
the
"gt"
and
"ge"
operators
on
xs:time
op:time-less-than($B,
$A)
values.
10.4.14.1
The
expression
op:time-greater-than(xs:time("08:00:00+09:00"),
xs:time("17:00:00-06: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:gYearMonth-equal
(
|
$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
.
xxxx-xx-ddT00:00:00
where
dd
represents
the
last
day
of
the
month
component
in
$arg1
or
$arg2
xxxx-xx-01T00: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:dateTime-equal
.
Assume
that
the
dynamic
context
provides
an
implicit
timezone
value
of
-05:00
.
returns
op:gYearMonth-equal(xs:gYearMonth("1976-02"),
xs:gYearMonth("1976-03Z"))
op:gYearMonth-equal(xs:gYearMonth("1986-02"),
xs:gYearMonth("1986-03"))
.
The
starting
instants
are
false
false()
and
1972-02-29T00:00:00-05:00
1986-02-01T00:00:00-05:00
,
respectively.
1972-03-31T00:00:00Z
1986-03-01T00:00:00
returns
op:gYearMonth-equal(xs:gYearMonth("1976-03"),
xs:gYearMonth("1976-03Z"))
op:gYearMonth-equal(xs:gYearMonth("1978-03"),
xs:gYearMonth("1986-03Z"))
.
The
starting
instants
are
false
false()
1986-03-01T00:00:00-05:00
and
1986-03-01T00: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:gYear-equal
(
$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
xxxx-01-01T00: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:dateTime-equal
.
Assume
that
the
dynamic
context
provides
an
implicit
timezone
value
of
-05:00
.
Assume,
also,
that
the
xs:dateTime
template
is
xxxx-01-01T00:00:00
.
op:gYear-equal(xs:gYear("2005-12:00"),
xs:gYear("2005+12:00"))
returns
.
The
starting
instants
are
false
false()
2005-01-01T00:00:00-12:00
and
2005-01-01T00:00:00+12:00
,
respectively,
and
normalize
to
and
2005-01-015T12:00:00Z
2005-01-01T12:00:00Z
2004-12-31T12:00:00Z
.
The
expression
op:gYear-equal(xs:gYear("1976-05: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:gMonthDay-equal
(
$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
1972-xx-xxT00: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:dateTime-equal
.
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).
1976-xx-xxT00:00:00
.
1972-xx-xxT00:00:00
The
expression
op:gMonthDay-equal(xs:gMonthDay("--12-25-14:00"),
xs:gMonthDay("--12-26+10:00"))
returns
.
(
The
starting
instants
are
true
true()
and
1976-12-25T00:00:00-14:00
1972-12-25T00:00:00-14:00
,
respectively,
and
normalize
to
1976-12-26T00:00:00+10:00
1972-12-26T00:00:00+10:00
and
1976-12-25T14:00:00Z
1972-12-25T14:00:00Z
.
).
1976-12-25T14:00:00Z
1972-12-25T14:00:00Z
The
expression
op:gMonthDay-equal(xs:gMonthDay("--12-25"),
xs:gMonthDay("--12-26Z"))
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:gMonth-equal
(
$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
1972-xx-ddT00:00:00
where
dd
represents
the
last
day
of
the
month
component
in
$arg1
1972-xx-01T00: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:dateTime-equal
.
Assume
that
the
dynamic
context
provides
an
implicit
timezone
value
of
-05:00
.
Assume,
also,
that
the
xs:dateTime
template
chosen
is
.
1972-xx-29T00:00:00
1972-xx-01T00:00:00
The
expression
op:gMonth-equal(xs:gMonth("--12-14:00"),
returns
xs:gMonth("--12+10:00")
xs:gMonth("--12+10:00"))
.
(
The
starting
instants
are
false
false()
and
1972-12-29T00:00:00-14:00
1972-12-01T00:00:00-14:00
,
respectively,
and
normalize
to
1972-12-29T00:00:00+10:00
1972-12-01T00:00:00+10:00
and
1972-12-29T14:00:00Z
1972-11-30T14:00:00Z
.
).
1972-12-28T14:00:00Z
1972-12-01T14:00:00Z
The
expression
op:gMonth-equal(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:gDay-equal
(
$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
1972-12-xxT00: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:dateTime-equal
.
Assume
that
the
dynamic
context
provides
an
implicit
timezone
value
of
-05:00
.
Assume,
also,
that
the
xs:dateTime
template
is
.
1976-12-xxT00:00:00
1972-12-xxT00:00:00
The
expression
op:gDay-equal(xs:gDay("---25-14:00"),
xs:gDay("---25+10:00"))
returns
.
(
The
starting
instants
are
false
false()
1972-12-25T00:00:00-14:00
and
1972-12-25T00:00:00+10:00
,
respectively,
and
normalize
to
1972-12-25T14:00:00Z
and
1972-12-24T14:00:00Z
.
).
The
expression
op:gDay-equal(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:year-from-dateTime
|
Returns
the
year
xs:dateTime
.
|
fn:month-from-dateTime
|
Returns
the
month
xs:dateTime
.
|
fn:day-from-dateTime
|
Returns
the
day
xs:dateTime
.
|
fn:hours-from-dateTime
|
Returns
the
hours
xs:dateTime
.
|
fn:minutes-from-dateTime
|
Returns
the
xs:dateTime
.
|
fn:seconds-from-dateTime
|
Returns
the
seconds
xs:dateTime
.
|
fn:timezone-from-dateTime
|
Returns
the
timezone
xs:dateTime
.
|
fn:year-from-date
|
Returns
the
year
xs:date
.
|
fn:month-from-date
|
Returns
the
month
xs:date
.
|
fn:day-from-date
|
Returns
the
day
xs:date
.
|
fn:timezone-from-date
|
Returns
the
timezone
xs:date
.
|
fn:hours-from-time
|
Returns
the
hours
xs:time
.
|
fn:minutes-from-time
|
Returns
the
minutes
xs:time
.
|
fn:seconds-from-time
|
Returns
the
seconds
xs:time
.
|
fn:timezone-from-time
|
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:years-from-duration(xs:yearMonthDuration("P20Y15M"))
returns
21
.
fn:years-from-duration(xs:yearMonthDuration("-P15M"))
returns
-1
.
fn:years-from-duration(xs:dayTimeDuration("-P2DT15H"))
returns
0
xs:dateTime
fn:months-from-duration
fn:year-from-dateTime
(
$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:months-from-duration(xs:yearMonthDuration("P20Y15M"))
returns
3
.
fn:months-from-duration(xs:yearMonthDuration("-P20Y18M"))
returns
-6
.
fn:months-from-duration(xs:dayTimeDuration("-P2DT15H0M0S"))
returns
0
.
10.5.3
fn:days-from-duration
fn:days-from-duration
(
$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:days-from-duration(xs:yearMonthDuration("P3Y5M"))
Otherwise,
the
function
returns
0
.
10.5.4
fn:hours-from-duration
fn:hours-from-duration
(
$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:hours-from-duration(xs:dayTimeDuration("PT123H"))
fn:year-from-dateTime(xs:dateTime("1999-05-31T13:20:00-05:00"))
.
3
1999
The
expression
returns
fn:hours-from-duration(xs:dayTimeDuration("-P3DT10H"))
fn:year-from-dateTime(xs:dateTime("1999-05-31T21:30:00-05: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:minutes-from-duration(xs:dayTimeDuration("P3DT10H"))
fn:year-from-dateTime(xs:dateTime("1999-12-31T19:20:00"))
.
0
1999
The
expression
returns
fn:minutes-from-duration(xs:dayTimeDuration("-P5DT12H30M"))
fn:year-from-dateTime(xs:dateTime("1999-12-31T24: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:seconds-from-duration(xs:dayTimeDuration("P3DT10H12.5S"))
returns
12.5
.
fn:seconds-from-duration(xs:dayTimeDuration("-P256S"))
returns
-16.0
xs:dateTime
fn:year-from-dateTime
fn:month-from-dateTime
(
$arg
as
xs:dateTime?
)
as
xs:integer?
If
$arg
is
the
empty
sequence,
the
function
returns
the
empty
sequence.
fn:year-from-dateTime(xs:dateTime("1999-12-31T24:00:00"))
Otherwise,
the
function
returns
2000
.
10.5.8
fn:month-from-dateTime
fn:month-from-dateTime
(
$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:month-from-dateTime(xs:dateTime("1999-05-31T13:20:00-05:00"))
returns
5
.
The
expression
fn:month-from-dateTime(xs:dateTime("1999-12-31T19:20:00-05:00"))
returns
12
.
The
expression
fn:month-from-dateTime(fn:adjust-dateTime-to-timezone(xs:dateTime("1999-12-31T19:20:00-05:00"),
xs:dayTimeDuration("PT0S")))
returns
1
.
Returns
the
day
component
of
an
xs:dateTime
.
fn:day-from-dateTime
(
$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:day-from-dateTime(xs:dateTime("1999-05-31T13:20:00-05:00"))
returns
31
.
The
expression
fn:day-from-dateTime(xs:dateTime("1999-12-31T20:00:00-05:00"))
returns
31
.
The
expression
fn:day-from-dateTime(fn:adjust-dateTime-to-timezone(xs:dateTime("1999-12-31T19:20:00-05:00"),
xs:dayTimeDuration("PT0S")))
returns
1
.
Returns
the
hours
component
of
an
xs:dateTime
.
fn:hours-from-dateTime
(
$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:hours-from-dateTime(xs:dateTime("1999-05-31T08:20:00-05:00"))
returns
8
.
The
expression
fn:hours-from-dateTime(xs:dateTime("1999-12-31T21:20:00-05:00"))
returns
21
.
The
expression
fn:hours-from-dateTime(fn:adjust-dateTime-to-timezone(xs:dateTime("1999-12-31T21:20:00-05:00"),
xs:dayTimeDuration("PT0S")))
returns
2
.
The
expression
fn:hours-from-dateTime(xs:dateTime("1999-12-31T12:00:00"))
returns
12
.
The
expression
fn:hours-from-dateTime(xs:dateTime("1999-12-31T24:00:00"))
returns
0
.
Returns
the
minute
component
of
an
xs:dateTime
.
fn:minutes-from-dateTime
(
$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:minutes-from-dateTime(xs:dateTime("1999-05-31T13:20:00-05:00"))
returns
20
.
.
The
expression
fn:minutes-from-dateTime(xs:dateTime("1999-05-31T13:30:00+05:30"))
returns
30
.
.
Returns
the
seconds
component
of
an
xs:dateTime
.
fn:seconds-from-dateTime
(
$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:seconds-from-dateTime(xs:dateTime("1999-05-31T13:20:00-05:00"))
returns
0
.
Returns
the
timezone
component
of
an
xs:dateTime
.
fn:timezone-from-dateTime
(
$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:timezone-from-dateTime(xs:dateTime("1999-05-31T13:20:00-05:00"))
returns
the
xs:dayTimeDuration
whose
value
is
.
-PT5H
xs:dayTimeDuration("-PT5H")
The
expression
fn:timezone-from-dateTime(xs:dateTime("2000-06-12T13:20:00Z"))
returns
the
.
xs:dayTimeDuration
whose
value
is
PT0S
xs:dayTimeDuration("PT0S")
The
expression
fn:timezone-from-dateTime(xs:dateTime("2004-08-27T00:00:00"))
returns
()
.
Returns
the
year
component
of
an
xs:date
.
fn:year-from-date
(
$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:year-from-date(xs:date("1999-05-31"))
returns
1999
.
The
expression
fn:year-from-date(xs:date("2000-01-01+05:00"))
returns
2000
.
Returns
the
month
component
of
an
xs:date
.
fn:month-from-date
(
$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:month-from-date(xs:date("1999-05-31-05:00"))
returns
5
.
.
The
expression
fn:month-from-date(xs:date("2000-01-01+05:00"))
returns
1
.
Returns
the
day
component
of
an
xs:date
.
fn:day-from-date
(
$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:day-from-date(xs:date("1999-05-31-05:00"))
returns
31
.
The
expression
fn:day-from-date(xs:date("2000-01-01+05:00"))
returns
1
.
Returns
the
timezone
component
of
an
xs:date
.
fn:timezone-from-date
(
$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:timezone-from-date(xs:date("1999-05-31-05:00"))
returns
the
xs:dayTimeDuration
whose
value
is
.
-PT5H
xs:dayTimeDuration("-PT5H")
The
expression
fn:timezone-from-date(xs:date("2000-06-12Z"))
returns
the
xs:dayTimeDuration
with
value
.
PT0S
xs:dayTimeDuration("PT0S")
Returns
the
hours
component
of
an
xs:time
.
fn:hours-from-time
(
$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:hours-from-time(xs:time("11:23:00"))
returns
11
.
The
expression
fn:hours-from-time(xs:time("21:23:00"))
returns
21
.
The
expression
fn:hours-from-time(xs:time("01:23:00+05:00"))
returns
1
.
The
expression
fn:hours-from-time(fn:adjust-time-to-timezone(xs:time("01:23:00+05:00"),
xs:dayTimeDuration("PT0S")))
returns
20
.
The
expression
fn:hours-from-time(xs:time("24:00:00"))
returns
0
.
Returns
the
minutes
component
of
an
xs:time
.
fn:minutes-from-time
(
$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:minutes-from-time(xs:time("13:00:00Z"))
returns
0
.
.
Returns
the
seconds
component
of
an
xs:time
.
fn:seconds-from-time
(
$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:seconds-from-time(xs:time("13:20:10.5"))
returns
10.5
.
Returns
the
timezone
component
of
an
xs:time
.
fn:timezone-from-time
(
$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:timezone-from-time(xs:time("13:20:00-05:00"))
returns
.
xs:dayTimeDuration
whose
value
is
-PT5H
xs:dayTimeDuration("-PT5H")
The
expression
fn:timezone-from-time(xs:time("13:20:00"))
returns
()
.
Function | Meaning |
---|---|
fn:adjust-dateTime-to-timezone
|
Adjusts
an
xs:dateTime
value
to
a
specific
timezone,
or
to
no
timezone
at
all.
|
fn:adjust-date-to-timezone
|
Adjusts
an
xs:date
value
to
a
specific
timezone,
or
to
no
timezone
at
|
fn:adjust-time-to-timezone
|
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:adjust-dateTime-to-timezone
(
$arg
as
xs:dateTime?
)
as
xs:dateTime?
xs:dateTime
fn:adjust-dateTime-to-timezone
(
|
$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
$tz-10
:=
xs:dayTimeDuration("-PT10H")
The
expression
returns
fn:adjust-dateTime-to-timezone(xs:dateTime("2002-03-07T10:00:00"))
fn:adjust-dateTime-to-timezone(xs:dateTime('2002-03-07T10:00:00'))
.
2002-03-07T10:00:00-05:00
xs:dateTime('2002-03-07T10:00:00-05:00')
The
expression
returns
fn:adjust-dateTime-to-timezone(xs:dateTime("2002-03-07T10:00:00-07:00"))
fn:adjust-dateTime-to-timezone(xs:dateTime('2002-03-07T10:00:00-07:00'))
.
2002-03-07T12:00:00-05:00
xs:dateTime('2002-03-07T12:00:00-05:00')
The
expression
returns
fn:adjust-dateTime-to-timezone(xs:dateTime("2002-03-07T10:00:00"),
$tz)
fn:adjust-dateTime-to-timezone(xs:dateTime('2002-03-07T10:00:00'),
$tz-10)
.
2002-03-07T10:00:00-10:00
xs:dateTime('2002-03-07T10:00:00-10:00')
The
expression
returns
fn:adjust-dateTime-to-timezone(xs:dateTime("2002-03-07T10:00:00-07:00"),
$tz)
fn:adjust-dateTime-to-timezone(xs:dateTime('2002-03-07T10:00:00-07:00'),
$tz-10)
.
2002-03-07T07:00:00-10:00
xs:dateTime('2002-03-07T07:00:00-10:00')
The
expression
returns
fn:adjust-dateTime-to-timezone(xs:dateTime("2002-03-07T10:00:00-07:00"),
fn:adjust-dateTime-to-timezone(xs:dateTime('2002-03-07T10:00:00-07:00'),
xs:dayTimeDuration("PT10H"))
.
2002-03-08T03:00:00+10:00
xs:dateTime('2002-03-08T03:00:00+10:00')
The
expression
returns
fn:adjust-dateTime-to-timezone(xs:dateTime("2002-03-07T00:00:00+01:00"),
fn:adjust-dateTime-to-timezone(xs:dateTime('2002-03-07T00:00:00+01:00'),
xs:dayTimeDuration("-PT8H"))
.
2002-03-06T15:00:00-08:00
xs:dateTime('2002-03-06T15:00:00-08:00')
The
expression
returns
fn:adjust-dateTime-to-timezone(xs:dateTime("2002-03-07T10:00:00"),
fn:adjust-dateTime-to-timezone(xs:dateTime('2002-03-07T10:00:00'),
())
.
2002-03-07T10:00:00
xs:dateTime('2002-03-07T10:00:00')
The
expression
returns
fn:adjust-dateTime-to-timezone(xs:dateTime("2002-03-07T10:00:00-07:00"),
fn:adjust-dateTime-to-timezone(xs:dateTime('2002-03-07T10:00:00-07:00'),
())
.
2002-03-07T10:00:00
xs:dateTime('2002-03-07T10: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:adjust-date-to-timezone
(
$arg
as
xs:date?
)
as
xs:date?
fn:adjust-date-to-timezone
(
|
$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:adjust-dateTime-to-timezone($srcdt,
fn:adjust-dateTime-to-timezone($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
$tz-10
:=
xs:dayTimeDuration("-PT10H")
The
expression
fn:adjust-date-to-timezone(xs:date("2002-03-07"))
returns
.
2002-03-07-05:00.
xs:date("2002-03-07-05:00")
The
expression
fn:adjust-date-to-timezone(xs:date("2002-03-07-07:00"))
returns
.
(
2002-03-07-05:00
xs:date("2002-03-07-05:00")
$arg
is
converted
to
the
.
This
is
adjusted
to
the
implicit
timezone,
giving
xs:dateTime
"2002-03-07T00:00:00-07:00"
xs:dateTime("2002-03-07T00:00:00-07:00")
.
).
"2002-03-07T02:00:00-05:00".
"2002-03-07T02:00:00-05:00"
The
expression
fn:adjust-date-to-timezone(xs:date("2002-03-07"),
returns
$tz)
$tz-10)
.
2002-03-07-10:00
xs:date("2002-03-07-10:00")
The
expression
fn:adjust-date-to-timezone(xs:date("2002-03-07-07:00"),
returns
$tz)
$tz-10)
.
(
2002-03-06-10:00
xs:date("2002-03-06-10:00")
$arg
is
converted
to
the
xs:dateTime
"2002-03-07T00:00:00-07:00"
.
This
is
adjusted
to
the
given
timezone,
giving
"2002-03-06T21:00:00-10:00"
.
).
The
expression
fn:adjust-date-to-timezone(xs:date("2002-03-07"),
())
returns
.
2002-03-07.
xs:date("2002-03-07")
The
expression
fn:adjust-date-to-timezone(xs:date("2002-03-07-07:00"),
())
returns
.
2002-03-07.
xs:date("2002-03-07")
Adjusts
an
xs:time
value
to
a
specific
timezone,
or
to
no
timezone
at
all.
fn:adjust-time-to-timezone
(
$arg
as
xs:time?
)
as
xs:time?
fn:adjust-time-to-timezone
(
|
$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('1972-12-31'),
$arg)
Let
be
the
$r
$adt
result
value
of
evaluating
fn:adjust-dateTime-to-timezone($srcdt,
fn:adjust-dateTime-to-timezone($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
$tz-10
:=
xs:dayTimeDuration("-PT10H")
The
expression
fn:adjust-time-to-timezone(xs:time("10:00:00"))
returns
.
10:00:00-05:00
xs:time("10:00:00-05:00")
The
expression
fn:adjust-time-to-timezone(xs:time("10:00:00-07:00"))
returns
.
12:00:00-05:00
xs:time("12:00:00-05:00")
The
expression
fn:adjust-time-to-timezone(xs:time("10:00:00"),
returns
$tz)
$tz-10)
.
10:00:00-10:00
xs:time("10:00:00-10:00")
The
expression
fn:adjust-time-to-timezone(xs:time("10:00:00-07:00"),
returns
$tz)
$tz-10)
.
07:00:00-10:00
xs:time("07:00:00-10:00")
The
expression
fn:adjust-time-to-timezone(xs:time("10:00:00"),
())
returns
.
10:00:00
xs:time("10:00:00")
The
expression
fn:adjust-time-to-timezone(xs:time("10:00:00-07:00"),
())
returns
.
10:00:00
xs:time("10:00:00")
The
expression
fn:adjust-time-to-timezone(xs:time("10:00:00-07: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:subtract-dateTimes
|
Returns
an
xs:dayTimeDuration
representing
the
.
|
op:subtract-dates
|
Returns
the
xs:dayTimeDuration
that
corresponds
to
the
elapsed
time
between
.
|
op:subtract-times
|
Returns
the
xs:dayTimeDuration
that
corresponds
to
the
elapsed
time
between
treated
as
times
on
the
same
date.
|
op:add-yearMonthDuration-to-dateTime
|
Returns
the
xs:dateTime
|
op:add-dayTimeDuration-to-dateTime
|
Returns
the
xs:dateTime
|
op:subtract-yearMonthDuration-from-dateTime
|
Returns
the
xs:dateTime
|
op:subtract-dayTimeDuration-from-dateTime
|
Returns
the
xs:dateTime
|
op:add-yearMonthDuration-to-date
|
Returns
the
xs:date
|
op:add-dayTimeDuration-to-date
|
Returns
the
xs:date
|
op:subtract-yearMonthDuration-from-date
|
Returns
the
xs:date
|
op:subtract-dayTimeDuration-from-date
|
Returns
the
xs:date
|
op:add-dayTimeDuration-to-time
|
xs:time
|
op:subtract-dayTimeDuration-from-time
|
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:subtract-dateTimes
(
|
$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:subtract-dateTimes(xs:dateTime("2000-10-30T06:12:00"),
xs:dateTime("1999-11-28T09: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:subtract-dates
(
$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:subtract-dateTimes
.
If
the
starting
instant
of
$arg1
precedes
in
time
the
starting
instant
of
$arg2
,
then
the
returned
value
is
a
negative
duration.
Assume
that
the
dynamic
context
provides
an
implicit
timezone
value
of
Z
.
The
expression
op:subtract-dates(xs:date("2000-10-30"),
xs:date("1999-11-28"))
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:subtract-dates(xs:date("2000-10-30"),
xs:date("1999-11-28Z"))
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:subtract-dates(xs:date("2000-10-15-05:00"),
xs:date("2000-10-10+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:subtract-times
(
$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:subtract-dateTimes
.
expression:
op-subtract-dateTimes( fn:dateTime(xs:date('1972-12-31'), $arg1), fn:dateTime(xs:date('1972-12-31'), $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
"1972-12-31"
.
The
expression
op:subtract-times(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:subtract-times(xs:time("11:00:00-05: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:subtract-times(xs:time("17:00:00-06: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:subtract-times(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:add-yearMonthDuration-to-dateTime
(
|
$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:add-yearMonthDuration-to-dateTime(xs:dateTime("2000-10-30T11:12:00"),
xs:yearMonthDuration("P1Y2M"))
returns
an
.
xs:dateTime
value
corresponding
to
the
lexical
representation
"2001-12-30T11:12:00"
xs:dateTime("2001-12-30T11: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:add-dayTimeDuration-to-dateTime
(
|
$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:add-dayTimeDuration-to-dateTime(xs:dateTime("2000-10-30T11:12:00"),
xs:dayTimeDuration("P3DT1H15M"))
returns
an
.
xs:dateTime
value
corresponding
to
the
lexical
representation
"2000-11-02T12:27:00"
xs:dateTime("2000-11-02T12: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:subtract-yearMonthDuration-from-dateTime
(
|
$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:add-yearMonthDuration-to-dateTime
is
negative,
then
the
.
The
expression
xs:dateTime
op:subtract-yearMonthDuration-from-dateTime(xs:dateTime("2000-10-30T11:12:00"),
xs:yearMonthDuration("P1Y2M"))
returned
follows
returns
.
$arg1
xs:dateTime("1999-08-30T11: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:subtract-dayTimeDuration-from-dateTime
(
|
$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:add-dayTimeDuration-to-dateTime
is
negative,
then
the
.
The
expression
xs:dateTime
op:subtract-dayTimeDuration-from-dateTime(xs:dateTime("2000-10-30T11:12:00"),
xs:dayTimeDuration("P3DT1H15M"))
returned
follows
returns
.
$arg1
xs:dateTime("2000-10-27T09: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:add-yearMonthDuration-to-date
(
|
$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:add-yearMonthDuration-to-dateTime
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:add-yearMonthDuration-to-date(xs:date("2000-10-30"),
xs:yearMonthDuration("P1Y2M"))
at
time
returns
.
00:00:00
on
that
date.
xs:date("2001-12-30")
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:add-dayTimeDuration-to-date
(
|
$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:add-dayTimeDuration-to-dateTime
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:add-dayTimeDuration-to-date(xs:date("2004-10-30Z"),
xs:dayTimeDuration("P2DT2H30M0S"))
returns
the
.
(
The
starting
instant
of
the
first
argument
is
the
xs:date
November
1,
2004.
xs:date("2004-11-01Z")
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:subtract-yearMonthDuration-from-date
(
|
$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:add-yearMonthDuration-to-date
values.
10.8.10.1
.
The
expression
op:subtract-yearMonthDuration-from-date(xs:date("2000-10-30"),
xs:yearMonthDuration("P1Y2M"))
returns
the
.
xs:date
August
30,
1999.
xs:date("1999-08-30")
The
expression
op:subtract-yearMonthDuration-from-date(xs:date("2000-02-29Z"),
xs:yearMonthDuration("P1Y"))
returns
the
xs:date
February
28,
1999
in
timezone
.
Z
xs:date("1999-02-28Z")
The
expression
op:subtract-yearMonthDuration-from-date(xs:date("2000-10-31-05:00"),
xs:yearMonthDuration("P1Y1M"))
returns
the
xs:date
September
30,
1999
in
timezone
.
-05:00
xs:date("1999-09-30-05: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:subtract-dayTimeDuration-from-date
(
|
$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:add-dayTimeDuration-to-date
returned
precedes
$arg1
.
.
The
starting
instant
of
an
xs:date
is
the
expression
xs:dateTime
op:subtract-dayTimeDuration-from-date(xs:date("2000-10-30"),
xs:dayTimeDuration("P3DT1H15M"))
at
returns
.
00:00:00
on
that
date.
xs:date("2000-10-26")
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
wrap-around
past
midnight)
This
functions
backs
up
Defines
the
"-"
semantics
of
the
"+"
operator
on
and
xs:date
xs:time
xs:dayTimeDuration
values.
op:add-dayTimeDuration-to-time
(
|
$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
1972-12-31
,
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:add-dayTimeDuration-to-time(xs:time("11:12:00"),
xs:dayTimeDuration("P3DT1H15M"))
returns
xs:time("12:27:00")
.
The
expression
op:add-dayTimeDuration-to-time(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
wrap-around
past
midnight)
Defines
the
semantics
of
the
"-"
operator
on
xs:time
and
xs:dayTimeDuration
values.
op:subtract-dayTimeDuration-from-time
(
|
$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
add-dayTimeDuration-to-time
The
expression
op:subtract-dayTimeDuration-from-time(xs:time("11:12:00"),
xs:dayTimeDuration("P3DT1H15M"))
".
returns
xs:time("09:57:00")
.
The
expression
returns
op:add-dayTimeDuration-to-time(xs:time("23:12:00+03:00"),
xs:dayTimeDuration("P1DT3H15M"))
op:subtract-dayTimeDuration-from-time(xs:time("08:20:00-05:00"),
xs:dayTimeDuration("P23DT10H10M"))
xs:time("22:10:00-05: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:format-dateTime
|
Returns
a
string
containing
an
xs:dateTime
value
formatted
for
display.
|
fn:format-date
|
Returns
a
string
containing
an
xs:date
value
formatted
for
display.
|
fn:format-time
|
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:format-dateTime
(
|
$value
|
as
xs:dateTime?
, |
$picture
|
as
xs:string
, | |
$language
|
as
xs:string?
, | |
$calendar
|
as
xs:string?
, | |
$country
|
as
xs:string?
)
as
xs:string?
|
fn:format-dateTime
(
$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:format-date
(
$value
as
xs:date?
,
$picture
as
xs:string
)
as
xs:string?
Returns
a
string
containing
an
xs:time
value
formatted
for
display.
fn:format-time
(
|
$value
|
as
xs:time?
, |
$picture
|
as
xs:string
, | |
$language
|
as
xs:string?
, | |
$calendar
|
as
xs:string?
, | |
$country
|
as
xs:string?
)
as
xs:string?
|
fn:format-time
(
$value
as
xs:time?
,
$picture
as
xs:string
)
as
xs:string?
Summary:
See
9.8.4
The
date/time
formatting
functions
.
The
fn:format-dateTime
,
fn:format-date
,
and
fn:format-time
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:format-dateTime
,
fn:format-date
,
and
fn:format-time
are
referred
to
collectively
as
the
date
formatting
functions
.
If
$value
is
the
empty
sequence,
the
function
returns
the
empty
sequence.
Calling the two-argument form of each of the three functions is equivalent to calling the five-argument 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 half-day (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
GMT-05: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
format-time
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,
format-integer
,$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
lower-case,
upper-case,
or
title-case
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
implementation-defined
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:format-integer
. |
o |
ordinal
form
of
a
number,
for
example
8th
or
8º
.
This
has
the
same
meaning
as
in
the
second
argument
of
fn:format-integer
.
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:format-integer
,
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:
"," min-width
("-"
max-width)?
where
min-width
is
either
an
unsigned
integer
indicating
the
minimum
number
of
characters
to
be
output,
or
*
indicating
that
there
is
no
explicit
minimum,
and
max-width
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
max-width
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,
1972-12-31
1
[f001]
requests
three
decimal
digits,
[f01]
requests
two
digits,
but
[f1]
will
produce
an
implementation-defined
number
of
digits.
If
exactly
one
digit
is
required,
this
can
be
achieved
using
the
component
specifier
[f1,1-1]
.
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
right-truncation
if
not.
For
example,
setting
max-width
to
4
indicates
that
four-letter
abbreviations
should
be
used,
though
it
would
be
acceptable
to
use
a
three-letter
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
max-width
requests
omission
of
high-order
digits
from
the
year,
for
example,
if
max-width
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
round-half-to-even(fractional-seconds,
max-width)
.
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 · implementation-defined · . When any of these arguments is omitted or is an empty sequence, an · implementation-defined · 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
implementation-dependent
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
3166-1]
)
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
·
implementation-defined
·
language.
The language is used to select the appropriate language-dependent forms of:
names (for example, of months)
numbers expressed as words or as ordinals (twenty, 20th, twentieth
)
hour convention (0-23 vs 1-24, 0-11 vs 1-12)
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
·
implementation-defined
·
.
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
expanded-QName
using
the
in-scope
namespaces
from
the
static
context;
the
expanded-QName
identifies
the
calendar;
the
behavior
in
this
case
is
·
implementation-defined
·
.
If the calendar attribute is omitted an · implementation-defined · 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
·
implementation-defined
·
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
per-language
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
zero-length
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
calendar-neutral.
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:subtract-dayTimeDuration-from-time(xs:time("11:12:00"),
xs:dayTimeDuration("P3DT1H15M"))
1502-01-11
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
ten-day
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
1502-01-01
,
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"
.
-0043-03-13,
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:subtract-dayTimeDuration-from-time(xs:time("08:20:00-05: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
3166-1]
.
Implementations
may
also
allow
the
use
of
codes
representing
subdivisions
of
a
country
from
ISO
3166-2,
or
codes
representing
formerly
used
names
of
countries
from
ISO
3166-3.
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:00-05: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
present-day
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 |
---|---|
|
format-date($d,
"[Y0001]-[M01]-[D01]")
|
12-31-2002
|
format-date($d,
"[M]-[D]-[Y]")
|
31-12-2002
|
format-date($d,
"[D]-[M]-[Y]")
|
31
XII
2002
|
format-date($d,
"[D1]
[MI]
[Y]")
|
31st
December,
2002
|
format-date($d,
"[D1o]
[MNn],
[Y]",
"en",
(),
())
|
31
DEC
2002
|
format-date($d,
"[D01]
[MN,*-3]
[Y0001]",
"en",
(),
())
|
December
31,
2002
|
format-date($d,
"[MNn]
[D],
[Y]",
"en",
(),
())
|
31
Dezember,
2002
|
format-date($d,
"[D]
[MNn],
[Y]",
"de",
(),
())
|
Tisdag
31
December
2002
|
format-date($d,
"[FNn]
[D]
[MNn]
[Y]",
"sv",
(),
())
|
[2002-12-31]
|
format-date($d,
"[[[Y0001]-[M01]-[D01]]]")
|
Two
Thousand
and
Three
|
format-date($d,
"[YWw]",
"en",
(),
())
|
einunddreißigste
Dezember
|
format-date($d,
"[Dwo]
[MNn]",
"de",
(),
())
|
3:58
PM
|
format-time($t,
"[h]:[m01]
[PN]",
"en",
(),
())
|
3:58:45
pm
|
format-time($t,
"[h]:[m01]:[s01]
[Pn]",
"en",
(),
())
|
3:58:45
PM
PDT
|
format-time($t,
"[h]:[m01]:[s01]
[PN]
[ZN,*-3]",
"en",
(),
())
|
3:58:45
o'clock
PM
PDT
|
format-time($t,
"[h]:[m01]:[s01]
o'clock
[PN]
[ZN,*-3]",
"en",
(),
())
|
15:58
|
format-time($t,"[H01]:[m01]")
|
15:58:45.762
|
format-time($t,"[H01]:[m01]:[s01].[f001]")
|
15:58:45
GMT+02:00
|
format-time($t,"[H01]:[m01]:[s01]
[z,6-6]",
"en",
(),
())
|
15.58
Uhr
GMT+2
|
format-time($t,"[H01]:[m01]
Uhr
[z]",
"de",
(),
())
|
3.58pm
on
Tuesday,
31st
December
|
format-dateTime($dt,
"[h].[m01][Pn]
on
[FNn],
[D1o]
[MNn]")
|
12/31/2002
at
15:58:45
|
format-dateTime($dt,
"[M01]/[D01]/[Y0001]
at
[H01]:[m01]:[s01]")
|
The following examples use calendars other than the Gregorian calendar.
These examples use non-Latin characters which might not display correctly in all browsers, depending on the system configuration.
Description | Request | Result |
---|---|---|
Islamic |
format-date($d,
"[D١]
[Mn]
[Y١]",
"ar",
"AH",
())
| ٢٦ ﺸﻭّﺍﻝ ١٤٢٣ |
Jewish (with Western numbering) |
format-date($d,
"[D]
[Mn]
[Y]",
"he",
"AM",
())
| 26 טבת 5763 |
Jewish (with traditional numbering) |
format-date($d,
"[Dאt]
[Mn]
[Yאt]",
"he",
"AM",
())
| כ״ו טבת תשס״ג |
Julian (Old Style) |
format-date($d,
"[D]
[MNn]
[Y]",
"en",
"OS",
())
| 18 December 2002 |
Thai |
format-date($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
in-scope
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:resolve-QName
|
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
expanded-QName)
by
taking
an
xs:string
that
has
the
lexical
form
of
an
xs:QName
(a
string
in
the
form
"prefix:local-name"
or
"local-name")
and
resolving
it
using
the
in-scope
namespaces
for
a
given
element.
fn:resolve-QName
(
$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
zero-length
string
if
it
has
no
prefix,
and
constructs
an
expanded-QName
whose
local
name
is
taken
from
the
supplied
$qname
,
and
whose
namespace
URI
is
taken
from
the
string
value
of
the
namespace
binding.
If
the
$qname
has
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
expanded-QName
has
no
namespace
part.
The
prefix
(or
absence
of
a
prefix)
in
the
supplied
$qname
argument
is
retained
in
the
returned
expanded-QName,
as
discussed
in
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:resolve-QName($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:resolve-QName("hello",
$element)
returns
a
QName
with
local
name
"hello"
that
is
in
no
namespace.
fn:resolve-QName("eg:myFunc",
$element)
returns
an
xs:QName
whose
namespace
URI
is
specified
by
the
namespace
binding
corresponding
to
the
prefix
"eg"
and
whose
local
name
is
"myFunc".
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
zero-length
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
zero-length
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:QName-equal
|
Returns
true
if
two
supplied
QNames
have
the
|
fn:prefix-from-QName
|
Returns
|
fn:local-name-from-QName
|
Returns
|
fn:namespace-uri-from-QName
|
Returns
the
namespace
URI
|
fn:namespace-uri-for-prefix
|
Returns
the
namespace
URI
of
one
of
the
in-scope
namespaces
for
$element
,
identified
by
its
namespace
prefix.
|
fn:in-scope-prefixes
|
Returns
the
prefixes
of
the
in-scope
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:QName-equal
(
$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/xpath-functions/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:codepoint-equal
function.
The
local
parts
are
also
compared
under
the
rules
of
the
fn:codepoint-equal
function.
The
prefix
parts
of
$arg1
and
$arg2
,
if
any,
are
ignored.
Returns the prefix component of the supplied QName.
fn:prefix-from-QName
(
$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:local-name-from-QName
(
$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:local-name-from-QName(fn:QName("http://www.example.com/example",
"person"))
returns
"person"
.
Returns the namespace URI part of the supplied QName.
fn:namespace-uri-from-QName
(
$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
zero-length
string
is
returned.
xs:anyURI
.
The
expression
fn:namespace-uri-from-QName(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
in-scope
namespaces
for
$element
,
identified
by
its
namespace
prefix.
fn:namespace-uri-for-prefix
(
|
$prefix
|
as
xs:string?
,
|
$element
|
as
element()
)
as
xs:anyURI?
|
If
$element
has
an
in-scope
namespace
whose
namespace
prefix
is
equal
to
$prefix
,
it
returns
the
namespace
URI
of
that
namespace.
If
$prefix
is
the
zero-length
string
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 in-scope namespaces for an element node.
fn:in-scope-prefixes
(
$element
as
element()
)
as
xs:string*
Summary:
Returns
The
function
returns
a
sequence
of
strings
representing
the
prefixes
of
the
in-scope
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
zero-length
string.
The result sequence contains no duplicates.
The ordering of the result sequence is · implementation-dependent · .
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:hexBinary-equal
|
Returns
true
if
xs:hexBinary
values
contain
the
same
octet
sequence.
|
op:base64Binary-equal
|
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:hexBinary-equal
(
|
$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:base64Binary-equal
(
|
$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:NOTATION-equal
|
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:NOTATION-equal
(
$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/xpath-functions/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:codepoint-equal
function.
The
local
parts
are
also
compared
under
the
rules
of
the
fn:codepoint-equal
function.
The
prefix
parts
of
$arg1
and
$arg2
,
if
any,
are
ignored.
This
section
discusses
specifies
functions
and
operators
on
nodes.
Nodes
are
formally
defined
in
Section
6
Nodes
DM
.
Function | Meaning |
---|---|
fn:name
|
Returns
the
name
of
a
node,
as
an
xs:string
that
is
either
the
.
|
fn:local-name
|
Returns
the
local
part
of
the
name
of
$arg
as
an
xs:string
that
is
either
the
xs:NCName
.
|
fn:namespace-uri
|
Returns
the
namespace
URI
part
of
the
name
of
$arg
,
as
an
xs:anyURI
|
fn:number
|
Returns
the
value
$arg
or,
if
$arg
is
not
specified,
the
context
item
after
xs:double
.
|
fn:lang
|
$node
,
or
the
context
xml:lang
attributes
is
the
same
as,
or
is
a
sublanguage
of,
the
language
specified
by
$testlang
.
|
op:is-same-node
|
Returns
true
if
the
two
arguments
|
op:node-before
|
|
op:node-after
|
|
fn:root
|
Returns
the
root
of
the
tree
to
which
$arg
belongs.
This
will
usually,
but
not
necessarily,
be
a
document
node.
|
For
the
illustrative
examples
below
assume
an
XQuery
or
transformation
operating
on
a
PurchaseOrder
document
containing
a
number
of
line-item
elements.
Each
line-item
has
child
elements
called
description,
price,
quantity,
etc.
whose
content
is
different
for
each
line-item.
Quantity
has
simple
content
of
type
xs:decimal
.
Further
assume
that
variables
$item1
,
$item2
,
etc.
are
each
bound
to
single
line-item
element
nodes
in
the
document
in
sequence
and
that
the
value
of
the
quantity
child
of
the
first
line-item
is
5.0
.
let
$po
:=
<PurchaseOrder> <line-item><description> ... </description> <price> ... </price><description>Large widget</description> <price>8.95</price> <quantity>5.0</quantity>...</line-item> <line-item>...<description>Small widget</description> <price>3.99</price> <quantity>2.0</quantity> </line-item> <line-item> <description>Tiny widget</description> <price>1.49</price> <quantity>805</quantity> </line-item>...</PurchaseOrder>
let
$item1
:=
$po/line-item[1]
let
$item2
:=
$po/line-item[2]
let
$item3
:=
$po/line-item[3]
Returns
the
name
of
a
node,
as
an
xs:string
that
is
either
the
zero-length
string,
or
has
the
lexical
form
of
an
xs:QName
.
fn:name
()
as
xs:string
fn:name
(
$arg
as
node()?
)
as
xs:string
If
the
argument
is
omitted,
it
defaults
to
the
context
item
(
.
).
The
behavior
of
the
function
if
the
argument
is
omitted
is
exactly
the
same
as
if
the
context
item
had
been
passed
as
the
argument.
The
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
.
If
the
argument
is
supplied
and
is
the
empty
sequence,
the
function
returns
the
zero-length
string.
If
the
target
node
identified
by
$arg
has
no
name
(that
is,
if
it
is
a
document
node,
a
comment,
a
text
node,
or
a
namespace
binding
node
having
no
name),
the
function
returns
the
zero-length
string.
Otherwise,
the
function
returns
the
value
returned
is
of
the
expression
fn:string(fn:node-name($arg))
.
The
following
errors
may
be
raised
when
$arg
is
omitted:
if
the
context
item
is
undefined
[
err:XPDY0002
]
XP
;
if
the
context
item
is
not
a
node
[
err:XPTY0004
]
XP
.
Returns
the
local
part
of
the
name
of
$arg
as
an
xs:string
that
is
either
the
zero-length
string,
or
has
the
lexical
form
of
an
xs:NCName
.
fn:local-name
()
as
xs:string
fn:local-name
(
$arg
as
node()?
)
as
xs:string
If
the
argument
is
omitted,
it
defaults
to
the
context
item
(
.
).
The
behavior
of
the
function
if
the
argument
is
omitted
is
exactly
the
same
as
if
the
context
item
had
been
passed
as
the
argument.
The
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
.
If
the
argument
is
supplied
and
is
the
empty
sequence,
the
function
returns
the
zero-length
string.
If
the
target
node
identified
by
$arg
has
no
name
(that
is,
if
it
is
a
document
node,
a
comment,
or
a
text
node),
node,
or
a
namespace
node
having
no
name),
the
function
returns
the
zero-length
string.
Otherwise,
the
value
returned
will
be
function
returns
the
local
part
of
the
expanded-QName
of
the
target
node
(as
identified
by
$arg
,
as
determined
by
the
dm:node-name
accessor
defined
in
Section
5.11
node-name
Accessor
DM
.
).
This
will
be
an
xs:string
whose
lexical
form
is
an
xs:NCName
.
The
following
errors
may
be
raised
when
$arg
is
omitted:
if
the
context
item
is
undefined
[
err:XPDY0002
]
XP
;
if
the
context
item
is
not
a
node
[
err:XPTY0004
]
XP
.
Returns
the
namespace
URI
part
of
the
name
of
$arg
,
as
an
xs:anyURI
value.
fn:namespace-uri
()
as
xs:anyURI
fn:namespace-uri
(
$arg
as
node()?
)
as
xs:anyURI
If
the
argument
is
omitted,
it
defaults
to
the
context
node
(
.
).
The
behavior
of
the
function
if
the
argument
is
omitted
is
exactly
the
same
as
if
the
context
item
had
been
passed
as
the
argument.
The
following
errors
may
be
raised:
if
the
context
item
is
undefined
[
err:XPDY0002
]
XP
;
if
If
the
context
item
is
not
a
node
[
err:XPTY0004
]
XP
.
If
identified
by
$arg
is
neither
an
element
nor
an
attribute
node,
or
if
it
is
an
element
or
attribute
node
whose
expanded-QName
(as
determined
by
the
dm:node-name
accessor
in
the
Section
5.11
node-name
Accessor
DM
)
is
in
no
namespace,
then
the
function
returns
the
zero-length
xs:anyURI
corresponding
to
value.
Otherwise,
the
zero-length
string.
result
will
be
the
namespace
URI
part
of
the
expanded-QName
of
the
node
identified
by
$arg
,
as
determined
by
the
dm:node-name
accessor
defined
in
Section
5.11
node-name
Accessor
DM
),
returned
as
an
xs:anyURI
value.
The
following
errors
may
be
raised
when
$arg
is
omitted:
if
the
context
item
is
undefined
[
err:XPDY0002
]
XP
;
if
the
context
item
is
not
a
node
[
err:XPTY0004
]
XP
.
Returns
the
value
indicated
by
$arg
or,
if
$arg
is
not
specified,
the
context
item
after
atomization,
converted
to
an
xs:double
.
fn:number
()
as
xs:double
fn:number
(
$arg
as
xs:anyAtomicType?
)
as
xs:double
Calling
the
zero-argument
version
of
the
function
is
defined
to
give
the
same
result
as
calling
the
single-argument
version
with
the
context
item
(
.
).
That
is,
fn:number()
is
equivalent
to
fn:number(.)
.
If
$arg
is
the
empty
sequence
or
if
$arg
or
the
context
item
cannot
be
converted
to
an
xs:double
,
the
xs:double
value
NaN
is
returned.
If
the
context
item
is
undefined
an
error
is
raised:
[
err:XPDY0002
]
XP
.
If
$arg
is
the
empty
sequence,
NaN
is
returned.
Otherwise,
$arg
,
or
the
context
item
after
atomization,
is
converted
to
an
xs:double
following
the
rules
of
17.1.3.2
18.1.3.2
Casting
to
xs:double
.
If
the
conversion
to
xs:double
fails,
the
xs:double
value
NaN
is
returned.
If
$arg
is
omitted
and
the
context
item
is
undefined
an
error
is
raised:
[
err:XPDY0002
]
XP
14.4.1
.
The
expression
fn:number($item1/quantity)
returns
.
5.0
5.0e0
The
expression
returns
fn:number($item2)
fn:number($item2/description)
.
NaN
xs:double('NaN')
Assume
that
the
context
item
is
the
xs:string
value
"
15
".
Then
fn:number()
returns
.
1.5E1
1.5e1
This
function
tests
whether
the
language
of
$node
,
or
the
context
item
if
the
second
argument
is
omitted,
as
specified
by
xml:lang
attributes
is
the
same
as,
or
is
a
sublanguage
of,
the
language
specified
by
$testlang
.
fn:lang
(
$testlang
as
xs:string?
)
as
xs:boolean
fn:lang
(
$testlang
as
xs:string?
,
$node
as
node()
)
as
xs:boolean
Summary:
This
function
tests
whether
the
language
of
$node
,
or
the
context
item
if
the
second
argument
is
omitted,
as
specified
by
xml:lang
attributes
is
the
same
as,
or
is
a
sublanguage
of,
the
language
specified
by
$testlang
.
The
behavior
of
the
function
if
the
second
argument
is
omitted
is
exactly
the
same
as
if
the
context
item
(
.
)
had
been
passed
as
the
second
argument.
The
language
of
the
argument
node,
$node
,
or
the
context
item
if
the
second
argument
is
omitted,
is
determined
by
the
value
of
the
xml:lang
attribute
on
the
node,
or,
if
the
node
has
no
such
attribute,
by
the
value
of
the
xml:lang
attribute
on
the
nearest
ancestor
of
the
node
that
has
an
xml:lang
attribute.
If
there
is
no
such
ancestor,
then
the
function
returns
false
.
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
.
If
$testlang
is
the
empty
sequence
it
is
interpreted
as
the
zero-length
string.
The
relevant
xml:lang
attribute
is
determined
by
the
value
of
the
XPath
expression:
(ancestor-or-self::*/@xml:lang)[last()]
If
this
expression
returns
an
empty
sequence,
the
function
returns
false
.
Otherwise,
the
function
returns
true
if
and
only
if,
based
on
a
caseless
default
match
as
specified
in
section
3.13
of
[The
Unicode
Standard]
,
either:
(1)
$testlang
is
equal
to
the
string-value
of
the
relevant
xml:lang
attribute,
or
(2)
$testlang
is
equal
to
some
substring
of
the
string-value
of
the
relevant
xml:lang
attribute
that
starts
at
the
start
of
the
string-value
and
ends
immediately
before
a
hyphen,
"-"
(The
(the
character
"-"
is
HYPHEN-MINUS,
#x002D).
When
$arg
is
omitted
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
14.5.1
]
XP
.
The
expression
fn:lang("en")
would
return
true
if
the
context
node
were
any
of
the
following
four
elements:
<para
xml:lang="en"/>
<div
xml:lang="en"><para>And
now,
and
forever!</para></div>
<para
xml:lang="EN"/>
<para
xml:lang="en-us"/>
The
expression
fn:lang("fr")
would
return
false
if
the
context
node
were
<para
xml:lang="EN"/>
Returns true if the two arguments refer to the same node.
Defines the semantics of the "is" operator on nodes.
op:is-same-node
(
$parameter1
$arg1
as
node()
,
$parameter2
$arg2
as
node()
)
as
xs:boolean
Summary:
If
the
node
identified
by
the
value
of
is
the
same
node
as
the
node
identified
by
the
value
of
$parameter1
$arg1
(that
is,
the
two
nodes
have
the
same
identity),
then
the
function
returns
$parameter2
$arg2
true
;
otherwise,
the
function
returns
false
.
This
function
backs
up
the
"is"
operator
on
nodes.
The
expression
op:is-same-node($item1,
$item1)
returns
.
true
true()
The
expression
op:is-same-node($item1,
$item2)
returns
.
false
false()
Returns true if the node identified by the first argument precedes the node identified by the second argument in document order.
Defines the semantics of the "<<" operator.
op:node-before
(
$parameter1
$arg1
as
node()
,
$parameter2
$arg2
as
node()
)
as
xs:boolean
Summary:
If
the
node
identified
by
the
value
of
occurs
in
document
order
before
the
node
identified
by
the
value
of
$parameter1
$arg1
,
$parameter2
$arg2
this
then
the
function
returns
true
;
otherwise,
it
returns
false
.
The
rules
determining
the
order
of
nodes
within
a
single
document
and
in
different
documents
can
be
found
in
Section
2.4
Document
Order
DM
.
This
function
backs
up
the
"<<"
operator.
The
expression
op:node-before($item1,
$item2)
returns
.
true
true()
The
expression
op:node-before($item1,
$item1)
returns
.
false
false()
Returns true if the node identified by the first argument follows the node identified by the second argument in document order.
Defines the semantics of the ">>" operator.
op:node-after
(
$parameter1
$arg1
as
node()
,
$parameter2
$arg2
as
node()
)
as
xs:boolean
Summary:
If
the
node
identified
by
the
value
of
occurs
in
document
order
after
the
node
identified
by
the
value
of
$parameter1
$arg1
,
$parameter2
$arg2
this
the
function
returns
true
;
otherwise,
it
returns
false
.
The
rules
determining
the
order
of
nodes
within
a
single
document
and
in
different
documents
can
be
found
in
Section
2.4
Document
Order
DM
.
This
function
backs
up
the
">>"
operator.
The
expression
op:node-after($item1,
$item2)
returns
.
false
false()
The
expression
op:node-after($item1,
$item1)
returns
.
false
false()
The
expression
op:node-after($item2,
$item1)
returns
.
true
true()
Returns
the
root
of
the
tree
to
which
$arg
belongs.
This
will
usually,
but
not
necessarily,
be
a
document
node.
fn:root
()
as
node()
fn:root
(
$arg
as
node()?
)
as
node()?
If
the
function
is
called
without
an
argument,
the
context
item
(
.
)
is
used
as
the
default
argument.
The
behavior
of
the
function
if
the
argument
is
omitted
is
exactly
the
same
as
if
the
context
item
had
been
passed
as
the
argument.
The
function
returns
the
value
of
the
expression
($arg/ancestor-or-self::node())[1]
.
When
$arg
is
omitted
the
following
errors
may
be
raised:
raised
:
if
the
context
item
is
undefined
[
err:XPDY0002
]
XP
;
if
the
context
item
is
not
a
node
[
err:XPTY0004
]
XP
.
These examples use some variables which could be defined in [XQuery 1.0: An XML Query Language] as:
let $i := <tool>wrench</tool> let $o := <order> {$i} <quantity>5</quantity> </order> let $odoc := document {$o} let $newi := $o/tool
Or they could be defined in [XSL Transformations (XSLT) Version 2.0] as:
<xsl:variable name="i" as="element()"> <tool>wrench</tool> </xsl:variable> <xsl:variable name="o" as="element()"> <order> <xsl:copy-of select="$i"/> <quantity>5</quantity> </order> </xsl:variable> <xsl:variable name="odoc"> <xsl:copy-of select="$o"/> </xsl:variable> <xsl:variable name="newi" select="$o/tool"/>
fn:root($i)
returns
the
element
node
$i
fn:root($o/quantity)
returns
the
element
node
$o
fn:root($odoc//quantity)
returns
the
document
node
$odoc
fn:root($newi)
returns
the
element
node
$o
The
final
three
examples
could
be
made
type-safe
by
wrapping
their
operands
with
fn:exactly-one().
fn:exactly-one()
.
A
sequence
is
an
ordered
collection
of
zero
or
more
items
.
An
item
is
either
a
node
or
an
atomic
value.
The
terms
sequence
and
item
are
defined
formally
in
[XQuery
1.0:
An
XML
Query
Language]
and
[XML
Path
Language
(XPath)
2.0]
.
The following functions are defined on sequences.
Function | Meaning |
---|---|
op:concatenate
|
|
|
Returns
|
fn:empty
|
|
fn:exists
|
|
|
Returns
a
sequence
$seqArg
of
items
that
are
$searchArg
.
|
fn:insert-before
|
|
fn:remove
|
$target
except
the
item
at
position
$position
.
|
fn:reverse
|
Reverses the order of items in a sequence. |
fn:subsequence
|
Returns
the
$sourceSeq
beginning
at
the
position
indicated
by
$startingLoc
and
continuing
for
the
number
of
items
indicated
by
the
value
of
$length
.
|
fn:unordered
|
Returns
the
items
of
$sourceSeq
in
|
As
in
the
previous
section,
for
the
illustrative
examples
below,
assume
an
XQuery
or
transformation
operating
on
a
non-empty
Purchase
Order
document
containing
a
number
of
line-item
elements.
The
variable
$seq
is
bound
to
the
sequence
of
line-item
nodes
in
document
order.
The
variables
$item1
,
$item2
,
etc.
are
bound
to
separate,
individual
line-item
nodes
in
the
sequence.
If
$arg
is
Returns
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
concatenation
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
.
two
sequences.
If
$arg
is
a
singleton
value
of
any
numeric
type
or
a
type
derived
from
a
numeric
type,
fn:boolean
returns
false
if
Defines
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
.
Note:
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
returns
false
.
15.1.1.1
Examples
let
$x
:=
("a",
"b",
"c")
fn:boolean($x)
raises
a
type
error
[
err:FORG0006
].
fn:boolean($x[1])
returns
true
.
fn:boolean($x[0])
returns
false
.
infix
operator
",".
op:concatenate
(
$seq1
as
item()*
,
$seq2
as
item()*
)
as
item()*
Summary:
Returns
The
function
returns
a
sequence
consisting
of
all
the
items
in
$seq1
followed
by
all
the
items
in
$seq2
.
This
function
backs
up
the
infix
operator
",".
If
either
sequence
is
the
empty
sequence,
the
other
operand
is
returned.
For detailed type semantics, see Section 4.3.1 Constructing Sequences FS
If either sequence is the empty sequence, the other operand is returned.
The
expression
op:concatenate((1,
2,
3),
(4,
5))
returns
(1,
2,
3,
4,
5)
.
The
expression
op:concatenate((1,
2,
3),
())
returns
(1,
2,
3)
.
The
expression
op:concatenate((),
())
returns
()
.
Returns the values that appear in a sequence, with duplicates eliminated.
fn:index-of
fn:distinct-values
(
$arg
as
xs:anyAtomicType*
,
$srchParam
as
xs:anyAtomicType
)
as
xs:integer*
xs:anyAtomicType*
(
|
|
as
xs:anyAtomicType*
,
|
|
as
xs:string
)
as
|
Summary:
Returns
a
sequence
of
positive
integers
giving
the
positions
within
The
function
returns
the
sequence
that
results
from
removing
from
all
but
one
of
$seqParam
$arg
items
a
set
of
values
that
are
equal
to
$srchParam
.
The
collation
used
by
the
invocation
of
this
function
is
determined
according
to
the
rules
in
7.3.1
Collations
.
The
collation
is
used
when
string
comparison
is
required.
The
items
in
the
sequence
$seqParam
one
another.
Values
are
compared
with
$srchParam
under
the
rules
for
using
the
eq
operator.
operator,
subject
to
the
caveats
defined
below.
Values
of
type
xs:untypedAtomic
are
compared
as
if
they
were
of
type
xs:string
.
Values
that
cannot
be
compared,
i.e.
because
the
eq
operator
is
not
defined
for
their
types,
are
considered
to
be
distinct.
If
an
item
compares
equal,
then
The
collation
used
by
this
function
is
determined
according
to
the
position
of
that
item
rules
in
the
sequence
5.3.3
Choosing
a
Collation
.
This
collation
is
used
when
string
comparison
is
required.
For
and
$seqParam
xs:float
xs:double
values,
positive
zero
is
included
in
the
result.
equal
to
negative
zero
and,
although
NaN
does
not
equal
itself,
if
$arg
contains
multiple
NaN
values
a
single
NaN
is
returned.
If
the
value
of
,$seqParam
xs:dateTime
xs:date
is
the
empty
sequence,
or
if
no
item
in
$seqParam
xs:time
matches
values
do
not
have
a
timezone,
they
are
considered
to
have
the
implicit
timezone
provided
by
the
dynamic
context
for
the
purpose
of
comparison.
Note
that
,
$srchParam
xs:dateTime
then
xs:date
or
xs:time
values
can
compare
equal
even
if
their
timezones
are
different.
The
order
in
which
the
empty
sequence
of
values
is
returned.
returned
is
·
implementation
dependent
·
.
The
first
item
in
Which
value
of
a
sequence
set
of
values
that
compare
equal
is
at
position
1,
not
position
0.
returned
is
·
implementation
dependent
·
.
The
static
type
of
the
result
sequence
is
a
sequence
of
prime
types
as
defined
in
ascending
numeric
order.
Section
7.2.7
The
fn:distinct-values
function
15.1.3.1
Examples
fn:index-of
((10,
20,
30,
40),
35)
returns
().
FS
.
If
the
input
sequence
contains
values
of
different
numeric
types
that
differ
from
each
other
by
small
amounts,
then
the
eq
operator
is
not
transitive,
because
of
rounding
effects
occurring
during
type
promotion.
In
the
situation
where
the
input
contains
three
values
,
fn:index-of
((10,
20,
30,
30,
20,
10),
20)
returns
A
,
and
(2,
5).
B
C
such
that
A
eq
B
,
B
eq
C
,
but
A
ne
C
,
then
the
number
of
items
in
the
result
of
the
function
(as
well
as
the
choice
of
which
items
are
returned)
is
implementation-dependent,
subject
only
to
the
constraints
that
(a)
no
two
items
in
the
result
sequence
compare
equal
to
each
other,
and
(b)
every
input
item
that
does
not
appear
in
the
result
sequence
compares
equal
to
some
item
that
does
appear
in
the
result
sequence.
For example, this arises when computing:
distinct-values( (xs:float('1.0'), xs:decimal('1.0000000000100000000001', xs:double( '1.00000000001'))
because
the
values
of
type
fn:index-of
(("a",
"sport",
"and",
"a",
"pastime"),
"a")
xs:float
returns
and
(1,
4).
xs:double
If
@a
is
an
attribute
both
compare
equal
to
the
value
of
type
xs:NMTOKENS
xs:decimal
whose
typed
value
is
"
but
not
equal
to
each
other.
If
red
green
blue
$arg
",
then:
is
the
empty
sequence,
the
function
returns
the
empty
sequence.
The
expression
returns
some
permutation
of
fn:index-of
(@a,
"blue")
fn:distinct-values((1,
2.0,
3,
2))
.
3
(1,
3,
2.0)
This
is
because
the
function
calling
mechanism
atomizes
the
attribute
node
to
produce
a
sequence
of
three
The
expression
xs:NMTOKEN
fn:distinct-values((xs:untypedAtomic("cherry"),
xs:untypedAtomic("plum"),
xs:untypedAtomic("plum")))
s.
returns
some
permutation
of
(xs:untypedAtomic("cherry"),
xs:untypedAtomic("plum"))
.
Returns true if the argument is the empty sequence.
fn:empty
(
$arg
as
item()*
)
as
xs:boolean
Summary:
If
the
value
of
$arg
is
the
empty
sequence,
the
function
returns
true
;
otherwise,
the
function
returns
false
.
The
expression
fn:empty((1,2,3)[10])
returns
true()
.
The
expression
fn:empty(fn:remove(("hello",
"world"),
1))
returns
.
false
false()
Returns true if the argument is a non-empty sequence.
fn:exists
(
$arg
as
item()*
)
as
xs:boolean
Summary:
If
the
value
of
$arg
is
not
the
empty
a
non-empty
sequence,
the
function
returns
true
;
otherwise,
the
function
returns
false
.
The
expression
fn:exists(fn:remove(("hello"),
1))
returns
.
false
false()
The
expression
fn:exists(fn:remove(("hello",
"world"),
1))
returns
true()
.
Returns
a
sequence
of
positive
integers
giving
the
positions
within
the
sequence
$seqArg
of
items
that
are
equal
to
$searchArg
.
(
|
$seqArg
|
as
xs:anyAtomicType*
,
|
$searchArg
|
as
xs:anyAtomicType
)
as
xs:integer*
|
(
|
|
as
xs:anyAtomicType*
,
|
$searchArg
|
as
xs:anyAtomicType
, | |
$collation
|
as
xs:string
)
as
xs:integer*
|
Summary:
Returns
The
function
returns
a
sequence
of
positive
integers
giving
the
positions
within
the
sequence
that
results
from
removing
from
$arg
$seqArg
all
but
one
of
a
set
of
values
items
that
are
equal
to
$searchArg
.
The collation used by this function is determined according to the rules in 5.3.3 Choosing a Collation . This collation is used when string comparison is required.
The
items
in
the
sequence
$seqArg
are
compared
with
$searchArg
under
the
rules
for
the
eq
to
one
other.
operator.
Values
of
type
xs:untypedAtomic
are
compared
as
if
they
were
of
type
xs:string
.
Values
that
cannot
be
compared,
i.e.
because
the
eq
operator
is
not
defined
for
their
types,
are
considered
to
be
distinct.
The
order
If
an
item
compares
equal,
then
the
position
of
that
item
in
which
the
sequence
of
values
is
returned
$seqArg
is
·
implementation
dependent
·
.
included
in
the
result.
The
static
type
of
the
result
is
first
item
in
a
sequence
of
prime
types
as
defined
in
Section
7.2.7
The
fn:distinct-values
function
FS
.
is
at
position
1,
not
position
0.
The
collation
used
by
the
invocation
of
this
function
result
sequence
is
determined
according
to
the
rules
in
7.3.1
Collations
.
The
collation
is
used
when
string
comparison
is
required.
ascending
numeric
order.
If
the
value
of
is
the
empty
sequence,
or
if
no
item
in
$arg
$seqArg
$seqArg
matches
$searchArg
,
then
the
function
returns
the
empty
sequence
is
returned.
sequence.
For
The
expression
xs:float
fn:index-of((10,
20,
30,
40),
35)
and
returns
.xs:double
values,
positive
zero
is
equal
to
negative
zero
and,
although
()
The
expression
NaN
fn:index-of((10,
20,
30,
30,
20,
10),
20)
does
not
equal
itself,
if
returns
.$arg
contains
multiple
(2,
5)
The
expression
NaN
fn:index-of(("a",
"sport",
"and",
"a",
"pastime"),
"a")
values
a
single
returns
.
NaN
is
returned.
(1,
4)
If
xs:dateTime
,
xs:date
or
xs:time
@a
values
do
not
have
a
timezone,
they
are
considered
to
have
the
implicit
timezone
provided
by
the
dynamic
context
for
the
purpose
is
an
attribute
of
comparison.
Note
that
xs:dateTime
,
xs:date
or
type
xs:time
xs:NMTOKENS
values
can
compare
equal
even
if
their
timezones
are
different.
Which
whose
string
value
of
a
set
of
values
that
compare
equal
is
returned
"red
green
blue"
,
and
whose
typed
value
is
·
implementation
dependent
·
.
15.1.6.1
Examples
therefore
fn:distinct-values((1,
2.0,
3,
2))
("red",
"green",
"blue")
might
return
then
returns
(1,
3,
2.0)
.
The
following
query:
let $x as xs:untypedAtomic*
:= (xs:untypedAtomic("cherry"),
xs:untypedAtomic("bar"),
xs:untypedAtomic("bar"))
return fn:distinct-values ($x)
fn:index-of(@a,
"blue")
3
.
This
is
because
the
function
calling
mechanism
atomizes
the
attribute
node
to
produce
a
sequence
containing
two
items
of
type
three
values.
xs:untypedAtomic
.
xs:NMTOKEN
Returns a sequence constructed by inserting an item or a sequence of items at a given position within an existing sequence.
fn:insert-before
(
|
$target
|
as
item()*
,
|
$position
|
as
xs:integer
,
|
|
$inserts
|
as
item()*
)
as
item()*
|
The
value
returned
by
the
function
consists
of
all
items
of
$target
whose
index
is
less
than
$position
,
followed
by
all
items
of
$inserts
,
followed
by
the
remaining
elements
of
$target
,
in
that
sequence.
order.
For detailed type semantics see Section 7.2.15 The fn:insert-before function FS .
If
$target
is
the
empty
sequence,
$inserts
is
returned.
If
$inserts
is
the
empty
sequence,
$target
is
returned.
If
$position
is
less
than
one
(1),
the
first
position,
the
effective
value
of
$position
is
one
(1).
If
$position
is
greater
than
the
number
of
items
in
$target
,
then
the
effective
value
of
$position
is
equal
to
the
number
of
items
in
$target
plus
1.
For
detailed
semantics
see,
Section
7.2.15
The
fn:insert-before
function
FS
.
value
of
$target
is
not
affected
by
the
sequence
construction.
let
:=
$x
$abc
("a",
"b",
"c")
The
expression
returns
fn:insert-before($x,
fn:insert-before($abc,
0,
"z")
("z",
"a",
"b",
"c")
.
The
expression
returns
fn:insert-before($x,
fn:insert-before($abc,
1,
"z")
("z",
"a",
"b",
"c")
.
The
expression
returns
fn:insert-before($x,
fn:insert-before($abc,
2,
"z")
("a",
"z",
"b",
"c")
.
The
expression
returns
fn:insert-before($x,
fn:insert-before($abc,
3,
"z")
("a",
"b",
"z",
"c")
.
The
expression
returns
fn:insert-before($x,
fn:insert-before($abc,
4,
"z")
("a",
"b",
"c",
"z")
.
Returns
a
new
sequence
containing
all
the
items
of
$target
except
the
item
at
position
$position
.
fn:remove
(
$target
as
item()*
,
$position
as
xs:integer
)
as
item()*
Summary:
Returns
The
function
returns
a
new
sequence
constructed
from
the
value
of
$target
with
the
item
at
the
position
specified
by
the
value
of
$position
removed.
If
$position
is
less
than
1
or
greater
than
the
number
of
items
in
$target
,
$target
is
returned.
Otherwise,
the
value
returned
by
the
function
consists
consisting
of
all
items
of
$target
whose
index
is
less
than
$position
,
followed
by
all
items
of
$target
whose
index
is
greater
than
$position
.
If
$target
is
the
empty
sequence,
the
empty
sequence
is
returned.
For detailed type semantics, see Section 7.2.11 The fn:remove function FS .
If
$position
is
less
than
1
or
greater
than
the
number
of
items
in
$target
,
$target
is
returned.
If
$target
is
the
empty
sequence,
the
empty
sequence
is
returned.
let
:=
$x
$abc
("a",
"b",
"c")
The
expression
returns
fn:remove($x,
fn:remove($abc,
0)
("a",
"b",
"c")
.
The
expression
returns
fn:remove($x,
fn:remove($abc,
1)
("b",
"c")
.
The
expression
returns
fn:remove($x,
fn:remove($abc,
6)
("a",
"b",
"c")
.
The
expression
fn:remove((),
3)
returns
()
.
Reverses the order of items in a sequence.
fn:reverse
(
$arg
as
item()*
)
as
item()*
Summary:
Reverses
The
function
returns
a
sequence
containing
the
order
of
items
in
a
sequence.
If
$arg
is
the
empty
sequence,
the
empty
sequence
is
returned.
in
reverse
order.
For detailed type semantics, see Section 7.2.12 The fn:reverse function FS
If
$arg
is
the
empty
sequence,
the
empty
sequence
is
returned.
let
:=
$x
$abc
("a",
"b",
"c")
The
expression
returns
fn:reverse($x)
fn:reverse($abc)
("c",
"b",
"a")
.
The
expression
fn:reverse(("hello"))
returns
("hello")
.
The
expression
fn:reverse(())
returns
()
.
Returns
the
contiguous
sequence
of
items
in
the
value
of
$sourceSeq
beginning
at
the
position
indicated
by
the
value
of
$startingLoc
and
continuing
for
the
number
of
items
indicated
by
the
value
of
$length
.
fn:subsequence
(
$sourceSeq
as
item()*
,
$startingLoc
as
xs:double
)
as
item()*
fn:subsequence
(
|
$sourceSeq
|
as
item()*
,
|
$startingLoc
|
as
xs:double
,
|
|
$length
|
as
xs:double
)
as
item()*
|
In the two-argument case, returns:
$sourceSeq[fn:round($startingLoc) le $p]$sourceSeq[fn:round($startingLoc) le position()]
In the three-argument case, returns:
$sourceSeq[fn:round($startingLoc) le $p and $p lt fn:round($startingLoc) + fn:round($length)]$sourceSeq[fn:round($startingLoc) le position() and position() lt fn:round($startingLoc) + fn:round($length)]
For
detailed
type
semantics,
see
Section
7.2.13
The
fn:subsequence
function
Notes:
FS
.
If
$sourceSeq
is
the
empty
sequence,
the
empty
sequence
is
returned.
If
$startingLoc
is
zero
or
negative,
the
subsequence
includes
items
from
the
beginning
of
the
$sourceSeq
.
If
$length
is
not
specified,
the
subsequence
includes
items
to
the
end
of
$sourceSeq
.
If
$length
is
greater
than
the
number
of
items
in
the
value
of
$sourceSeq
following
$startingLoc
,
the
subsequence
includes
items
to
the
end
of
$sourceSeq
.
The first item of a sequence is located at position 1, not position 0.
For
detailed
type
semantics,
see
Section
7.2.13
The
fn:subsequence
function
FS
.
The
reason
the
function
accepts
arguments
of
type
xs:double
is
that
many
computations
on
untyped
data
return
an
xs:double
result;
and
the
reason
for
the
rounding
rules
is
to
compensate
for
any
imprecision
in
these
floating-point
computations.
Assume
let
$seq
:=
=
($item1,
$item2,
$item3,
$item4,
...)
("item1",
"item2",
"item3",
"item4",
"item5")
The
expression
fn:subsequence($seq,
4)
returns
.
($item4,
...)
("item4",
"item5")
The
expression
fn:subsequence($seq,
3,
2)
returns
.
($item3,
$item4)
("item3",
"item4")
Returns
the
items
of
$sourceSeq
in
an
·
implementation
dependent
·
order.
fn:unordered
(
$sourceSeq
as
item()*
)
as
item()*
Summary:
Returns
The
function
returns
the
items
of
$sourceSeq
in
an
·
implementation
dependent
·
order.
Query optimizers may be able to do a better job if the order of the output sequence is not specified. For example, when retrieving prices from a purchase order, if an index exists on prices, it may be more efficient to return the prices in index order rather than in document order.
The
expression
fn:unordered((1,
2,
3,
4,
5))
returns
some
permutation
of
(1,
2,
3,
4,
5)
.
The following functions test the cardinality of their sequence arguments.
Function | Meaning |
---|---|
fn:zero-or-one
|
Returns
$arg
if
it
contains
zero
or
one
items.
|
fn:one-or-more
|
Returns
$arg
if
it
contains
one
or
more
items.
|
fn:exactly-one
|
Returns
$arg
if
it
contains
exactly
one
item.
|
The
functions
fn:zero-or-one
,
fn:one-or-more
,
and
fn:exactly-one
defined
in
this
section,
check
that
the
cardinality
of
a
sequence
is
in
the
expected
range.
They
are
particularly
useful
with
regard
to
static
typing.
For
example,
the
XML
Schema
[XML
Schema
Part
1:
Structures
Second
Edition]
function
call
fn:remove($seq,
index-of($seq2,
'abc'))
describing
requires
the
output
result
of
the
call
on
fn:index-of
to
be
a
query
may
require
a
sequence
of
length
one-or-more
in
some
position,
singleton
integer,
but
the
static
type
system
may
not
be
able
to
cannot
infer
this;
inserting
a
call
to
writing
the
expression
as
fn:one-or-more
fn:remove($seq,
fn:exactly-one(fn:index-of($seq2,
'abc')))
at
the
appropriate
place
will
provide
a
suitable
static
type
at
query
analysis
time,
and
confirm
ensures
that
the
length
of
the
sequence
is
correct
with
a
dynamic
check
at
query
execution
time.
The
type
signatures
for
these
functions
deliberately
declare
the
argument
type
as
item()*
,
permitting
a
sequence
of
any
length.
A
more
restrictive
signature
would
defeat
the
purpose
of
the
function,
which
is
to
defer
cardinality
checking
until
query
execution
time.
Returns
$arg
if
it
contains
zero
or
one
items.
Otherwise,
raises
an
error.
fn:zero-or-one
(
$arg
as
item()*
)
as
item()?
Summary:
Returns
Except
in
error
cases,
the
function
returns
$arg
if
it
contains
zero
or
one
items.
Otherwise,
raises
an
error
[
err:FORG0003
].
unchanged.
For detailed type semantics, see Section 7.2.16 The fn:zero-or-one, fn:one-or-more, and fn:exactly-one functions FS
An
error
is
raised
[
err:FORG0003
]
if
$arg
contains
more
than
one
item.
Returns
$arg
if
it
contains
one
or
more
items.
Otherwise,
raises
an
error.
fn:one-or-more
(
$arg
as
item()*
)
as
item()+
Summary:
Returns
Except
in
error
cases,
the
function
returns
$arg
if
it
contains
one
or
more
items.
Otherwise,
raises
an
error
[
err:FORG0004
].
unchanged.
For detailed type semantics, see Section 7.2.16 The fn:zero-or-one, fn:one-or-more, and fn:exactly-one functions FS
An
error
is
raised
[
err:FORG0004
]
if
$arg
is
an
empty
sequence.
Returns
$arg
if
it
contains
exactly
one
item.
Otherwise,
raises
an
error.
fn:exactly-one
(
$arg
as
item()*
)
as
item()
Summary:
Returns
Except
in
error
cases,
the
function
returns
$arg
if
it
contains
exactly
one
item.
Otherwise,
raises
an
error
[
err:FORG0005
].
unchanged.
For detailed type semantics, see Section 7.2.16 The fn:zero-or-one, fn:one-or-more, and fn:exactly-one functions FS
An
error
is
raised
[
err:FORG0005
]
if
$arg
is
an
empty
sequence
or
a
sequence
containing
more
than
one
item.
Function | Meaning |
---|---|
fn:deep-equal
|
|
op:union
|
$arg1
or
$arg2
,
eliminating
|
op:intersect
|
$arg1
and
$arg2
,
eliminating
|
op:except
|
$arg1
but
not
in
the
$arg2
,
eliminating
|
As
in
the
previous
sections,
for
the
illustrative
examples
below,
assume
an
XQuery
or
transformation
operating
on
a
Purchase
Order
document
containing
a
number
of
line-item
elements.
The
variables
$item1
,
$item2
,
etc.
are
bound
to
individual
line-item
nodes
in
the
sequence.
We
use
sequences
of
these
nodes
in
some
of
the
examples
below.
This function assesses whether two sequences are deep-equal to each other. To be deep-equal, they must contain items that are pairwise deep-equal; and for two items to be deep-equal, they must either be atomic values that compare equal, or nodes of the same kind, with the same name, whose children are deep-equal.
fn:deep-equal
(
$parameter1
as
item()*
,
$parameter2
as
item()*
)
as
xs:boolean
fn:deep-equal
(
|
$parameter1
|
as
item()*
,
|
$parameter2
|
as
item()*
,
|
|
$collation
|
as
)
as
xs:boolean
|
Summary:
This
function
assesses
whether
two
sequences
are
deep-equal
to
each
other.
To
be
deep-equal,
they
must
contain
items
that
are
pairwise
deep-equal;
and
for
two
items
to
be
deep-equal,
they
must
either
be
atomic
values
that
compare
equal,
or
nodes
of
the
same
kind,
with
the
same
name,
whose
children
are
deep-equal.
This
is
defined
in
more
detail
below.
The
$collation
argument
identifies
a
collation
which
is
used
at
all
levels
of
recursion
when
strings
are
compared
(but
not
when
names
are
compared),
according
to
the
rules
in
7.3.1
Collations
5.3.3
Choosing
a
Collation
.
If
the
two
sequences
are
both
empty,
the
function
returns
true
.
If
the
two
sequences
are
of
different
lengths,
the
function
returns
false
.
If
the
two
sequences
are
of
the
same
length,
the
function
returns
true
if
and
only
if
every
item
in
the
sequence
$parameter1
is
deep-equal
to
the
item
at
the
same
position
in
the
sequence
$parameter2
.
The
rules
for
deciding
whether
two
items
are
deep-equal
follow.
Call
the
two
items
$i1
and
$i2
respectively.
If
$i1
and
$i2
are
both
atomic
values,
they
are
deep-equal
if
and
only
if
($i1
eq
$i2)
is
true
,
or
if
both
values
are
NaN
.
If
the
eq
operator
is
not
defined
for
$i1
and
$i2
,
the
function
returns
false
.
If
one
of
the
pair
$i1
or
$i2
is
an
atomic
value
and
the
other
is
a
node,
the
function
returns
false
.
If
$i1
and
$i2
are
both
nodes,
they
are
compared
as
described
below:
If
the
two
nodes
are
of
different
kinds,
the
result
is
false
.
If
the
two
nodes
are
both
document
nodes
then
they
are
deep-equal
if
and
only
if
the
sequence
$i1/(*|text())
is
deep-equal
to
the
sequence
$i2/(*|text())
.
If the two nodes are both element nodes then they are deep-equal if and only if all of the following conditions are satisfied:
the
The
two
nodes
have
the
same
name,
that
is
(node-name($i1)
eq
node-name($i2))
.
the
The
two
nodes
are
both
annotated
as
having
simple
content
or
both
nodes
are
annotated
as
having
complex
content.
the
The
two
nodes
have
the
same
number
of
attributes,
and
for
every
attribute
$a1
in
$i1/@*
there
exists
an
attribute
$a2
in
$i2/@*
such
that
$a1
and
$a2
are
deep-equal.
One of the following conditions holds:
Both
element
nodes
have
a
type
annotation
that
is
simple
content,
and
the
typed
value
of
$i1
is
deep-equal
to
the
typed
value
of
$i2
.
Both
element
nodes
have
a
type
annotation
that
is
complex
content
with
elementOnly
content,
and
each
child
element
of
$i1
is
deep-equal
to
the
corresponding
child
element
of
$i2
.
Both
element
nodes
have
a
type
annotation
that
is
complex
content
with
mixed
content,
and
the
sequence
$i1/(*|text())
is
deep-equal
to
the
sequence
$i2/(*|text())
.
Both element nodes have a type annotation that is complex content with empty content.
If the two nodes are both attribute nodes then they are deep-equal if and only if both the following conditions are satisfied:
the
The
two
nodes
have
the
same
name,
that
is
(node-name($i1)
eq
node-name($i2))
.
the
The
typed
value
of
$i1
is
deep-equal
to
the
typed
value
of
$i2
.
If
the
two
nodes
are
both
processing
instruction
nodes
or
namespace
bindings,
,
then
they
are
deep-equal
if
and
only
if
both
the
following
conditions
are
satisfied:
the
The
two
nodes
have
the
same
name,
that
is
(node-name($i1)
eq
node-name($i2))
.
the
The
string
value
of
$i1
is
equal
to
the
string
value
of
$i2
.
If the two nodes are both namespace nodes, then they are deep-equal if and only if both the following conditions are satisfied:
The
two
nodes
either
have
the
same
name
or
are
both
nameless,
that
is
fn:deep-equal(node-name($i1),
node-name($i2))
.
The
string
value
of
$i1
is
equal
to
the
string
value
of
$i2
when
compared
using
the
Unicode
codepoint
collation.
If the two nodes are both text nodes or comment nodes, then they are deep-equal if and only if their string-values are equal.
If either input sequence contains a function item, the function raises an error [ err:FOTY0015 ]
The
two
nodes
are
not
required
to
have
the
same
type
annotation,
and
they
are
not
required
to
have
the
same
in-scope
namespaces.
They
may
also
differ
in
their
parent,
their
base
URI,
and
the
values
returned
by
the
is-id
and
is-idrefs
accessors
(see
Section
5.5
is-id
Accessor
DM
and
Section
5.6
is-idrefs
Accessor
DM
).
The
order
of
children
is
significant,
but
the
order
of
attributes
is
insignificant.
The contents of comments and processing instructions are significant only if these nodes appear directly as items in the two sequences being compared. The content of a comment or processing instruction that appears as a descendant of an item in one of the sequences being compared does not affect the result. However, the presence of a comment or processing instruction, if it causes a text node to be split into two text nodes, may affect the result.
The
result
of
fn:deep-equal(1,
current-dateTime())
is
false
;
it
does
not
raise
an
error.
let
$at
:=
let $at := <attendees> <name last='Parker' first='Peter'/> <name last='Barker' first='Bob'/> <name last='Parker' first='Peter'/> </attendees><attendees> <name last='Parker' first='Peter'/> <name last='Barker' first='Bob'/> <name last='Parker' first='Peter'/> </attendees>
The
expression
fn:deep-equal($at,
$at/*)
returns
.
false
false()
The
expression
fn:deep-equal($at/name[1],
$at/name[2])
returns
.
false
false()
The
expression
fn:deep-equal($at/name[1],
$at/name[3])
returns
.
true
true()
The
expression
fn:deep-equal($at/name[1],
'Peter
Parker')
returns
.
false
false()
Constructs
a
sequence
containing
every
node
that
occurs
in
the
values
of
either
$arg1
or
$arg2
,
eliminating
duplicates
and
sorting
the
result
in
document
order.
Defines the semantics of the "union" or "|" operator.
op:union
(
$parameter1
$arg1
as
node()*
,
$parameter2
$arg2
as
node()*
)
as
node()*
Summary:
Constructs
The
function
returns
a
sequence
containing
every
node
that
occurs
in
the
values
of
either
or
$parameter1
$arg1
,
eliminating
duplicate
nodes.
Nodes
are
returned
in
document
order.
$parameter2
$arg2
Two
nodes
$n1
and
$n2
are
duplicates
if
they
are
satisfy
.
op:is-same-node()
op:is-same-node($n1,
$n2)
If
either
operand
is
the
empty
sequence,
a
sequence
is
returned
containing
the
nodes
in
the
other
operand
in
document
order
after
eliminating
duplicates.
For
detailed
type
semantics,
see
Section
7.2.14
The
op:union,
op:intersect,
and
op:except
operators
FS
This
function
backs
up
If
either
operand
is
the
"union"
or
"|"
operator.
empty
sequence,
the
result
is
a
sequence
containing
the
nodes
in
the
other
operand
in
document
order
after
eliminating
duplicates.
Assume
let
$seq1
:=
=
($item1,
$item2),
$seq2
=
($item1,
$item2)
and
let
$seq2
:=
($item2,
$item2,
$item1)
let
$seq3
:=
=
($item2,
$item3)
.
The
expression
op:union($seq1,
$seq1)
returns
the
sequence
($item1,
$item2)
.
The
expression
op:union($seq2,
$seq3)
returns
the
sequence
consisting
of
($item1,
$item2,
$item3)
.
The
expression
op:union($seq2,
())
returns
($item1,
$item2)
.
Constructs
a
sequence
containing
every
node
that
occurs
in
the
values
of
both
$arg1
and
$arg2
,
eliminating
duplicates
and
sorting
the
result
in
document
order.
Defines the semantics of the "intersect" operator.
op:intersect
(
$parameter1
$arg1
as
node()*
,
$parameter2
$arg2
as
node()*
)
as
node()*
Summary:
Constructs
The
function
returns
a
sequence
containing
every
node
that
occurs
in
the
values
of
both
and
$parameter1
$arg1
,
eliminating
duplicate
nodes.
Nodes
are
returned
in
document
order.
$parameter2
$arg2
If
either
operand
is
the
empty
sequence,
the
empty
sequence
is
returned.
Two
nodes
$n1
and
$n2
are
duplicates
if
they
are
satisfy
.
op:is-same-node()
op:is-same-node($n1,
$n2)
For detailed type semantics, see Section 7.2.14 The op:union, op:intersect, and op:except operators FS .
This
If
either
operand
is
the
empty
sequence,
the
function
backs
up
returns
the
"intersect"
operator.
empty
sequence.
Assume
let
$seq1
:=
=
($item1,
$item2),
$seq2
=
($item1,
$item2)
and
let
$seq2
:=
($item2,
$item2,
$item1)
let
$seq3
:=
=
($item2,
$item3)
.
The
expression
op:intersect($seq1,
$seq1)
returns
the
sequence
($item1,
$item2)
.
The
expression
op:intersect($seq2,
$seq3)
returns
the
sequence
($item2)
.
The
expression
op:intersect($seq2,
())
returns
()
.
The
expression
op:intersect($item1,
$item3)
returns
()
.
Constructs
a
sequence
containing
every
node
that
occurs
in
the
value
of
$arg1
but
not
in
the
value
of
$arg2
,
eliminating
duplicates
and
sorting
the
result
in
document
order.
Defines the semantics of the "except" operator.
op:except
(
$parameter1
$arg1
as
node()*
,
$parameter2
$arg2
as
node()*
)
as
node()*
Summary:
Constructs
The
function
returns
a
sequence
containing
every
node
that
occurs
in
the
value
of
provided
that
it
does
not
occur
in
the
value
of
$parameter1
,
but
$arg1
.
Duplicate
nodes
are
eliminated,
and
nodes
are
returned
in
document
order.
$parameter2
,
eliminating
duplicate
nodes.
Nodes
$arg2
If
$parameter1
is
the
empty
sequence,
the
empty
sequence
is
returned.
If
Two
nodes
$parameter2
$n1
is
the
empty
sequence,
a
sequence
is
returned
containing
the
nodes
in
and
$parameter1
$n2
in
document
order
after
eliminating
duplicates.
Two
nodes
are
duplicates
if
they
are
satisfy
.
op:is-same-node()
op:is-same-node($n1,
$n2)
For detailed type semantics, see Section 7.2.14 The op:union, op:intersect, and op:except operators FS .
This
function
backs
up
If
$arg1
is
the
"except"
operator.
empty
sequence,
the
empty
sequence
is
returned.
If
$arg2
is
the
empty
sequence,
a
sequence
is
returned
containing
the
nodes
in
$arg1
in
document
order
after
eliminating
duplicates.
Assume
let
$seq1
:=
=
($item1,
$item2),
$seq2
=
($item1,
$item2)
and
let
$seq2
:=
($item2,
$item2,
$item1)
let
$seq3
:=
=
($item2,
$item3)
.
The
expression
op:except($seq1,
returns
$seq2)
$seq1)
the
empty
sequence.
()
.
The
expression
op:except($seq2,
$seq1)
returns
()
.
The
expression
op:except($seq2,
$seq3)
returns
the
sequence
($item1)
.
The
expression
op:except($seq2,
())
returns
($item1,
$item2)
.
The
expression
op:except($seq3,
$seq2)
returns
($item3)
.
Aggregate
functions
take
a
sequence
as
argument
and
return
a
single
value
computed
from
values
in
the
sequence.
Except
for
fn:count
,
the
sequence
must
consist
of
values
of
a
single
type
or
one
if
its
subtypes,
or
they
must
be
numeric.
xs:untypedAtomic
values
are
permitted
in
the
input
sequence
and
handled
by
special
conversion
rules.
The
type
of
the
items
in
the
sequence
must
also
support
certain
operations.
Function | Meaning |
---|---|
fn:count
|
Returns the number of items in a sequence. |
fn:avg
|
Returns
the
average
of
$arg
,
that
is,
the
sum
of
the
values
divided
by
the
number
of
values.
|
fn:max
|
Returns
a
value
that
is
equal
to
the
|
fn:min
|
Returns
a
value
that
is
equal
to
the
|
fn:sum
|
Returns
$arg
.
|
Returns the number of items in a sequence.
fn:count
(
$arg
as
item()*
)
as
xs:integer
Summary:
Returns
The
function
returns
the
number
of
items
in
the
value
of
$arg
.
Returns
0
if
$arg
is
the
empty
sequence.
Assume
let
$seq1
:=
=
($item1,
$item2)
and
let
$seq2
:=
(98.5,
98.3,
98.9)
let
$seq3
:=
=
()
,
the
empty
sequence.
The
expression
fn:count($seq1)
returns
2
.
The
expression
fn:count($seq3)
returns
0
.
The
expression
fn:count($seq2)
returns
3
.
The
expression
fn:count($seq2[.
>
100])
returns
0
.
Summary:
Returns
the
average
of
the
values
in
the
input
sequence
$arg
,
that
is,
the
sum
of
the
values
divided
by
the
number
of
values.
fn:avg
(
$arg
as
xs:anyAtomicType*
)
as
xs:anyAtomicType?
If
$arg
is
the
empty
sequence,
the
empty
sequence
is
returned.
If
$arg
contains
values
of
type
xs:untypedAtomic
they
are
cast
to
xs:double
.
Duration
values
must
either
all
be
xs:yearMonthDuration
values
or
must
all
be
xs:dayTimeDuration
values.
For
numeric
values,
the
numeric
promotion
rules
defined
in
6.2
4.2
Arithmetic
Operators
on
Numeric
Values
are
used
to
promote
all
values
to
a
single
common
type.
After
these
operations,
$arg
must
contain
items
of
a
single
type,
which
must
be
one
of
the
four
numeric
types,
xs:yearMonthDuration
or
xs:dayTimeDuration
or
one
if
its
subtypes.
If
the
above
conditions
are
not
met,
then
a
type
error
is
raised
[
err:FORG0006
].
Otherwise,
The
function
returns
the
average
of
the
values
as
sum($arg)
div
count($arg)
;
but
the
implementation
may
use
an
otherwise
equivalent
algorithm
that
avoids
arithmetic
overflow.
For detailed type semantics, see Section 7.2.10 The fn:min, fn:max, fn:avg, and fn:sum functions FS .
If
the
input
sequence
contains
items
of
incompatible
types,
as
described
above,
then
a
type
error
is
raised
[
err:FORG0006
15.4.2.1
].
Assume
let
$d1
:=
=
xs:yearMonthDuration("P20Y")
and
let
$d2
:=
=
xs:yearMonthDuration("P10M")
and
let
$seq3
:=
=
(3,
4,
5)
.
The
expression
fn:avg($seq3)
returns
4.0
.
(The
result
is
of
type
xs:decimal
.).
The
expression
fn:avg(($d1,
$d2))
returns
a
yearMonthDuration
with
value
.
125
months.
xs:yearMonthDuration("P10Y5M")
fn:avg(($d1,
$seq3))
raises
a
type
error
[
err:FORG0006
].
The
expression
fn:avg(())
returns
()
.
The
expression
fn:avg((xs:float('INF'),
xs:float('-INF')))
returns
.
NaN
xs:float('NaN')
The
expression
fn:avg(($seq3,
xs:float('NaN')))
returns
.
NaN
xs:float('NaN')
Returns a value that is equal to the highest value appearing in the input sequence.
fn:max
(
$arg
as
xs:anyAtomicType*
)
as
xs:anyAtomicType?
fn:max
(
$arg
as
xs:anyAtomicType*
,
$collation
as
string
xs:string
)
as
xs:anyAtomicType?
The
following
rules
are
applied
to
the
input
sequence:
sequence
$arg
:
Values
of
type
xs:untypedAtomic
in
$arg
are
cast
to
xs:double
.
Numeric
and
xs:anyURI
values
are
converted
to
the
least
common
type
that
supports
the
ge
operator
reachable
by
a
combination
of
type
promotion
and
subtype
substitution.
See
Section
B.1
Type
Promotion
XP
and
Section
B.2
Operator
Mapping
XP
.
The
items
in
the
resulting
sequence
may
be
reordered
in
an
arbitrary
order.
The
resulting
sequence
is
referred
to
below
as
the
converted
sequence.
This
The
function
returns
an
item
from
the
converted
sequence
rather
than
the
input
sequence.
If
the
converted
sequence
is
empty,
the
function
returns
the
empty
sequence
is
returned.
sequence.
All
items
in
$arg
the
converted
sequence
must
be
numeric
or
derived
from
a
single
base
type
for
which
the
operator
is
defined.
In
addition,
the
values
in
the
sequence
must
have
a
total
order.
If
date/time
values
do
not
have
a
timezone,
they
are
considered
to
have
the
implicit
timezone
provided
by
the
dynamic
context
for
ge
le
purposes
the
purpose
of
comparison.
Duration
values
must
either
all
be
xs:yearMonthDuration
values
or
must
all
be
xs:dayTimeDuration
values.
If
any
of
these
conditions
is
not
met,
then
a
type
error
is
raised
[
err:FORG0006
].
If
the
converted
sequence
contains
the
value
NaN
,
the
value
NaN
is
returned.
If
the
items
in
the
value
of
$arg
converted
sequence
are
of
type
xs:string
or
types
derived
by
restriction
from
xs:string
,
then
the
determination
of
the
item
with
the
largest
smallest
value
is
made
according
to
the
collation
that
is
used.
If
the
type
of
the
items
in
$arg
the
converted
sequence
is
not
xs:string
and
$collation
is
specified,
the
collation
is
ignored.
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
.
Otherwise,
the
result
of
the
The
function
is
returns
the
result
of
the
expression:
if (every $v in $c satisfies $c[1] ge $v) then $c[1] else fn:max(fn:subsequence($c, 2))
evaluated
with
$collation
as
the
default
collation
if
specified,
and
with
$c
as
the
converted
sequence.
For detailed type semantics, see Section 7.2.10 The fn:min, fn:max, fn:avg, and fn:sum functions FS .
If the input sequence contains items of incompatible types, as described above, then a type error is raised [ err:FORG0006 ].
Because
the
rules
allow
the
sequence
to
be
reordered,
if
there
are
two
or
items
that
are
"equal
highest",
the
specific
item
whose
value
is
returned
is
Notes:
·
implementation
dependent
·
.
This
can
arise
for
example
if
two
different
strings
compare
equal
under
the
selected
collation,
or
if
two
different
xs:dateTime
values
compare
equal
despite
being
in
different
timezones.
If the converted sequence contains exactly one value then that value is returned.
The
default
type
when
the
fn:max
function
is
applied
to
xs:untypedAtomic
values
is
xs:double
.
This
differs
from
the
default
type
for
operators
such
as
gt
,
and
for
sorting
in
XQuery
and
XSLT,
which
is
xs:string
.
The
expression
fn:max((3,4,5))
returns
5
.
The
expression
returns
fn:max((5,
5.0e0))
fn:max((xs:integer(5),
xs:float(5.0),
xs:double(0)))
.
5.0e0
xs:double(5.0e0)
fn:max((3,4,"Zero"))
raises
a
type
error
[
err:FORG0006
].
The
expression
fn:max((fn:current-date(),
xs:date("2001-01-01")))
xs:date("2100-01-01")))
typically
returns
xs:date("2100-01-01")
.
(Assuming
that
the
current
date.
date
is
during
the
21st
century.).
The
expression
fn:max(("a",
"b",
"c"))
returns
"c"
.
(Assuming
a
typical
default
under
collation.
collation.).
Returns a value that is equal to the lowest value appearing in the input sequence.
fn:min
(
$arg
as
xs:anyAtomicType*
)
as
xs:anyAtomicType?
fn:min
(
$arg
as
xs:anyAtomicType*
,
$collation
as
string
xs:string
)
as
xs:anyAtomicType?
The following rules are applied to the input sequence:
Values
of
type
xs:untypedAtomic
in
$arg
are
cast
to
xs:double
.
Numeric
and
xs:anyURI
values
are
converted
to
the
least
common
type
that
supports
the
le
operator
reachable
by
a
combination
of
type
promotion
and
subtype
substitution.
See
Section
B.1
Type
Promotion
XP
and
Section
B.2
Operator
Mapping
XP
.
The
items
in
the
resulting
sequence
may
be
reordered
in
an
arbitrary
order.
The
resulting
sequence
is
referred
to
below
as
the
converted
sequence.
This
The
function
returns
an
item
from
the
converted
sequence
rather
than
the
input
sequence.
If the converted sequence is empty, the empty sequence is returned.
All
items
in
$arg
the
converted
sequence
must
be
numeric
or
derived
from
a
single
base
type
for
which
the
le
operator
is
defined.
In
addition,
the
values
in
the
sequence
must
have
a
total
order.
If
date/time
values
do
not
have
a
timezone,
they
are
considered
to
have
the
implicit
timezone
provided
by
the
dynamic
context
for
the
purpose
of
comparison.
Duration
values
must
either
all
be
xs:yearMonthDuration
values
or
must
all
be
xs:dayTimeDuration
values.
If
any
of
these
conditions
is
not
met,
a
type
error
is
raised
[
err:FORG0006
].
If
the
converted
sequence
contains
the
value
NaN
,
the
value
NaN
is
returned.
If
the
items
in
the
value
of
$arg
converted
sequence
are
of
type
xs:string
or
types
derived
by
restriction
from
xs:string
,
then
the
determination
of
the
item
with
the
smallest
value
is
made
according
to
the
collation
that
is
used.
If
the
type
of
the
items
in
$arg
the
converted
sequence
is
not
xs:string
and
$collation
is
specified,
the
collation
is
ignored.
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
.
Otherwise,
the
result
of
the
The
function
is
returns
the
result
of
the
expression:
if (every $v in $c satisfies $c[1] le $v) then $c[1] else fn:min(fn:subsequence($c, 2))
evaluated
with
$collation
as
the
default
collation
if
specified,
and
with
$c
as
the
converted
sequence.
For detailed type semantics, see Section 7.2.10 The fn:min, fn:max, fn:avg, and fn:sum functions FS .
If the input sequence contains items of incompatible types, as described above, then a type error is raised [ err:FORG0006 ].
Because
the
rules
allow
the
sequence
to
be
reordered,
if
there
are
two
or
items
that
are
"equal
lowest",
the
specific
item
whose
value
is
returned
is
Notes:
·
implementation
dependent
·
.
This
can
arise
for
example
if
two
different
strings
compare
equal
under
the
selected
collation,
or
if
two
different
xs:dateTime
values
compare
equal
despite
being
in
different
timezones.
If the converted sequence contains exactly one value then that value is returned.
The
default
type
when
the
fn:min
function
is
applied
to
xs:untypedAtomic
values
is
xs:double
.
This
differs
from
the
default
type
for
operators
such
as
lt
,
and
for
sorting
in
XQuery
and
XSLT,
which
is
xs:string
.
The
expression
fn:min((3,4,5))
returns
3
.
The
expression
returns
fn:min((5,
5.0e0))
fn:min((xs:integer(5),
xs:float(5),
xs:double(10)))
.
5.0e0
xs:double(5.0e0)
fn:min((3,4,"Zero"))
raises
a
type
error
[
err:FORG0006
].
fn:min((xs:float(0.0E0),
xs:float(-0.0E0)))
can
return
either
positive
or
negative
zero.
[XML
Schema
Part
2:
Datatypes
Second
Edition]
does
not
distinguish
between
the
values
positive
zero
and
negative
zero.
The
result
is
·
implementation
dependent
·
.
The
expression
fn:min((fn:current-date(),
xs:date("2001-01-01")))
xs:date("1900-01-01")))
typically
returns
.
(Assuming
that
the
current
date
is
set
to
a
reasonable
value.).
xs:date("2001-01-01")
xs:date("1900-01-01")
The
expression
fn:min(("a",
"b",
"c"))
returns
"a"
.
(Assuming
a
typical
default
under
collation.
collation.).
Returns
a
value
obtained
by
adding
together
the
values
in
$arg
.
fn:sum
(
$arg
as
xs:anyAtomicType*
)
as
xs:anyAtomicType
fn:sum
(
|
$arg
|
as
xs:anyAtomicType*
,
|
$zero
|
as
xs:anyAtomicType?
)
as
xs:anyAtomicType?
|
Any
values
of
type
xs:untypedAtomic
in
$arg
are
cast
to
xs:double
.
The
items
in
the
resulting
sequence
may
be
reordered
in
an
arbitrary
order.
The
resulting
sequence
is
referred
to
below
as
the
converted
sequence.
If
the
converted
sequence
is
empty,
then
the
single-argument
form
of
the
function
returns
the
xs:integer
value
0
;
the
two-argument
form
returns
the
value
of
the
argument
$zero
.
If
the
converted
sequence
contains
the
value
NaN
,
NaN
is
returned.
All
items
in
$arg
must
be
numeric
or
derived
from
a
single
base
type.
In
addition,
the
type
must
support
addition.
Duration
values
must
either
all
be
xs:yearMonthDuration
values
or
must
all
be
xs:dayTimeDuration
values.
For
numeric
values,
the
numeric
promotion
rules
defined
in
6.2
4.2
Arithmetic
Operators
on
Numeric
Values
are
used
to
promote
all
values
to
a
single
common
type.
The
sum
of
a
sequence
of
integers
will
therefore
be
an
integer,
while
the
sum
of
a
numeric
sequence
that
includes
at
least
one
xs:double
will
be
an
xs:double.
If
the
above
conditions
are
not
met,
a
type
error
is
raised
[
err:FORG0006
].
xs:double
.
Otherwise,
the
The
result
of
the
function,
using
the
second
signature,
is
the
result
of
the
expression:
if (fn:count($c) eq 0) then $zero else if (fn:count($c) eq 1) then $c[1] else $c[1] + fn:sum(subsequence($c, 2))
where
$c
is
the
converted
sequence.
The
result
of
the
function,
using
the
first
signature,
is
the
result
of
the
expression:
fn:sum($arg,
0)
.
For detailed type semantics, see Section 7.2.10 The fn:min, fn:max, fn:avg, and fn:sum functions FS .
If the input sequence contains items of incompatible types, as described above, then a type error is raised [ err:FORG0006 ].
The second argument allows an appropriate value to be defined to represent the sum of an empty sequence. For example, when summing a sequence of durations it would be appropriate to return a zero-length duration of the appropriate type. This argument is necessary because a system that does dynamic typing cannot distinguish "an empty sequence of integers", for example, from "an empty sequence of durations".
If the converted sequence contains exactly one value then that value is returned.
Assume:
let
$d1
:=
xs:yearMonthDuration("P20Y")
let
$d2
:=
xs:yearMonthDuration("P10M")
let
$seq1
:=
($d1,
$d2)
let
fn:sum(($d1,
$d2))
$seq3
returns
an
:=
xs:yearMonthDuration
(3,
4,
5)
with
a
value
of
The
expression
250
fn:sum(($d1,
$d2))
months.
returns
xs:yearMonthDuration("P20Y10M")
.
The
expression
fn:sum($seq1[.
returns
<
lt
xs:yearMonthDuration('P3M')],
xs:yearMonthDuration('P0M'))
an
xs:yearMonthDuration
with
a
value
of
.
0
months.
xs:yearMonthDuration("P0M")
The
expression
fn:sum($seq3)
returns
12
.
The
expression
fn:sum(())
returns
0
.
The
expression
fn:sum((),())
returns
()
.
The
expression
fn:sum((1
to
returns
100)[.<0],
100)[.
lt
0],
0)
0
.
fn:sum(($d1,
9E1))
raises
an
error
[
err:FORG0006
].
The
expression
fn:sum(($d1,
$d2),
"ein
Augenblick")
returns
xs:yearMonthDuration("P20Y10M")
.
(There
is
no
requirement
that
the
$zero
value
should
be
the
same
type
as
the
items
in
$arg
,
or
even
that
it
should
belong
to
a
type
that
supports
addition.).
Function | Meaning |
---|---|
op:to
|
Returns a sequence of consecutive integers in a given range. |
fn:id
|
Returns
the
sequence
IDREF
values
supplied
in
$arg
.
|
|
Returns
the
sequence
of
element
nodes
ID
value
matching
the
value
of
one
or
more
of
the
IDREF
values
supplied
in
$arg
.
|
fn:idref
|
Returns
the
sequence
of
element
or
attribute
nodes
with
an
IDREF
value
matching
the
value
of
one
or
more
of
the
ID
values
supplied
in
$arg
.
|
fn:doc
|
xs:string
,
and
returns
the
|
fn:doc-available
|
fn:doc($uri)
would
return
a
document
|
fn:collection
|
Returns
a
sequence
of
nodes
|
fn:uri-collection
|
Returns
a
sequence
of
xs:anyURI
values
representing
the
|
fn:generate-id
| This function returns a string that uniquely identifies a given node. |
fn:parse
| This function takes as input an XML document represented as a string, and returns the document node at the root of an XDM tree representing the parsed document. |
fn:serialize
|
This
function
serializes
the
supplied
node
$arg
as
described
in
[serialization]
,
returning
the
serialized
node
as
a
string.
|
Returns a sequence of consecutive integers in a given range.
Defines the semantics of the "to" operator.
op:to
(
$firstval
as
xs:integer
,
$lastval
as
xs:integer
)
as
xs:integer*
Summary:
Returns
The
function
returns
the
sequence
containing
every
xs:integer
whose
value
is
between
the
value
of
$firstval
(inclusive)
and
the
value
of
$lastval
(inclusive),
in
monotonic
increasing
order.
If
the
value
of
the
first
operand
is
greater
than
the
value
of
the
second,
the
function
returns
the
empty
sequence
is
returned.
sequence.
If
the
values
of
the
two
operands
are
equal,
the
function
returns
a
sequence
containing
a
single
xs:integer
equal
to
the
value
is
returned.
This
function
backs
up
the
"to"
operator.
that
value.
The
expression
1
to
3
returns
(1,
2,
3)
.
The
expression
3
to
1
returns
()
.
The
expression
5
to
5
returns
5
.
Returns
the
sequence
of
element
nodes
that
have
an
ID
value
matching
the
value
of
one
or
more
of
the
IDREF
values
supplied
in
$arg
.
fn:id
(
$arg
as
xs:string*
)
as
element()*
fn:id
(
$arg
as
xs:string*
,
$node
as
node()
)
as
element()*
The
function
returns
a
sequence,
in
document
order
with
duplicates
eliminated,
containing
every
element
node
E
that
satisfies
all
the
following
conditions:
E
is
in
the
target
document.
The
target
document
is
the
document
containing
$node
,
or
the
document
containing
the
context
item
(
.
)
if
the
second
argument
is
omitted.
The
behavior
of
the
function
if
$node
is
omitted
is
exactly
the
same
as
if
the
context
item
had
been
passed
as
$node
.
If
$node
,
or
the
context
item
if
the
second
argument
is
omitted,
is
a
node
in
a
tree
whose
root
is
not
a
document
node
[
err:FODC0001
]
is
raised.
If
the
second
argument
is
the
context
item,
or
is
omitted,
the
following
errors
may
be
raised:
if
there
is
no
context
item,
[
err:XPDY0002
]
XP
;
if
the
context
item
is
not
a
node
[
err:XPTY0004
]
XP
.
E
has
an
ID
value
equal
to
one
of
the
candidate
IDREF
values,
where:
An
element
has
an
ID
value
equal
to
V
if
either
or
both
of
the
following
conditions
are
true:
The
is-id
property
(See
Section
5.5
is-id
Accessor
DM
.)
of
the
element
node
is
true,
and
the
typed
value
of
the
element
node
is
equal
to
V
under
the
rules
of
the
eq
operator
using
the
Unicode
code
point
codepoint
collation
(
http://www.w3.org/2005/xpath-functions/collation/codepoint
).
The
element
has
an
attribute
node
whose
is-id
property
(See
Section
5.5
is-id
Accessor
DM
.)
is
true
and
whose
typed
value
is
equal
to
V
under
the
rules
of
the
eq
operator
using
the
Unicode
code
point
collation
(
http://www.w3.org/2005/xpath-functions/collation/codepoint
).
Each
xs:string
in
$arg
is
parsed
as
if
it
were
of
type
IDREFS
,
that
is,
each
xs:string
in
$arg
is
treated
as
a
whitespace-separated
sequence
of
tokens,
each
acting
as
an
IDREF
.
These
tokens
are
then
included
in
the
list
of
candidate
IDREF
s.
If
any
of
the
tokens
is
not
a
lexically
valid
IDREF
(that
is,
if
it
is
not
lexically
an
xs:NCName
),
it
is
ignored.
Formally,
the
candidate
IDREF
values
are
the
strings
in
the
sequence
given
by
the
expression:
for $s in $arg return fn:tokenize(fn:normalize-space($s), ' ') [. castable as xs:IDREF]for $s in $arg return fn:tokenize(fn:normalize-space($s), ' ')[. castable as xs:IDREF]
If
several
elements
have
the
same
ID
value,
then
E
is
the
one
that
is
first
in
document
order.
If
$node
,
or
the
context
item
if
the
second
argument
is
omitted,
is
a
node
in
a
tree
whose
root
is
not
a
document
node
[
err:FODC0001
]
is
raised.
If
the
second
argument
is
the
context
item,
or
is
omitted,
the
following
errors
may
be
raised:
if
there
is
no
context
item,
[
err:XPDY0002
]
Notes:
XP
;
if
the
context
item
is
not
a
node
[
err:XPTY0004
]
XP
.
The
effect
of
this
function
is
anomalous
in
respect
of
element
nodes
with
the
is-id
property.
For
legacy
reasons,
this
function
returns
the
element
that
has
the
is-id
property,
whereas
it
would
be
more
appropriate
to
return
its
parent,
that
being
the
element
that
is
uniquely
identified
by
the
ID.
A
new
function
element-with-id
is
being
introduced
with
the
desired
behavior.
If
the
data
model
is
constructed
from
an
Infoset,
an
attribute
will
have
the
is-id
property
if
the
corresponding
attribute
in
the
Infoset
had
an
attribute
type
of
ID
:
typically
this
means
the
attribute
was
declared
as
an
ID
in
a
DTD.
If
the
data
model
is
constructed
from
a
PSVI,
an
element
or
attribute
will
have
the
is-id
property
if
its
schema-defined
type
typed
value
is
a
single
atomic
value
of
type
xs:ID
or
a
type
derived
by
restriction
from
xs:ID
.
No
error
is
raised
in
respect
of
a
candidate
IDREF
value
that
does
not
match
the
ID
of
any
element
in
the
document.
If
no
candidate
IDREF
value
matches
the
ID
value
of
any
element,
the
function
returns
the
empty
sequence.
It
is
not
necessary
that
the
supplied
argument
should
have
type
xs:IDREF
or
xs:IDREFS
,
or
that
it
should
be
derived
from
a
node
with
the
is-idrefs
property.
An
element
may
have
more
than
one
ID
value.
This
can
occur
with
synthetic
data
models
or
with
data
models
constructed
from
a
PSVI
where
the
element
and
one
of
its
attributes
are
both
typed
as
xs:ID
.
If
the
source
document
is
well-formed
but
not
valid,
it
is
possible
for
two
or
more
elements
to
have
the
same
ID
value.
In
this
situation,
the
function
will
select
the
first
such
element.
It
is
also
possible
in
a
well-formed
but
invalid
document
to
have
an
element
or
attribute
that
has
the
is-id
property
but
whose
value
does
not
conform
to
the
lexical
rules
for
the
xs:ID
type.
Such
a
node
will
never
be
selected
by
this
function.
let
$emp
:=
<employee xml:id="ID21256"> <empnr>E21256</empnr> <first>John</first> <last>Brown</last> </employee>
The
expression
id('ID21256')/name()
returns
employee
.
(The
xml:id
attribute
has
the
is-id
property,
so
the
employee
element
is
selected.).
The
expression
id('E21256')/name()
returns
empnr
.
(Assuming
the
empnr
element
is
given
the
type
xs:ID
as
a
result
of
schema
validation,
the
element
will
have
the
is-id
property
and
is
therefore
selected.
Note
the
difference
from
the
behavior
of
fn:element-with-id
.).
Returns
the
sequence
of
element
nodes
that
have
an
ID
value
matching
the
value
of
one
or
more
of
the
IDREF
values
supplied
in
$arg
.
fn:idref
fn:element-with-id
(
$arg
as
xs:string*
)
as
node()*
element()*
fn:idref
fn:element-with-id
(
$arg
as
xs:string*
,
$node
as
node()
)
as
element()*
Editorial note | |
See bug 6028. Text here is proposed by the editor in response to decisions made at the joint telcon on 2008-11-11. Requires review of detailed text. Also needs issuing as a 1.0/2.0 erratum |
Note:
Summary:
Returns
The
effect
of
this
function
is
identical
to
fn:id
in
respect
of
elements
that
have
an
attribute
with
the
sequence
is-id
property.
However,
it
behaves
differently
in
respect
of
element
or
attribute
nodes
with
an
the
IDREF
is-id
value
matching
property.
Whereas
the
value
of
one
or
more
of
fn:id
,
for
legacy
reasons,
returns
the
element
that
has
the
ID
is-id
values
supplied
in
property,
this
parent
returns
the
element
identified
by
the
ID,
which
is
the
parent
of
the
element
having
the
property.
$arg
.
is-id
The
function
returns
a
sequence,
in
document
order
with
duplicates
eliminated,
containing
every
element
or
attribute
node
that
satisfies
all
the
following
conditions:
$N
E
is
in
the
target
document.
The
target
document
is
the
document
containing
$N
E
$node
,
or
the
document
containing
the
context
item
(
.
)
if
the
second
argument
is
omitted.
The
behavior
of
the
function
if
$node
is
omitted
is
exactly
the
same
as
if
the
context
item
had
been
passed
as
$node
.
E
has
an
ID
value
equal
to
one
of
the
candidate
IDREF
values,
where:
An
element
has
an
ID
value
equal
to
V
if
either
or
both
of
the
following
conditions
are
true:
The
element
has
an
child
element
node
whose
is-id
property
(See
Section
5.5
is-id
Accessor
DM
.)
is
true
and
whose
typed
value
is
equal
to
V
under
the
rules
of
the
eq
operator
using
the
Unicode
code
point
collation
(
http://www.w3.org/2005/xpath-functions/collation/codepoint
).
The
element
has
an
attribute
node
whose
is-id
property
(See
Section
5.5
is-id
Accessor
DM
.)
is
true
and
whose
typed
value
is
equal
to
V
under
the
rules
of
the
eq
operator
using
the
Unicode
code
point
collation
(
http://www.w3.org/2005/xpath-functions/collation/codepoint
).
Each
xs:string
in
$arg
is
parsed
as
if
it
were
of
type
IDREFS
,
that
is,
each
xs:string
in
$arg
is
treated
as
a
whitespace-separated
sequence
of
tokens,
each
acting
as
an
IDREF
.
These
tokens
are
then
included
in
the
list
of
candidate
IDREF
s.
If
any
of
the
tokens
is
not
a
lexically
valid
IDREF
(that
is,
if
it
is
not
lexically
an
xs:NCName
),
it
is
ignored.
Formally,
the
candidate
IDREF
values
are
the
strings
in
the
sequence
given
by
the
expression:
for $s in $arg return fn:tokenize(fn:normalize-space($s), ' ')[. castable as xs:IDREF]
If
several
elements
have
the
same
ID
value,
then
E
is
the
one
that
is
first
in
document
order.
If
$node
,
or
the
context
item
if
the
second
argument
is
omitted,
is
a
node
in
a
tree
whose
root
is
not
a
document
node
[
err:FODC0001
]
is
raised.
If
the
second
argument
is
the
context
item,
or
is
omitted,
the
following
errors
may
be
raised:
if
there
is
no
context
item
item,
[
err:XPDY0002
]
XP
;
if
the
context
item
is
not
a
node
[
err:XPTY0004
]
XP
.
This
function
is
equivalent
to
the
fn:id
function
except
when
dealing
with
ID-valued
element
nodes.
Whereas
the
fn:id
function
selects
the
element
containing
the
identifier,
this
function
selects
its
parent.
If
the
data
model
is
constructed
from
an
Infoset,
an
attribute
will
have
the
is-id
property
if
the
corresponding
attribute
in
the
Infoset
had
an
attribute
type
of
ID
:
typically
this
means
the
attribute
was
declared
as
an
ID
in
a
DTD.
If
the
data
model
is
constructed
from
a
PSVI,
an
element
or
attribute
will
have
the
is-id
property
if
its
typed
value
is
a
single
atomic
value
of
type
xs:ID
or
a
type
derived
by
restriction
from
xs:ID
.
No
error
is
raised
in
respect
of
a
candidate
IDREF
value
that
does
not
match
the
ID
of
any
element
in
the
document.
If
no
candidate
IDREF
value
matches
the
ID
value
of
any
element,
the
function
returns
the
empty
sequence.
It
is
not
necessary
that
the
supplied
argument
should
have
type
xs:IDREF
or
xs:IDREFS
,
or
that
it
should
be
derived
from
a
node
with
the
is-idrefs
property.
An
element
may
have
more
than
one
ID
value.
This
can
occur
with
synthetic
data
models
or
with
data
models
constructed
from
a
PSVI
where
the
element
and
one
of
its
attributes
are
both
typed
as
xs:ID
.
If
the
source
document
is
well-formed
but
not
valid,
it
is
possible
for
two
or
more
elements
to
have
the
same
ID
value.
In
this
situation,
the
function
will
select
the
first
such
element.
It
is
also
possible
in
a
well-formed
but
invalid
document
to
have
an
element
or
attribute
that
has
the
is-id
property
but
whose
value
does
not
conform
to
the
lexical
rules
for
the
xs:ID
type.
Such
a
node
will
never
be
selected
by
this
function.
let
$emp
:=
<employee xml:id="ID21256"> <empnr>E21256</empnr> <first>John</first> <last>Brown</last> </employee>
The
expression
id('ID21256')/name()
returns
"employee"
.
(The
xml:id
attribute
has
the
is-id
property,
so
the
employee
element
is
selected.).
The
expression
id('E21256')/name()
returns
"employee"
.
(Assuming
the
empnr
element
is
given
the
type
xs:ID
as
a
result
of
schema
validation,
the
element
will
have
the
is-id
property
and
is
therefore
its
parent
is
selected.
Note
the
difference
from
the
behavior
of
fn:id
.).
Returns
the
sequence
of
element
or
attribute
nodes
with
an
IDREF
value
matching
the
value
of
one
or
more
of
the
ID
values
supplied
in
$arg
.
fn:idref
(
$arg
as
xs:string*
)
as
node()*
fn:idref
(
$arg
as
xs:string*
,
$node
as
node()
)
as
node()*
The
function
returns
a
sequence,
in
document
order
with
duplicates
eliminated,
containing
every
element
or
attribute
node
$N
that
satisfies
all
the
following
conditions:
$N
is
in
the
target
document.
The
target
document
is
the
document
containing
$node
or
the
document
containing
the
context
item
(
.
)
if
the
second
argument
is
omitted.
The
behavior
of
the
function
if
$node
is
omitted
is
exactly
the
same
as
if
the
context
item
had
been
passed
as
$node
.
$N
has
an
IDREF
value
equal
to
one
of
the
candidate
ID
values,
where:
A
node
$N
has
an
IDREF
value
equal
to
V
if
both
of
the
following
conditions
are
true:
The
is-idrefs
property
(See
(see
Section
5.6
is-idrefs
Accessor
DM
.)of
)
of
$N
is
true
.
The sequence
fn:tokenize(fn:normalize-space($N), ' ')fn:tokenize(fn:normalize-space(fn:string($N)), ' ')
V
under
the
rules
of
the
eq
operator
using
the
Unicode
code
point
collation
(
http://www.w3.org/2005/xpath-functions/collation/codepoint
).
Each
xs:string
in
$arg
is
parsed
as
if
it
were
of
lexically
of
type
xs:ID
.
These
xs:string
s
are
then
included
in
the
list
of
candidate
xs:ID
s.
If
any
of
the
strings
in
$arg
is
not
a
lexically
valid
xs:ID
(that
is,
if
it
is
not
lexically
an
xs:NCName
),
it
is
ignored.
More
formally,
the
candidate
ID
values
are
the
strings
in
the
sequence
sequence:
$arg[. castable as xs:NCName]
If
$node
,
or
the
context
item
if
the
second
argument
is
omitted,
is
a
node
in
a
tree
whose
root
is
not
a
document
node
[
err:FODC0001
]
is
raised.
If
the
second
argument
is
the
context
item,
or
is
omitted,
the
following
errors
may
be
raised:
if
there
is
no
context
item
[
err:XPDY0002
]
Notes:
XP
;
if
the
context
item
is
not
a
node
[
err:XPTY0004
]
XP
.
An
element
or
attribute
typically
acquires
the
is-idrefs
property
by
being
validated
against
the
schema
type
xs:IDREF
or
xs:IDREFS
,
or
(for
attributes
only)
by
being
described
as
of
type
IDREF
or
IDREFS
in
a
DTD.
No
error
is
raised
in
respect
of
a
candidate
ID
value
that
does
not
match
the
IDREF
value
of
any
element
or
attribute
in
the
document.
If
no
candidate
ID
value
matches
the
IDREF
value
of
any
element
or
attribute,
the
function
returns
the
empty
sequence.
It
is
possible
for
two
or
more
nodes
to
have
an
IDREF
value
that
matches
a
given
candidate
ID
value.
In
this
situation,
the
function
will
return
all
such
nodes.
However,
each
matching
node
will
be
returned
at
most
once,
regardless
how
many
candidate
ID
values
it
matches.
It
is
possible
in
a
well-formed
but
invalid
document
to
have
a
node
whose
is-idrefs
property
is
true
but
that
does
not
conform
to
the
lexical
rules
for
the
xs:IDREF
type.
The
effect
of
the
above
rules
is
that
ill-formed
candidate
ID
values
and
ill-formed
IDREF
values
are
ignored.
If
the
data
model
is
constructed
from
a
PSVI,
the
typed
value
of
a
node
that
has
the
is-idrefs
property
will
contain
at
least
one
atomic
value
of
type
xs:IDREF
(or
a
type
derived
by
restriction
from
xs:IDREF
).
It
may
also
contain
atomic
values
of
other
types.
These
atomic
values
are
treated
as
candidate
ID
values
if
their
lexical
form
is
valid
as
an
xs:NCName
,
and
they
are
ignored
otherwise.
Retrieves
a
document
using
a
URI
supplied
as
an
xs:string
,
and
returns
the
corresponding
document
node.
fn:doc
(
$uri
as
xs:string?
)
as
document-node()?
Summary:
Retrieves
a
document
using
an
xs:anyURI
,
which
may
include
a
fragment
identifier,
supplied
as
an
xs:string
.
If
$uri
is
not
a
valid
xs:anyURI
,
an
error
the
empty
sequence,
the
result
is
raised
[
err:FODC0005
].
an
empty
sequence.
If
it
$uri
is
a
relative
URI
Reference,
reference,
it
is
resolved
relative
to
the
value
of
the
base
URI
property
from
the
static
context.
The
resulting
absolute
URI
Reference
is
promoted
to
an
xs:string
.
If
the
Available
documents
discussed
described
in
Section
2.1.2
Dynamic
Context
XP
provides
a
mapping
from
this
string
to
a
document
node,
the
function
returns
that
document
node.
If
the
Available
documents
provides
no
mapping
for
the
string,
an
error
is
raised
[
err:FODC0005
].
If
$uri
is
the
empty
sequence,
the
result
is
an
empty
sequence.
The
URI
may
include
a
fragment
identifier.
By default, this function is · stable · . Two calls on this function return the same document node if the same URI Reference (after resolution to an absolute URI Reference) is supplied to both calls. Thus, the following expression (if it does not raise an error) will always be true:
doc("foo.xml") is doc("foo.xml")
However, for performance reasons, implementations may provide a user option to evaluate the function without a guarantee of stability. The manner in which any such option is provided is implementation-defined. If the user has not selected such an option, a call of the function must either return a stable result or must raise an error: [ err:FODC0003 ].
For detailed type semantics, see Section 7.2.5 The fn:collection and fn:doc functions FS .
Note:
If
$uri
is
read
from
a
source
document,
it
is
generally
appropriate
to
resolve
it
relative
to
the
base
URI
property
of
the
relevant
node
in
the
source
document.
This
can
be
achieved
by
calling
the
fn:resolve-uri
function,
and
passing
the
resulting
absolute
URI
as
an
argument
to
the
fn:doc
function.
If two calls to this function supply different absolute URI References as arguments, the same document node may be returned if the implementation can determine that the two arguments refer to the same resource.
By defining the semantics of this function in terms of a string-to-document-node mapping in the dynamic context, the specification is acknowledging that the results of this function are outside the purview of the language specification itself, and depend entirely on the run-time environment in which the expression is evaluated. This run-time environment includes not only an unpredictable collection of resources ("the web"), but configurable machinery for locating resources and turning their contents into document nodes within the XPath data model. Both the set of resources that are reachable, and the mechanisms by which those resources are parsed and validated, are · implementation dependent · .
One
possible
processing
model
for
this
function
is
as
follows.
The
resource
identified
by
the
URI
Reference
is
retrieved.
If
the
resource
cannot
be
retrieved,
an
error
is
raised
[
err:FODC0002
].
The
data
resulting
from
the
retrieval
action
is
then
parsed
as
an
XML
document
and
a
tree
is
constructed
in
accordance
with
the
[XQuery
1.0
and
XPath
2.0
Data
Model]
[xpath-datamodel]
.
If
the
top-level
media
type
is
known
and
is
"text",
the
content
is
parsed
in
the
same
way
as
if
the
media
type
were
text/xml;
otherwise,
it
is
parsed
in
the
same
way
as
if
the
media
type
were
application/xml.
If
the
contents
cannot
be
parsed
successfully,
an
error
is
raised
[
err:FODC0002
].
Otherwise,
the
result
of
the
function
is
the
document
node
at
the
root
of
the
resulting
tree.
This
tree
is
then
optionally
validated
against
a
schema.
Various aspects of this processing are · implementation-defined · . Implementations may provide external configuration options that allow any aspect of the processing to be controlled by the user. In particular:
The set of URI schemes that the implementation recognizes is implementation-defined. Implementations may allow the mapping of URIs to resources to be configured by the user, using mechanisms such as catalogs or user-written URI handlers.
The handling of non-XML media types is implementation-defined. Implementations may allow instances of the data model to be constructed from non-XML resources, under user control.
It is · implementation-defined · whether DTD validation and/or schema validation is applied to the source document.
Implementations may provide user-defined error handling options that allow processing to continue following an error in retrieving a resource, or in parsing and validating its content. When errors have been handled in this way, the function may return either an empty sequence, or a fallback document provided by the error handler.
Implementations may provide user options that relax the requirement for the function to return stable results.
If
$uri
is
not
a
valid
URI,
an
error
may
be
raised
[
err:FODC0005
].
If the Available documents provides no mapping for the absolutized URI, an error is raised [ err:FODC0005 ].
If the resource cannot be retrieved or cannot be parsed successfully as XML, an error is raised [ err:FODC0002 ]
If the implementation is not able to guarantee that the result of the function will be stable, and the user has not indicated that an unstable result is acceptable, an error is raised [ err:FODC0003 ].
The
function
returns
true
if
and
only
if
the
function
call
fn:doc($uri)
would
return
a
document
node.
fn:doc-available
(
$uri
as
xs:string?
)
as
xs:boolean
If
$uri
is
an
empty
sequence,
this
function
returns
false
.
Summary:
If
a
call
on
fn:doc($uri)
returns
would
return
a
document
node,
this
function
returns
true
.
If
$uri
is
not
a
valid
URI
according
to
the
rules
applied
by
the
implementation
of
,
an
error
is
raised
[
err:FODC0005
].
xs:anyURI
,
fn:doc
Otherwise,
this
function
returns
false
.
If
this
function
returns
true
,
then
calling
fn:doc($uri)
within
the
same
·
execution
scope
·
must
return
a
document
node.
However,
if
non-stable
processing
has
been
selected
for
the
fn:doc
function,
this
guarantee
is
lost.
Returns a sequence of nodes representing a collection of documents indentified by a collection URI; or a default collection if no URI is supplied.
fn:collection
()
as
node()*
fn:collection
(
$arg
as
xs:string?
)
as
node()*
Summary:
This
function
takes
an
xs:string
as
argument
and
returns
a
sequence
of
nodes
obtained
by
interpreting
$arg
as
an
xs:anyURI
and
resolving
it
according
to
the
mapping
specified
in
Available
collections
described
in
Section
C.2
Dynamic
Context
Components
XP
.
If
Available
collections
provides
a
mapping
from
this
string
to
a
sequence
of
nodes,
the
function
returns
that
sequence.
If
Available
collections
maps
the
string
to
an
empty
sequence,
then
the
function
returns
an
empty
sequence.
If
Available
collections
provides
no
mapping
for
the
string,
an
error
is
raised
[
err:FODC0004
].
If
$arg
is
not
specified,
the
function
returns
the
sequence
of
the
nodes
in
the
default
collection
in
the
dynamic
context.
See
Section
C.2
Dynamic
Context
Components
XP
.
If
the
value
of
the
default
collection
is
undefined
an
error
is
raised
[
err:FODC0002
].
If
the
value
of
$arg
is
a
relative
xs:anyURI
,
it
is
resolved
against
the
value
of
the
base-URI
property
from
the
static
context.
If
$arg
is
not
a
valid
xs:anyURI
,
an
error
is
raised
[
err:FODC0004
].
If
$arg
is
the
empty
sequence,
the
function
behaves
as
if
it
had
been
called
without
an
argument.
See
above.
By default, this function is · stable · . This means that repeated calls on the function with the same argument will return the same result. However, for performance reasons, implementations may provide a user option to evaluate the function without a guarantee of stability. The manner in which any such option is provided is · implementation-defined · . If the user has not selected such an option, a call to this function must either return a stable result or must raise an error: [ err:FODC0003 ].
For detailed type semantics, see Section 7.2.5 The fn:collection and fn:doc functions FS .
If no URI is supplied and the value of the default collection is undefined, an error is raised [ err:FODC0002 ].
If
Note:
Available
collections
provides
no
mapping
for
the
absolutized
URI,
an
error
is
raised
[
err:FODC0004
]
If
$arg
is
not
a
valid
xs:anyURI
,
an
error
is
raised
[
err:FODC0004
].
This
function
provides
a
facility
for
users
to
work
with
a
collection
of
documents
which
may
be
contained
in
a
directory
or
rows
of
a
Relational
table
or
other
implementation-specific
construct.
An
implementation
may
also
use
external
variables
to
identify
external
resources,
but
provides
functionality
not
provided
by
external
variables.
Specifying
resources
using
URIs
is
useful
because
URIs
are
dynamic,
can
be
parameterized,
and
do
not
rely
on
an
external
environment.
fn:collection()
fn:collection
Returns
a
sequence
of
xs:anyURI
values
representing
the
document
URIs
of
the
documents
in
a
collection.
fn:uri-collection
()
as
xs:anyURI*
fn:uri-collection
(
$arg
as
xs:string?
)
as
xs:anyURI*
A
collection,
as
returned
by
the
fn:collection
function,
is
in
general
a
sequence
of
nodes.
Some
of
these
nodes
may
be
document
nodes,
and
some
of
these
document
nodes
may
have
a
non-empty
document
URI,
accessible
using
the
fn:document-uri
function.
The
fn:uri-collection
function
returns
a
sequence
of
URIs,
being
the
document
URIs
of
those
nodes
in
the
collection
that
are
document
nodes
and
that
have
a
document
URI
(other
nodes
in
the
collection
are
ignored).
That
is,
in
the
absence
of
errors,
fn:uri-collection(X)
returns
the
same
set
of
URIs
as
fn:collection(X)/fn:document-uri(.)
,
though
possibly
in
a
different
order.
The
purpose
in
providing
the
function,
however,
is
to
allow
the
URIs
of
the
documents
in
a
collection
to
be
retrieved
without
incurring
the
cost
(which
might
be
significant
in
some
implementations)
of
dereferencing
the
URIs
to
obtain
the
actual
nodes.
Where
required,
the
returned
URIs
can
then
be
dereferenced
by
calling
the
fn:doc
function.
The zero-argument form of the function returns the document URIs of the document nodes in the default collection.
The single-argument form returns the document URIs of the document nodes in the collection with a given collection URI. If the value of the argument is an empty sequence, the action is as for the zero-argument form of the function. If the argument is a relative URI, it is resolved against the base URI property of the static context.
If no URI is supplied and the value of the default collection is undefined, an error is raised [ err:FODC0002 ].
If Available collections provides no mapping for the absolutized URI, an error is raised [ err:FODC0004 ]
If
$arg
is
not
a
valid
xs:anyURI
,
an
error
is
raised
[
err:FODC0004
].
There are several reasons it might be appriopriate to retrieve the URIs of the documents in a collection without retrieving the documents themselves. For example:
In
XSLT
it
allows
the
documents
to
be
processed
in
streaming
mode
using
the
xsl:stream
instruction.
It
allows
recovery
from
failures
to
read,
parse,
or
validate
individual
documents,
by
calling
the
fn:doc
function
within
the
scope
of
try/catch.
It
allows
selection
of
which
documents
to
read
based
on
their
URI,
for
example
they
can
be
filtered
to
select
those
whose
URIs
end
in
.xml
.
However, there may be collections that cannot be processed in this way: specifically, those that contain nodes other than document nodes, and those that contain document nodes having no document URI.
This function returns a string that uniquely identifies a given node.
fn:generate-id
()
as
xs:string
fn:generate-id
(
$arg
as
node()?
)
as
xs:string
If
the
argument
is
omitted,
it
defaults
to
the
context
item
(
.
).
The
behavior
of
the
function
if
the
argument
is
omitted
is
exactly
the
same
as
if
the
context
item
had
been
passed
as
the
argument.
If the argument is the empty sequence, the result is the zero-length string.
In other cases, the function returns a string that uniquely identifies a given node.
The returned identifier must consist of ASCII alphanumeric characters and must start with an alphabetic character. Thus, the string is syntactically an XML name.
An implementation is free to generate an identifier in any convenient way provided that it always generates the same identifier for the same node and that different identifiers are always generated from different nodes. An implementation is under no obligation to generate the same identifiers each time a document is transformed or queried.
The
following
errors
may
be
raised
when
$arg
is
omitted:
if
the
context
item
is
undefined
[
err:XPDY0002
]
XP
;
if
the
context
item
is
not
a
node
[
err:XPTY0004
]
XP
.
There is no guarantee that a generated unique identifier will be distinct from any unique IDs specified in the source document.
There
is
no
inverse
to
this
function;
it
is
not
directly
possible
to
find
the
node
with
a
given
generated
ID.
Of
course,
it
is
possible
to
search
a
given
sequence
of
nodes
using
an
expression
such
as
$nodes[generate-id()=$id]
.
It is advisable, but not required, for implementations to generate IDs that are distinct even when compared using a case-blind collation.
Editorial note | |
This function was moved from XSLT to F+O as a decision of the WG on 23 Feb 2009. |
The
primary
use
case
for
this
function
is
to
generate
hyperlinks.
For
example,
when
generating
HTML,
an
anchor
for
a
given
section
$sect
can
be
generated
by
writing
(in
either
XSLT
or
XQuery):
<a
name="{generate-id($sect)}"/>
and a link to that section can then be produced with code such as:
see
<a
href="#{generate-id($sect)}">here</a>
Note that anchors generated in this way will not necessarily be the same each time a document is republished.
This function takes as input an XML document represented as a string, and returns the document node at the root of an XDM tree representing the parsed document.
fn:parse
(
$arg
as
xs:string
)
as
document-node(element(*,
xs:untyped))
fn:parse
(
|
$arg
|
as
xs:string
, |
$baseURI
|
as
xs:string
)
as
document-node(element(*,
xs:untyped))
|
Schema validation is not invoked, which means that the nodes in the returned document will all be untyped.
The precise process used to construct the XDM instance is implementation-defined. In particular, it is implementation-defined whether DTD validation is invoked, and it is implementation-defined whether an XML 1.0 or XML 1.1 parser is used.
If
the
second
argument
is
present
then
it
provides
a
URI
which
will
be
used
as
the
base
URI
of
the
document.
This
serves
both
as
the
base
URI
used
by
the
XML
parser
to
resolve
relative
entity
references
within
the
document,
and
as
the
base
URI
of
the
document
node
that
is
returned.
If
the
second
argument
is
omitted,
then
the
static
base
URI
of
the
fn:parse
function
call
is
used.
The function is not · stable · : that is, if the function is called twice with the same arguments, it is · implementation-dependent · whether the same node is returned on both occasions.
A
dynamic
error
[
err:FODC0006
]
is
raised
if
the
content
of
$arg
is
not
a
well-formed
and
namespace-well-formed
XML
document.
A
dynamic
error
[
err:FODC0007
]
is
raised
if
the
content
of
$baseURI
is
not
a
valid
absolute
URI.
Since the XML document is presented to the parser as a string, rather than as a sequence of octets, the encoding specified within the XML declaration has no meaning. If the XML parser accepts input only in the form of a sequence of octets, then the processor must ensure that the string is encoded as octets in a way that is consistent with rules used by the XML parser to detect the encoding.
The
primary
use
case
for
this
function
is
to
handle
input
documents
that
contain
nested
XML
documents
embedded
within
CDATA
sections.
Since
the
content
of
the
CDATA
section
are
exposed
as
text,
the
receiving
query
or
stylesheet
may
pass
this
text
to
the
fn:parse
function
to
create
a
tree
representation
of
the
nested
document.
Similarly, nested XML within comments is sometimes encountered, and lexical XML is sometimes returned by extension functions, for example, functions that access web services or read from databases.
A
use
case
arises
in
XSLT
where
there
is
a
need
to
preprocess
an
input
document
before
parsing.
For
example,
an
application
might
wish
to
edit
the
document
to
remove
its
DOCTYPE
declaration.
This
can
be
done
by
reading
the
raw
text
using
the
fn:unparsed-text
function,
editing
the
resulting
string,
and
then
passing
it
to
the
fn:parse
function.
The
expression
fn:parse("<alpha>abcd</alpha>")
returns
a
newly
created
document
node,
having
an
alpha
element
as
its
only
child;
the
alpha
element
in
turn
is
the
parent
of
a
text
node
whose
string
value
is
"abcd"
.
This
function
serializes
the
supplied
node
$arg
as
described
in
[serialization]
,
returning
the
serialized
node
as
a
string.
fn:serialize
(
$arg
as
node()
)
as
xs:string
fn:serialize
(
$arg
as
node()
,
$params
as
node()*
)
as
xs:string
The
node
$arg
acts
as
the
(singleton)
input
sequence
to
the
serialization
process.
The
single-argument
version
of
this
function
has
the
same
effect
as
the
two-argument
version
called
with
$params
set
to
an
empty
sequence.
The
$params
argument
is
used
to
identify
a
set
of
serialization
parameters.
These
are
supplied
in
the
form
of
a
sequence
of
nodes,
typically
element
or
attribute
nodes.
Each
node
represents
one
serialization
parameter.
The
parameters
are
interpreted
as
follows:
The name of the node is used for the name of the serialization parameter.
The string value of the node is used for the value of the parameter.
If more than one node in the sequence has the same name, then the one that appears last in the sequence is used.
If any node in the sequence has a name that is not recognized as the name of a serialization parameter, then the node is ignored.
Where
a
serialization
parameter
is
a
list
of
values
(for
example,
cdata-section-elements
)
its
value
is
supplied
as
a
whitespace-separated
list.
Where
the
value
of
a
serialization
parameter
includes
an
expanded-QName
(for
example,
method
or
cdata-section-elements
),
the
value
is
supplied
as
a
lexical
QName,
which
is
resolved
with
respect
to
the
in-scope
namespaces
for
the
node
in
which
the
parameter
value
is
supplied,
excluding
any
default
namespace
(so
a
name
with
no
prefix
is
in
no
namespace).
The
use-character-maps
property
is
not
available,
and
any
attempt
to
specify
a
value
for
this
property
is
a
dynamic
error
[SEPM0016].
Any
serialization
parameter
for
which
no
value
is
supplied
takes
an
implementation-defined
default
value.
However,
the
default
for
the
method
parameter
is
always
xml
.
The final stage of serialization, that is, encoding, is skipped. If the serializer does not allow this phase to be skipped, then the sequence of octets returned by the serializer is decoded into a string by reversing the character encoding performed in the final stage.
The
serialization
process
will
raise
an
error
if
$arg
is
an
attribute
or
namespace
node.
If
any
serialization
error
occurs,
including
the
detection
of
an
invalid
value
for
a
serialization
parameter,
this
results
in
the
fn:serialize
call
failing
with
a
dynamic
error.
One
use
case
arises
when
there
is
a
need
to
construct
an
XML
document
containing
nested
XML
documents
within
a
CDATA
section
(or
on
occasions
within
a
comment).
See
fn:parse
for
further
details.
Another case arises when calling extension functions that expect a lexical XML document as input.
There are also use cases where the application wants to post-process the output of a query or transformation, for example by adding an internal DTD subset.
Editorial note | |
Add some examples! |
The following functions are defined to obtain information from the dynamic context.
Function | Meaning |
---|---|
fn:position
|
Returns
the
|
fn:last
|
Returns
the
|
fn:current-dateTime
|
Returns
the
current
|
fn:current-date
|
Returns
the
current
|
fn:current-time
|
Returns
the
current
|
fn:implicit-timezone
|
Returns the value of the implicit timezone property from the dynamic context. |
fn:default-collation
|
Returns the value of the default collation property from the static context. |
fn:static-base-uri
|
Returns the value of the Base URI property from the static context. |
Returns the context position from the dynamic context.
fn:position
()
as
xs:integer
Summary:
Returns
the
context
position
from
the
dynamic
context.
(See
Section
C.2
Dynamic
Context
Components
XP
.)
If the context item is undefined, an error is raised: [ err:XPDY0002 ] XP .
Returns the context size from the dynamic context.
fn:last
()
as
xs:integer
Summary:
Returns
the
context
size
from
the
dynamic
context.
(See
Section
C.2
Dynamic
Context
Components
XP
.)
If the context item is undefined, an error is raised: [ err:XPDY0002 ] XP .
The
expression
(1
to
20)[fn:last()
-
1]
returns
19
.
Returns the current date and time (with timezone).
fn:current-dateTime
()
as
xs:dateTime
xs:dateTimeStamp
Summary:
Returns
the
current
dateTime
(with
timezone)
from
the
dynamic
context.
(See
Section
C.2
Dynamic
Context
Components
XP
.)
This
is
an
xs:dateTime
that
is
current
at
some
time
during
the
evaluation
of
a
query
or
transformation
in
which
is
executed.
fn:current-dateTime()
fn:current-dateTime
This
function
is
·
stable
·
.
The
precise
instant
during
the
query
or
transformation
represented
by
the
value
of
fn:current-dateTime()
is
·
implementation
dependent
·
.
If
the
implementation
supports
data
types
from
XSD
1.1
then
the
returned
value
will
be
an
instance
of
xs:dateTimeStamp
.
Otherwise,
the
only
guarantees
are
that
it
will
be
an
instance
of
xs:dateTime
and
will
have
a
timezone
component.
The
returned
xs:dateTime
will
always
have
an
associated
timezone,
which
will
always
be
the
same
as
the
implicit
timezone
in
the
dynamic
context
fn:current-dateTime()
returns
an
corresponding
to
the
current
date
and
time.
For
example,
xs:dateTime
xs:dateTimeStamp
an
invocation
a
call
of
fn:current-dateTime()
might
return
2004-05-12T18:17:15.125Z
corresponding
to
the
current
time
on
May
12,
2004
in
timezone
Z
.
Returns the current date.
fn:current-date
()
as
xs:date
Summary:
Returns
xs:date(fn:current-dateTime())
.
This
is
an
xs:date
(with
timezone)
that
is
current
at
some
time
during
the
evaluation
of
a
query
or
transformation
in
which
is
executed.
fn:current-date()
fn:current-date
This
function
is
·
stable
·
.
The
precise
instant
during
the
query
or
transformation
represented
by
the
value
of
is
·
implementation
dependent
·
.
fn:current-date()
fn:current-date
The returned date will always have an associated timezone, which will always be the same as the implicit timezone in the dynamic context
fn:current-date()
returns
an
xs:date
corresponding
to
the
current
date
and
time.
date.
For
example,
an
invocation
a
call
of
fn:current-date()
might
return
2004-05-12+01:00
.
Returns the current time.
fn:current-time
()
as
xs:time
Summary:
Returns
xs:time(fn:current-dateTime())
.
This
is
an
xs:time
(with
timezone)
that
is
current
at
some
time
during
the
evaluation
of
a
query
or
transformation
in
which
is
executed.
fn:current-time()
fn:current-time
This
function
is
·
stable
·
.
The
precise
instant
during
the
query
or
transformation
represented
by
the
value
of
fn:current-time()
is
·
implementation
dependent
·
.
The returned time will always have an associated timezone, which will always be the same as the implicit timezone in the dynamic context
fn:current-time()
returns
an
xs:time
corresponding
to
the
current
date
and
time.
For
example,
an
invocation
a
call
of
fn:current-time()
might
return
23:17:00.000-05:00
.
Returns the value of the implicit timezone property from the dynamic context.
fn:implicit-timezone
()
as
xs:dayTimeDuration
Summary:
Returns
the
value
of
the
implicit
timezone
property
from
the
dynamic
context.
Components
of
the
dynamic
context
are
discussed
in
Section
C.2
Dynamic
Context
Components
XP
.
Returns the value of the default collation property from the static context.
fn:default-collation
()
as
xs:string
Summary:
Returns
the
value
of
the
default
collation
property
from
the
static
context.
Components
of
the
static
context
are
discussed
in
Section
C.1
Static
Context
Components
XP
.
The
default
collation
property
can
never
be
undefined.
If
it
is
not
explicitly
defined,
a
system
defined
default
can
be
invoked.
If
this
is
not
provided,
the
Unicode
code
point
codepoint
collation
(
http://www.w3.org/2005/xpath-functions/collation/codepoint
)
is
used.
Returns the value of the Base URI property from the static context.
fn:static-base-uri
()
as
xs:anyURI?
Summary:
Returns
The
function
returns
the
value
of
the
Base
URI
property
from
the
static
context.
If
the
Base
URI
property
is
undefined,
the
empty
sequence
is
returned.
Components of the static context are discussed in Section C.1 Static Context Components XP .
The following functions operate on function items, that is, values referring to a function.
Function | Meaning |
---|---|
fn:function-name
| Returns the name of the function identified by a function item. |
fn:function-arity
| Returns the arity of the function identified by a function item. |
fn:partial-apply
| Returns the new function item obtained by binding one of the arguments of a supplied function item to a value. That is, it curries the supplied function. |
Returns the name of the function identified by a function item.
fn:function-name
(
$func
as
function()
)
as
xs:QName?
If
$func
refers
to
a
named
function,
fn:function-name($func)
returns
the
name
of
that
function.
Otherwise
(
$func
refers
to
an
anonymous
function),
fn:function-name($func)
returns
an
empty
sequence.
The prefix part of the returned QName is · implementation dependent · .
The
expression
fn:function-name(fn:contains#2)
returns
fn:QName("http://www.w3.org/2005/xpath-functions",
"fn:contains")
.
The
expression
fn:function-name(function($node){count($node/*})
returns
()
.
Returns the arity of the function identified by a function item.
fn:function-arity
(
$func
as
function()
)
as
xs:integer
The
fn:function-arity
function
returns
the
arity
(number
of
arguments)
of
the
function
identified
by
$func
.
The
expression
fn:function-arity(fn:contains#2)
returns
2
.
The
expression
fn:function-arity(function($node){name($node})
returns
1
.
Returns the new function item obtained by binding one of the arguments of a supplied function item to a value. That is, it curries the supplied function.
fn:partial-apply
(
$func
as
function()
,
$arg
as
item()*
)
as
function()
fn:partial-apply
(
|
$func
|
as
function()
, |
$arg
|
as
item()*
, | |
$argNum
|
as
xs:integer
)
as
function()
|
The
effect
of
calling
the
2-argument
version
of
this
function
is
the
same
as
calling
the
3-argument
version
with
$argNum
set
to
1
(one).
The result of the function is a new function item with the following properties:
The
set
of
variable
values
is
the
same
as
the
variable
values
of
$func
.
The name is absent (the function item is anonymous)
The
arity
is
one
less
than
the
arity
of
$func
The
new
function
NF
has
a
signature
which
is
the
same
as
the
signature
of
$func
,
removing
the
parameter
specified
by
$argNum
,
and
a
body
whose
effect
is
the
same
as
the
effect
of
invoking
$func
with
the
arguments
from
the
invocation
of
NF
,
inserting
the
$arg
as
the
value
of
argument
$argNum.
Editorial note | |
An
alternative
to
this
function
has
been
proposed
in
bug
7350
:
instead
of
the
fn:partial-apply
function,
use
custom
syntax
such
as
max(?,
'http://my-collation/de')
to
create
a
function
equivalent
to
fn:partial-apply(max#2,
'http://my-collation/de',
2)
.
This
would
allow
more
than
one
argument
to
be
bound
in
a
single
call,
as
well
as
being
more
readable.
|
If
$argNum
is
less
than
1
(one)
or
greater
than
fn:function-arity($func)
,
then
a
dynamic
error
[
err:FOFU0001
]
is
raised.
If
$arg
cannot
be
converted
to
the
required
type
of
the
corresponding
argument
of
$func
by
applying
the
function
conversion
rules,
then
a
type
error
[
err:XPTY0004
]
XP
may
be
raised.
(If
a
type
error
is
not
raised
at
this
stage,
it
will
be
raised
later
when
the
new
function
is
invoked.)
The
expression
let
$f
:=
fn:partial-apply(fn:contains#2,
"e",
2)
return
($f("Mike"),
$f("John"))
returns
(true(),
false())
.
The
expression
let
$tail
:=
fn:partial-apply(fn:remove#2,
1,
2)
return
$tail((1,2,3,4))
returns
(2,3,4)
.
Editorial note | |
The following reference needs to be rephrased so it refers to "whichever version of XSD the implementation chooses to support". |
Every
built-in
atomic
type
that
is
defined
in
[XML
Schema
Part
2:
Datatypes
Second
Edition]
,
except
xs:anyAtomicType
and
xs:NOTATION
,
has
an
associated
constructor
function.
xs:untypedAtomic
,
defined
in
Section
2.6
Types
DM
and
the
two
derived
types
xs:yearMonthDuration
and
xs:dayTimeDuration
defined
in
Section
2.6
Types
DM
also
have
associated
constructor
functions.
A
constructor
function
is
not
defined
for
xs:anyAtomicType
as
there
are
no
atomic
values
with
type
annotation
xs:anyAtomicType
at
runtime,
although
this
can
be
a
statically
inferred
type.
A
constructor
function
is
not
defined
for
xs:NOTATION
since
it
is
defined
as
an
abstract
type
in
[XML
Schema
Part
2:
Datatypes
Second
Edition]
.
If
the
static
context
(See
Section
2.1.1
Static
Context
XP
)
contains
a
type
derived
from
xs:NOTATION
then
a
constructor
function
is
defined
for
it.
See
17.3
Constructor
Functions
for
User-Defined
Types
.
The form of the constructor function for a type prefix:TYPE is:
prefix:TYPE
(
$arg
as
xs:anyAtomicType?
)
as
prefix:TYPE?
If
$arg
is
the
empty
sequence,
the
empty
sequence
is
returned.
For
example,
the
signature
of
the
constructor
function
corresponding
to
the
xs:unsignedInt
type
defined
in
[XML
Schema
Part
2:
Datatypes
Second
Edition]
is:
xs:unsignedInt
(
$arg
as
xs:anyAtomicType?
)
as
xs:unsignedInt?
Invoking
the
constructor
function
xs:unsignedInt(12)
returns
the
xs:unsignedInt
value
12.
Another
invocation
of
that
constructor
function
that
returns
the
same
xs:unsignedInt
value
is
xs:unsignedInt("12")
.
The
same
result
would
also
be
returned
if
the
constructor
function
were
to
be
invoked
with
a
node
that
had
a
typed
value
equal
to
the
xs:unsignedInt
12.
The
standard
features
described
in
Section
2.4.2
Atomization
XP
would
'atomize'
the
node
to
extract
its
typed
value
and
then
call
the
constructor
with
that
value.
If
the
value
passed
to
a
constructor
is
illegal
for
the
datatype
to
be
constructed,
an
error
is
raised
[
err:FORG0001
].
The
semantics
of
the
constructor
function
"
xs:TYPE(arg)
"
are
identical
to
the
semantics
of
"
arg
cast
as
xs:TYPE?
".
See
18
Casting
.
If the argument to a constructor function is a literal, the result of the function may be evaluated statically; if an error is found during such evaluation, it may be reported as a static error.
Special
rules
apply
to
constructor
functions
for
xs:QName
and
types
derived
from
xs:QName
and
xs:NOTATION
.
See
17.2
Constructor
Functions
for
xs:QName
and
xs:NOTATION
.
The following constructor functions for the built-in types are supported:
xs:string
(
$arg
as
xs:anyAtomicType?
)
as
xs:string?
xs:boolean
(
$arg
as
xs:anyAtomicType?
)
as
xs:boolean?
xs:decimal
(
$arg
as
xs:anyAtomicType?
)
as
xs:decimal?
xs:float
(
$arg
as
xs:anyAtomicType?
)
as
xs:float?
Implementations
·
may
·
return
negative
zero
for
xs:float("-0.0E0")
.
[XML
Schema
Part
2:
Datatypes
Second
Edition]
does
not
distinguish
between
the
values
positive
zero
and
negative
zero.
xs:double
(
$arg
as
xs:anyAtomicType?
)
as
xs:double?
Implementations
·
may
·
return
negative
zero
for
xs:double("-0.0E0").
[XML
Schema
Part
2:
Datatypes
Second
Edition]
does
not
distinguish
between
the
values
positive
zero
and
negative
zero.
xs:duration
(
$arg
as
xs:anyAtomicType?
)
as
xs:duration?
xs:dateTime
(
$arg
as
xs:anyAtomicType?
)
as
xs:dateTime?
xs:time
(
$arg
as
xs:anyAtomicType?
)
as
xs:time?
xs:date
(
$arg
as
xs:anyAtomicType?
)
as
xs:date?
xs:gYearMonth
(
$arg
as
xs:anyAtomicType?
)
as
xs:gYearMonth?
xs:gYear
(
$arg
as
xs:anyAtomicType?
)
as
xs:gYear?
xs:gMonthDay
(
$arg
as
xs:anyAtomicType?
)
as
xs:gMonthDay?
xs:gDay
(
$arg
as
xs:anyAtomicType?
)
as
xs:gDay?
xs:gMonth
(
$arg
as
xs:anyAtomicType?
)
as
xs:gMonth?
xs:hexBinary
(
$arg
as
xs:anyAtomicType?
)
as
xs:hexBinary?
xs:base64Binary
(
$arg
as
xs:anyAtomicType?
)
as
xs:base64Binary?
xs:anyURI
(
$arg
as
xs:anyAtomicType?
)
as
xs:anyURI?
xs:QName
(
$arg
as
xs:anyAtomicType
)
as
xs:QName?
See 17.2 Constructor Functions for xs:QName and xs:NOTATION for special rules.
xs:normalizedString
(
$arg
as
xs:anyAtomicType?
)
as
xs:normalizedString?
xs:token
(
$arg
as
xs:anyAtomicType?
)
as
xs:token?
xs:language
(
$arg
as
xs:anyAtomicType?
)
as
xs:language?
xs:NMTOKEN
(
$arg
as
xs:anyAtomicType?
)
as
xs:NMTOKEN?
xs:Name
(
$arg
as
xs:anyAtomicType?
)
as
xs:Name?
xs:NCName
(
$arg
as
xs:anyAtomicType?
)
as
xs:NCName?
xs:ID
(
$arg
as
xs:anyAtomicType?
)
as
xs:ID?
xs:IDREF
(
$arg
as
xs:anyAtomicType?
)
as
xs:IDREF?
xs:ENTITY
(
$arg
as
xs:anyAtomicType?
)
as
xs:ENTITY?
See
18.4.1
Casting
to
xs:ENTITY
for
rules
related
to
constructing
values
of
type
xs:ENTITY
and
types
derived
from
it.
xs:integer
(
$arg
as
xs:anyAtomicType?
)
as
xs:integer?
xs:nonPositiveInteger
(
$arg
as
xs:anyAtomicType?
)
as
xs:nonPositiveInteger?
xs:negativeInteger
(
$arg
as
xs:anyAtomicType?
)
as
xs:negativeInteger?
xs:long
(
$arg
as
xs:anyAtomicType?
)
as
xs:long?
xs:int
(
$arg
as
xs:anyAtomicType?
)
as
xs:int?
xs:short
(
$arg
as
xs:anyAtomicType?
)
as
xs:short?
xs:byte
(
$arg
as
xs:anyAtomicType?
)
as
xs:byte?
xs:nonNegativeInteger
(
$arg
as
xs:anyAtomicType?
)
as
xs:nonNegativeInteger?
xs:unsignedLong
(
$arg
as
xs:anyAtomicType?
)
as
xs:unsignedLong?
xs:unsignedInt
(
$arg
as
xs:anyAtomicType?
)
as
xs:unsignedInt?
xs:unsignedShort
(
$arg
as
xs:anyAtomicType?
)
as
xs:unsignedShort?
xs:unsignedByte
(
$arg
as
xs:anyAtomicType?
)
as
xs:unsignedByte?
xs:positiveInteger
(
$arg
as
xs:anyAtomicType?
)
as
xs:positiveInteger?
xs:yearMonthDuration
(
$arg
as
xs:anyAtomicType?
)
as
xs:yearMonthDuration?
xs:dayTimeDuration
(
$arg
as
xs:anyAtomicType?
)
as
xs:dayTimeDuration?
xs:untypedAtomic
(
$arg
as
xs:anyAtomicType?
)
as
xs:untypedAtomic?
xs:dateTimeStamp
(
$arg
as
xs:anyAtomicType?
)
as
xs:dateTimeStamp?
Special
rules
apply
to
constructor
functions
for
the
types
xs:QName
and
xs:NOTATION
,
for
two
reasons:
The lexical representation of these types uses namespace prefixes, whose meaning is context-dependent.
Values
cannot
belong
directly
to
the
type
xs:NOTATION
,
only
to
its
subtypes.
These constraints result in the following restrictions:
Conversion
from
an
xs:string
to
a
value
of
type
xs:QName
,
a
type
derived
from
xs:QName
or
a
type
derived
from
xs:NOTATION
is
permitted
only
if
the
xs:string
is
written
as
a
string
literal.
This
applies
whether
the
conversion
is
expressed
using
a
constructor
function
or
using
the
"cast
as"
syntax.
Such
a
conversion
can
be
regarded
as
a
pseudo-function,
which
is
always
evaluated
statically.
It
is
also
permitted
for
these
constructors
and
casts
to
take
a
dynamically-supplied
argument
in
the
normal
manner,
but
as
the
casting
table
(see
18.1
Casting
from
primitive
types
to
primitive
types
)
indicates,
the
only
arguments
that
are
supported
in
this
case
are
values
of
type
xs:QName
or
xs:NOTATION
respectively.
There
is
no
constructor
function
for
xs:NOTATION
.
Constructors
are
defined,
however,
for
xs:QName
,
for
types
derived
from
xs:QName
,
and
for
types
derived
from
xs:NOTATION
.
When
converting
from
an
xs:string
,
the
prefix
within
the
lexical
xs:QName
supplied
as
the
argument
is
resolved
to
a
namespace
URI
using
the
statically
known
namespaces
from
the
static
context.
If
the
lexical
xs:QName
has
no
prefix,
the
namespace
URI
of
the
resulting
expanded-QName
is
the
default
element/type
namespace
from
the
static
context.
Components
of
the
static
context
are
discussed
in
Section
2.1.1
Static
Context
XP
.
A
static
error
is
raised
[
err:FONS0004
]
if
the
prefix
is
not
bound
in
the
static
context.
As
described
in
Section
2.1
Terminology
DM
,
the
supplied
prefix
is
retained
as
part
of
the
expanded-QName
value.
For every atomic type in the static context (See Section 2.1.1 Static Context XP ) that is derived from a primitive type, there is a constructor function (whose name is the same as the name of the type) whose effect is to create a value of that type from the supplied argument. The rules for constructing user-defined types are defined in the same way as the rules for constructing built-in derived types discussed in 17.1 Constructor Functions for XML Schema Built-in Types .
Special
rules
apply
to
constructor
functions
for
types
derived
from
xs:QName
and
xs:NOTATION
.
See
17.2
Constructor
Functions
for
xs:QName
and
xs:NOTATION
.
Consider
a
situation
where
the
static
context
contains
a
type
called
hatSize
defined
in
a
schema
whose
target
namespace
is
bound
to
the
prefix
my
.
In
such
a
case
the
constructor
function:
my:hatSize
(
$arg
as
xs:anyAtomicType?
)
as
my:hatSize?
is available to users.
To
construct
an
instance
of
an
atomic
type
that
is
not
in
a
namespace,
it
is
necessary
to
use
a
cast
expression
or
undeclare
the
default
function
namespace.
For
example,
if
the
user-defined
type
apple
is
derived
from
xs:integer
but
is
not
in
a
namespace,
an
instance
of
this
type
can
be
constructed
as
follows
using
a
cast
expression
(this
requires
that
the
default
element/type
namespace
is
no
namespace):
17 cast as apple
The following shows the use of the constructor function:
declare default function namespace ""; apple(17)
Constructor
functions
and
cast
expressions
accept
an
expression
and
return
a
value
of
a
given
type.
They
both
convert
a
source
value,
SV
,
of
a
source
type,
ST
,
to
a
target
value,
TV
,
of
the
given
target
type,
TT
,
with
identical
semantics
and
different
syntax.
The
name
of
the
constructor
function
is
the
same
as
the
name
of
the
built-in
[XML
Schema
Part
2:
Datatypes
Second
Edition]
datatype
or
the
datatype
defined
in
Section
2.6
Types
DM
of
[XQuery
1.0
and
XPath
2.0
Data
Model]
Model
(XDM)
1.1]
(see
5.1
17.1
Constructor
Functions
for
XML
Schema
Built-in
Types
)
or
the
user-derived
datatype
(see
5.4
17.3
Constructor
Functions
for
User-Defined
Types
)
that
is
the
target
for
the
conversion,
and
the
semantics
are
exactly
the
same
as
for
a
cast
expression;
for
example,"
xs:date("2003-01-01")
"
means
exactly
the
same
as
"
"2003-01-01"
cast
as
xs:date?
".
The cast expression takes a type name to indicate the target type of the conversion. See Section 3.10.2 Cast XP . If the type name allows the empty sequence and the expression to be cast is the empty sequence, the empty sequence is returned. If the type name does not allow the empty sequence and the expression to be cast is the empty sequence, a type error is raised [ err:XPTY0004 ] XP .
Where the argument to a cast is a literal, the result of the function may be evaluated statically; if an error is encountered during such evaluation, it may be reported as a static error.
Casting
from
primitive
type
to
primitive
type
is
discussed
in
17.1
18.1
Casting
from
primitive
types
to
primitive
types
.
Casting
to
derived
types
is
discussed
in
17.2
18.2
Casting
to
derived
types
.
Casting
from
derived
types
is
discussed
in
17.3
18.3
Casting
from
derived
types
to
parent
types
,
17.4
18.4
Casting
within
a
branch
of
the
type
hierarchy
and
17.5
18.5
Casting
across
the
type
hierarchy
.
When
casting
from
xs:string
the
semantics
in
17.1.1
18.1.1
Casting
from
xs:string
and
xs:untypedAtomic
apply,
regardless
of
target
type.
This
section
defines
casting
between
the
19
primitive
types
defined
in
[XML
Schema
Part
2:
Datatypes
Second
Edition]
as
well
as
xs:untypedAtomic
,
xs:integer
and
the
two
derived
types
of
xs:duration
(
xs:yearMonthDuration
and
xs:dayTimeDuration
).
These
four
types
are
not
primitive
types
but
they
are
treated
as
primitive
types
in
this
section.
The
type
conversions
that
are
supported
are
indicated
in
the
table
below.
In
this
table,
there
is
a
row
for
each
primitive
type
with
that
type
as
the
source
of
the
conversion
and
there
is
a
column
for
each
primitive
type
as
the
target
of
the
conversion.
The
intersections
of
rows
and
columns
contain
one
of
three
characters:
"Y"
indicates
that
a
conversion
from
values
of
the
type
to
which
the
row
applies
to
the
type
to
which
the
column
applies
is
supported;
"N"
indicates
that
there
are
no
supported
conversions
from
values
of
the
type
to
which
the
row
applies
to
the
type
to
which
the
column
applies;
and
"M"
indicates
that
a
conversion
from
values
of
the
type
to
which
the
row
applies
to
the
type
to
which
the
column
applies
may
succeed
for
some
values
in
the
value
space
and
fails
for
others.
[XML
Schema
Part
2:
Datatypes
Second
Edition]
defines
xs:NOTATION
as
an
abstract
type.
Thus,
casting
to
xs:NOTATION
from
any
other
type
including
xs:NOTATION
is
not
permitted
and
raises
[
err:XPST0080
]
XP
.
However,
casting
from
one
subtype
of
xs:NOTATION
to
another
subtype
of
xs:NOTATION
is
permitted.
Casting
is
not
supported
to
or
from
xs:anySimpleType
.
Thus,
there
is
no
row
or
column
for
this
type
in
the
table
below.
For
any
node
that
has
not
been
validated
or
has
been
validated
as
xs:anySimpleType
,
the
typed
value
of
the
node
is
an
atomic
value
of
type
xs:untypedAtomic
.
There
are
no
atomic
values
with
the
type
annotation
xs:anySimpleType
at
runtime.
Casting
to
a
type
that
is
not
atomic
raises
[
err:XPST0051
]
XP
.
Similarly,
casting
is
not
supported
to
or
from
xs:anyAtomicType
and
will
raise
error
[
err:XPST0080
]
XP
.
There
are
no
atomic
values
with
the
type
annotation
xs:anyAtomicType
at
runtime,
although
this
can
be
a
statically
inferred
type.
If casting is attempted from an ST to a TT for which casting is not supported, as defined in the table below, a type error is raised [ err:XPTY0004 ] XP .
In the following table, the columns and rows are identified by short codes that identify simple types as follows:
uA = xs:untypedAtomic
aURI = xs:anyURI
b64 = xs:base64Binary
bool = xs:boolean
dat = xs:date
gDay = xs:gDay
dbl = xs:double
dec = xs:decimal
dT = xs:dateTime
dTD = xs:dayTimeDuration
dur = xs:duration
flt = xs:float
hxB = xs:hexBinary
gMD = xs:gMonthDay
gMon = xs:gMonth
int = xs:integer
NOT = xs:NOTATION
QN = xs:QName
str = xs:string
tim = xs:time
gYM = xs:gYearMonth
yMD = xs:yearMonthDuration
gYr = xs:gYear
In the following table, the notation "S\T" indicates that the source ("S") of the conversion is indicated in the column below the notation and that the target ("T") is indicated in the row to the right of the notation.
S\T | uA | str | flt | dbl | dec | int | dur | yMD | dTD | dT | tim | dat | gYM | gYr | gMD | gDay | gMon | bool | b64 | hxB | aURI | QN | NOT |
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
uA | Y | Y | M | M | M | M | M | M | M | M | M | M | M | M | M | M | M | M | M | M | M | N | N |
str | Y | Y | M | M | M | M | M | M | M | M | M | M | M | M | M | M | M | M | M | M | M | M | M |
flt | Y | Y | Y | Y | M | M | N | N | N | N | N | N | N | N | N | N | N | Y | N | N | N | N | N |
dbl | Y | Y | Y | Y | M | M | N | N | N | N | N | N | N | N | N | N | N | Y | N | N | N | N | N |
dec | Y | Y | Y | Y | Y | Y | N | N | N | N | N | N | N | N | N | N | N | Y | N | N | N | N | N |
int | Y | Y | Y | Y | Y | Y | N | N | N | N | N | N | N | N | N | N | N | Y | N | N | N | N | N |
dur | Y | Y | N | N | N | N | Y | Y | Y | N | N | N | N | N | N | N | N | N | N | N | N | N | N |
yMD | Y | Y | N | N | N | N | Y | Y | Y | N | N | N | N | N | N | N | N | N | N | N | N | N | N |
dTD | Y | Y | N | N | N | N | Y | Y | Y | N | N | N | N | N | N | N | N | N | N | N | N | N | N |
dT | Y | Y | N | N | N | N | N | N | N | Y | Y | Y | Y | Y | Y | Y | Y | N | N | N | N | N | N |
tim | Y | Y | N | N | N | N | N | N | N | N | Y | N | N | N | N | N | N | N | N | N | N | N | N |
dat | Y | Y | N | N | N | N | N | N | N | Y | N | Y | Y | Y | Y | Y | Y | N | N | N | N | N | N |
gYM | Y | Y | N | N | N | N | N | N | N | N | N | N | Y | N | N | N | N | N | N | N | N | N | N |
gYr | Y | Y | N | N | N | N | N | N | N | N | N | N | N | Y | N | N | N | N | N | N | N | N | N |
gMD | Y | Y | N | N | N | N | N | N | N | N | N | N | N | N | Y | N | N | N | N | N | N | N | N |
gDay | Y | Y | N | N | N | N | N | N | N | N | N | N | N | N | N | Y | N | N | N | N | N | N | N |
gMon | Y | Y | N | N | N | N | N | N | N | N | N | N | N | N | N | N | Y | N | N | N | N | N | N |
bool | Y | Y | Y | Y | Y | Y | N | N | N | N | N | N | N | N | N | N | N | Y | N | N | N | N | N |
b64 | Y | Y | N | N | N | N | N | N | N | N | N | N | N | N | N | N | N | N | Y | Y | N | N | N |
hxB | Y | Y | N | N | N | N | N | N | N | N | N | N | N | N | N | N | N | N | Y | Y | N | N | N |
aURI | Y | Y | N | N | N | N | N | N | N | N | N | N | N | N | N | N | N | N | N | N | Y | N | N |
QN | Y | Y | N | N | N | N | N | N | N | N | N | N | N | N | N | N | N | N | N | N | N | Y |
|
NOT | Y | Y | N | N | N | N | N | N | N | N | N | N | N | N | N | N | N | N | N | N | N |
|
M |
The
following
sub-sections
define
the
semantics
of
casting
from
a
primitive
type
to
a
primitive
type.
Semantics
of
casting
to
and
from
a
derived
type
are
defined
in
sections
17.2
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
and
17.5
18.5
Casting
across
the
type
hierarchy
.
When
the
supplied
value
is
an
instance
of
xs:string
or
an
instance
of
xs:untypedAtomic
,
it
is
treated
as
being
a
string
value
and
mapped
to
a
typed
value
of
the
target
type
as
defined
in
[XML
Schema
Part
2:
Datatypes
Second
Edition]
.
Whitespace
normalization
is
applied
as
indicated
by
the
whiteSpace
facet
for
the
datatype.
The
resulting
whitespace-normalized
string
must
be
a
valid
lexical
form
for
the
datatype.
The
semantics
of
casting
are
identical
to
XML
Schema
validation.
For
example,
"13"
cast
as
xs:unsignedInt
returns
the
xs:unsignedInt
typed
value
13
.
This
could
also
be
written
xs:unsignedInt("13")
.
When
casting
from
xs:string
or
xs:untypedAtomic
to
a
derived
type
where
the
derived
type
is
restricted
by
a
pattern
facet,
the
lexical
form
is
first
checked
against
the
pattern
before
further
casting
is
attempted
(See
17.2
18.2
Casting
to
derived
types
).
If
the
lexical
form
does
not
conform
to
the
pattern,
error
[
err:FORG0001
]
is
raised.
Consider
a
user-defined
Schema
whose
target
namespace
is
bound
to
the
prefix
mySchema
which
defines
a
restriction
of
xs:boolean
called
trueBool
which
allows
only
the
lexical
forms
"
1
"
and
"
0
".
"true"
cast
as
mySchema:trueBool
would
fail
with
[
err:FORG0001
].
If
the
Schema
also
defines
a
datatype
called
height
as
a
restriction
of
xs:integer
with
a
maximum
value
of
84
then
"100"
cast
as
mySchema:height
would
also
fail
with
[
err:FORG0001
].
Casting
is
permitted
from
xs:string
and
xs:untypedAtomic
to
any
primitive
atomic
type
or
any
atomic
type
derived
by
restriction,
except
xs:QName
or
xs:NOTATION
.
Casting
to
xs:NOTATION
is
not
permitted
because
it
is
an
abstract
type.
Casting
is
permitted
from
xs:string
literals
to
xs:QName
and
types
derived
from
xs:NOTATION
.
If
the
argument
to
such
a
cast
is
computed
dynamically,
[
err:XPTY0004
]
XP
is
raised
if
the
value
is
of
any
type
other
than
xs:QName
or
xs:NOTATION
respectively
(including
the
case
where
it
is
an
xs:string
).
The
process
is
described
in
more
detail
in
17.2
Constructor
Functions
for
xs:QName
and
xs:NOTATION
.
Note:
This
version
of
the
specification
allows
casting
between
xs:QName
and
xs:NOTATION
in
either
direction;
this
was
not
permitted
in
the
previous
Recommendation.
In
casting
to
numerics,
if
the
value
is
too
large
or
too
small
to
be
accurately
represented
by
the
implementation,
it
is
handled
as
an
overflow
or
underflow
as
defined
in
6.2
4.2
Arithmetic
Operators
on
Numeric
Values
.
In
casting
to
xs:decimal
or
to
a
type
derived
from
xs:decimal
,
if
the
value
is
not
too
large
or
too
small
but
nevertheless
cannot
be
represented
accurately
with
the
number
of
decimal
digits
available
to
the
implementation,
the
implementation
may
round
to
the
nearest
representable
value
or
may
raise
a
dynamic
error
[
err:FOCA0006
].
The
choice
of
rounding
algorithm
and
the
choice
between
rounding
and
error
behavior
and
is
implementation-defined.
In
casting
to
a
date
xs:date
,
xs:dateTime
,
xs:gYear
,
or
time
value,
xs:gYearMonth
(or
types
derived
from
these),
if
the
value
is
too
large
or
too
small
to
be
represented
by
the
implementation,
error
[
err:FODT0001
]
is
raised.
In casting to a duration value, if the value is too large or too small to be represented by the implementation, error [ err:FODT0002 ] is raised.
For
xs:anyURI
,
the
extent
to
which
an
implementation
validates
the
lexical
form
of
xs:anyURI
is
·
implementation
dependent
·
.
If the cast fails for any other reason, error [ err:FORG0001 ] is raised.
Casting
is
permitted
from
any
primitive
type
to
the
primitive
types
xs:string
and
xs:untypedAtomic
.
When
a
value
of
any
simple
type
is
cast
as
xs:string
,
the
derivation
of
the
xs:string
value
TV
depends
on
the
ST
and
on
the
SV
,
as
follows.
If
ST
is
xs:string
or
a
type
derived
from
xs:string
,
TV
is
SV
.
If
ST
is
xs:anyURI
,
the
type
conversion
is
performed
without
escaping
any
characters.
If
ST
is
xs:QName
or
xs:NOTATION
:
if
the
qualified
name
has
a
prefix
prefix,
then
TV
is
(
fn:concat(fn:prefix-from-QName(
the
concatenation
of
the
prefix
of
SV
)
,
":"
,
fn:local-name-from-QName(
,
a
single
colon
(:),
and
the
local
name
of
SV
))
.
.
otherwise TV is the local-name.
If ST is a numeric type, the following rules apply:
If
ST
is
xs:integer
,
TV
is
the
canonical
lexical
representation
of
SV
as
defined
in
[XML
Schema
Part
2:
Datatypes
Second
Edition]
.
There
is
no
decimal
point.
If
ST
is
xs:decimal
,
then:
If
SV
is
in
the
value
space
of
xs:integer
,
that
is,
if
there
are
no
significant
digits
after
the
decimal
point,
then
the
value
is
converted
from
an
xs:decimal
to
an
xs:integer
and
the
resulting
xs:integer
is
converted
to
an
xs:string
using
the
rule
above.
Otherwise, the canonical lexical representation of SV is returned, as defined in [XML Schema Part 2: Datatypes Second Edition] .
If
ST
is
xs:float
or
xs:double
,
then:
TV
will
be
an
xs:string
in
the
lexical
space
of
xs:double
or
xs:float
that
when
converted
to
an
xs:double
or
xs:float
under
the
rules
of
17.1.1
18.1.1
Casting
from
xs:string
and
xs:untypedAtomic
produces
a
value
that
is
equal
to
SV
,
or
is
"NaN"
if
SV
is
NaN
.
In
addition,
TV
must
satisfy
the
constraints
in
the
following
sub-bullets.
If
SV
has
an
absolute
value
that
is
greater
than
or
equal
to
0.000001
(one
millionth)
and
less
than
1000000
(one
million),
then
the
value
is
converted
to
an
xs:decimal
and
the
resulting
xs:decimal
is
converted
to
an
xs:string
according
to
the
rules
above,
as
though
using
an
implementation
of
xs:decimal
that
imposes
no
limits
on
the
totalDigits
or
fractionDigits
facets.
If SV has the value positive or negative zero, TV is "0" or "-0" respectively.
If
SV
is
positive
or
negative
infinity,
TV
is
the
string
"
INF
"
or
"
-INF
"
respectively.
In
other
cases,
the
result
consists
of
a
mantissa,
which
has
the
lexical
form
of
an
xs:decimal
,
followed
by
the
letter
"E",
followed
by
an
exponent
which
has
the
lexical
form
of
an
xs:integer
.
Leading
zeroes
and
"+"
signs
are
prohibited
in
the
exponent.
For
the
mantissa,
there
must
be
a
decimal
point,
and
there
must
be
exactly
one
digit
before
the
decimal
point,
which
must
be
non-zero.
The
"+"
sign
is
prohibited.
There
must
be
at
least
one
digit
after
the
decimal
point.
Apart
from
this
mandatory
digit,
trailing
zero
digits
are
prohibited.
Note:
The
above
rules
allow
more
than
one
representation
of
the
same
value.
For
example,
the
xs:float
value
whose
exact
decimal
representation
is
1.26743223E15
might
be
represented
by
any
of
the
strings
"1.26743223E15",
"1.26743222E15"
or
"1.26743224E15"
(inter
alia).
It
is
implementation-dependent
which
of
these
representations
is
chosen.
If
ST
is
xs:dateTime
,
xs:date
or
xs:time
,
TV
is
the
local
value.
The
components
of
TV
are
individually
cast
to
xs:string
using
the
functions
described
in
[casting-to-datetimes]
and
the
results
are
concatenated
together.
The
year
component
is
cast
to
xs:string
using
eg:convertYearToString
.
The
month
,
day
,
hour
and
minute
components
are
cast
to
xs:string
using
eg:convertTo2CharString
.
The
second
component
is
cast
to
xs:string
using
eg:convertSecondsToString
.
The
timezone
component,
if
present,
is
cast
to
xs:string
using
eg:convertTZtoString
.
Note
that
the
hours
component
of
the
resulting
string
will
never
be
"24"
.
Midnight
is
always
represented
as
"00:00:00"
.
If
ST
is
xs:yearMonthDuration
or
xs:dayTimeDuration
,
TV
is
the
canonical
representation
of
SV
as
defined
in
10.3.1
8.2.1
xs:yearMonthDuration
or
10.3.2
8.2.2
xs:dayTimeDuration
,
respectively.
If
ST
is
xs:duration
then
let
SYM
be
SV
cast
as
xs:yearMonthDuration
,
and
let
SDT
be
SV
cast
as
xs:dayTimeDuration
;
Now,
let
the
next
intermediate
value,
TYM
,
be
SYM
cast
as
TT
,
,
and
let
TDT
be
SDT
cast
as
TT
.
.
If
TYM
is
"P0M",
then
TV
is
TDT
.
Otherwise,
TYM
and
TDT
are
merged
according
to
the
following
rules:
If TDT is "PT0S", then TV is TYM .
Otherwise, TV is the concatenation of all the characters in TYM and all the characters except the first "P" and the optional negative sign in TDT .
In all other cases, TV is the [XML Schema Part 2: Datatypes Second Edition] canonical representation of SV . For datatypes that do not have a canonical lexical representation defined an · implementation dependent · canonical representation may be used.
To
cast
as
xs:untypedAtomic
the
value
is
cast
as
xs:string
,
as
described
above,
and
the
type
annotation
changed
to
xs:untypedAtomic
.
Note:
The
string
representations
of
numeric
values
are
backwards
compatible
with
XPath
1.0
except
for
the
special
values
positive
and
negative
infinity,
negative
zero
and
values
outside
the
range
1.0e-6
to
1.0e+6
.
When
a
value
of
any
simple
type
is
cast
as
xs:float
,
the
xs:float
TV
is
derived
from
the
ST
and
the
SV
as
follows:
If
ST
is
xs:float
,
then
TV
is
SV
and
the
conversion
is
complete.
If
ST
is
xs:double
,
then
TV
is
obtained
as
follows:
if
SV
is
the
xs:double
value
INF
,
-INF
,
NaN
,
positive
zero,
or
negative
zero,
then
TV
is
the
xs:float
value
INF
,
-INF
,
NaN
,
positive
zero,
or
negative
zero
respectively.
otherwise,
SV
can
be
expressed
in
the
form
m
×
2^e
where
the
mantissa
m
and
exponent
e
are
signed
xs:integer
s
whose
value
range
is
defined
in
[XML
Schema
Part
2:
Datatypes
Second
Edition]
,
and
the
following
rules
apply:
if
m
(the
mantissa
of
SV
)
is
outside
the
permitted
range
for
the
mantissa
of
an
xs:float
value
(-2^24-1
to
+2^24-1)
,
then
it
is
divided
by
2^N
where
N
is
the
lowest
positive
xs:integer
that
brings
the
result
of
the
division
within
the
permitted
range,
and
the
exponent
e
is
increased
by
N
.
This
is
integer
division
(in
effect,
the
binary
value
of
the
mantissa
is
truncated
on
the
right).
Let
M
be
the
mantissa
and
E
the
exponent
after
this
adjustment.
if
E
exceeds
104
(the
maximum
exponent
value
in
the
value
space
of
xs:float
)
then
TV
is
the
xs:float
value
INF
or
-INF
depending
on
the
sign
of
M
.
if
E
is
less
than
-149
(the
minimum
exponent
value
in
the
value
space
of
xs:float
)
then
TV
is
the
xs:float
value
positive
or
negative
zero
depending
on
the
sign
of
M
otherwise,
TV
is
the
xs:float
value
M
×
2^E
.
If
ST
is
xs:decimal
,
or
xs:integer
,
then
TV
is
xs:float(
SV
cast
as
xs:string)
and
the
conversion
is
complete.
If
ST
is
xs:boolean
,
SV
is
converted
to
1.0E0
if
SV
is
true
and
to
0.0E0
if
SV
is
false
and
the
conversion
is
complete.
If
ST
is
xs:untypedAtomic
or
xs:string
,
see
17.1.1
18.1.1
Casting
from
xs:string
and
xs:untypedAtomic
.
Note:
Implementations
·
may
·
return
negative
zero
for
"-0.0E0"
cast
as
xs:float
.
[XML
Schema
Part
2:
Datatypes
Second
Edition]
does
not
distinguish
between
the
values
positive
zero
and
negative
zero.
When
a
value
of
any
simple
type
is
cast
as
xs:double
,
the
xs:double
value
TV
is
derived
from
the
ST
and
the
SV
as
follows:
If
ST
is
xs:double
,
then
TV
is
SV
and
the
conversion
is
complete.
If
ST
is
xs:float
or
a
type
derived
from
xs:float
,
then
TV
is
obtained
as
follows:
if
SV
is
the
xs:float
value
INF
,
-INF
,
NaN
,
positive
zero,
or
negative
zero,
then
TV
is
the
xs:double
value
INF
,
-INF
,
NaN
,
positive
zero,
or
negative
zero
respectively.
otherwise,
SV
can
be
expressed
in
the
form
m
×
2^e
where
the
mantissa
m
and
exponent
e
are
signed
xs:integer
values
whose
value
range
is
defined
in
[XML
Schema
Part
2:
Datatypes
Second
Edition]
,
and
TV
is
the
xs:double
value
m
×
2^e
.
If
ST
is
xs:decimal
or
xs:integer
,
then
TV
is
xs:double(
SV
cast
as
xs:string)
and
the
conversion
is
complete.
If
ST
is
xs:boolean
,
SV
is
converted
to
1.0E0
if
SV
is
true
and
to
0.0E0
if
SV
is
false
and
the
conversion
is
complete.
If
ST
is
xs:untypedAtomic
or
xs:string
,
see
17.1.1
18.1.1
Casting
from
xs:string
and
xs:untypedAtomic
.
Note:
Implementations
·
may
·
return
negative
zero
for
"-0.0E0"
cast
as
xs:double
.
[XML
Schema
Part
2:
Datatypes
Second
Edition]
does
not
distinguish
between
the
values
positive
zero
and
negative
zero.
When
a
value
of
any
simple
type
is
cast
as
xs:decimal
,
the
xs:decimal
value
TV
is
derived
from
ST
and
SV
as
follows:
If
ST
is
xs:decimal
,
xs:integer
or
a
type
derived
from
them,
then
TV
is
SV
,
converted
to
an
xs:decimal
value
if
need
be,
and
the
conversion
is
complete.
If
ST
is
xs:float
or
xs:double
,
then
TV
is
the
xs:decimal
value,
within
the
set
of
xs:decimal
values
that
the
implementation
is
capable
of
representing,
that
is
numerically
closest
to
SV
.
If
two
values
are
equally
close,
then
the
one
that
is
closest
to
zero
is
chosen.
If
SV
is
too
large
to
be
accommodated
as
an
xs:decimal
,
(see
[XML
Schema
Part
2:
Datatypes
Second
Edition]
for
·
implementation-defined
·
limits
on
numeric
values)
an
error
is
raised
[
err:FOCA0001
].
If
SV
is
one
of
the
special
xs:float
or
xs:double
values
NaN
,
INF
,
or
-INF
,
an
error
is
raised
[
err:FOCA0002
].
If
ST
is
xs:boolean
,
SV
is
converted
to
1.0
if
SV
is
1
or
true
and
to
0.0
if
SV
is
0
or
false
and
the
conversion
is
complete.
If
ST
is
xs:untypedAtomic
or
xs:string
,
see
17.1.1
18.1.1
Casting
from
xs:string
and
xs:untypedAtomic
.
When
a
value
of
any
simple
type
is
cast
as
xs:integer
,
the
xs:integer
value
TV
is
derived
from
ST
and
SV
as
follows:
If
ST
is
xs:integer
,
or
a
type
derived
from
xs:integer
,
then
TV
is
SV
,
converted
to
an
xs:integer
value
if
need
be,
and
the
conversion
is
complete.
If
ST
is
xs:decimal
,
xs:float
or
xs:double
,
then
TV
is
SV
with
the
fractional
part
discarded
and
the
value
converted
to
xs:integer
.
Thus,
casting
3.1456
returns
3
and
-17.89
returns
-17
.
Casting
3.124E1
returns
31
.
If
SV
is
too
large
to
be
accommodated
as
an
integer,
(see
[XML
Schema
Part
2:
Datatypes
Second
Edition]
for
·
implementation-defined
·
limits
on
numeric
values)
an
error
is
raised
[
err:FOCA0003
].
If
SV
is
one
of
the
special
xs:float
or
xs:double
values
NaN
,
INF
,
or
-INF
,
an
error
is
raised
[
err:FOCA0002
].
If
ST
is
xs:boolean
,
SV
is
converted
to
1
if
SV
is
1
or
true
and
to
0
if
SV
is
0
or
false
and
the
conversion
is
complete.
If
ST
is
xs:untypedAtomic
or
xs:string
,
see
17.1.1
18.1.1
Casting
from
xs:string
and
xs:untypedAtomic
.
When
a
value
of
type
xs:untypedAtomic
,
xs:string
,
a
type
derived
from
xs:string
,
xs:yearMonthDuration
or
xs:dayTimeDuration
is
cast
as
xs:duration
,
xs:yearMonthDuration
or
xs:dayTimeDuration
,
TV
is
derived
from
ST
and
SV
as
follows:
If ST is the same as TT , then TV is SV .
If
ST
is
xs:duration
,
or
a
type
derived
from
xs:duration
,
but
not
xs:dayTimeDuration
or
a
type
derived
from
xs:dayTimeDuration
,
and
TT
is
xs:yearMonthDuration
,
then
TV
is
derived
from
SV
by
removing
the
day,
hour,
minute
and
second
components
from
SV
.
If
ST
is
xs:duration
,
or
a
type
derived
from
duration
,
but
not
xs:yearMonthDuration
or
a
type
derived
from
xs:yearMonthDuration
,
and
TT
is
xs:dayTimeDuration
,
then
TV
is
derived
from
SV
by
removing
the
year
and
month
components
from
SV
.
If
ST
is
xs:yearMonthDuration
or
xs:dayTimeDuration
,
and
TT
is
xs:duration
,
then
TV
is
derived
from
SV
as
discussed
in
17.3
18.3
Casting
from
derived
types
to
parent
types
.
If
ST
is
xs:yearMonthDuration
and
TT
is
xs:dayTimeDuration
,
the
cast
is
permitted
and
returns
a
xs:dayTimeDuration
with
value
0.0
seconds.
If
ST
is
xs:dayTimeDuration
and
TT
is
xs:yearMonthDuration
,
the
cast
is
permitted
and
returns
a
xs:yearMonthDuration
with
value
0
months.
If
ST
is
xs:untypedAtomic
or
xs:string
,
see
17.1.1
18.1.1
Casting
from
xs:string
and
xs:untypedAtomic
.
Note
that
casting
from
xs:duration
to
xs:yearMonthDuration
or
xs:dayTimeDuration
loses
information.
To
avoid
this,
users
can
cast
the
xs:duration
value
to
both
an
xs:yearMonthDuration
and
an
xs:dayTimeDuration
and
work
with
both
values.
In
several
situations,
casting
to
date
and
time
types
requires
the
extraction
of
a
component
from
SV
or
from
the
result
of
fn:current-dateTime
and
converting
it
to
an
xs:string
.
These
conversions
must
follow
certain
rules.
For
example,
converting
an
xs:integer
year
value
requires
converting
to
an
xs:string
with
four
or
more
characters,
preceded
by
a
minus
sign
if
the
value
is
negative.
This document defines four functions to perform these conversions. These functions are for illustrative purposes only and make no recommendations as to style or efficiency. References to these functions from the following text are not normative.
The arguments to these functions come from functions defined in this document. Thus, the functions below assume that they are correct and do no range checking on them.
declare function eg:convertYearToString($year as xs:integer) as xs:string { let $plusMinus := if ($year >= 0) then "" else "-" let $yearString := fn:abs($year) cast as xs:stringlet $length := fn:length($yearString)let $length := fn:string-length($yearString) return if ($length = 1) then fn:concat($plusMinus, "000", $yearString) else if ($length = 2) then fn:concat($plusMinus, "00", $yearString) else if ($length = 3) then fn:concat($plusMinus, "0", $yearString) else fn:concat($plusMinus, $yearString) }
declare function eg:convertTo2CharString($value as xs:integer) as xs:string { let $string := $value cast as xs:string returnif (fn:length($string) = 1) then fn:concat("0", $string)if (fn:string-length($string) = 1) then fn:concat("0", $string) else $string }
declare function eg:convertSecondsToString($seconds as xs:decimal) as xs:string { let $string := $seconds cast as xs:stringlet $intLength := fn:length(($seconds cast as xs:integer) cast as xs:string)let $intLength := fn:string-length(($seconds cast as xs:integer) cast as xs:string) return if ($intLength = 1) then fn:concat("0", $string) else $string }
declare function eg:convertTZtoString($tz as xs:dayTimeDuration?) as xs:string {if (empty($tz)) then ""if (empty($tz)) then "" else if ($tz eq xs:dayTimeDuration('PT0S')) then "Z" elselet $tzh := fn:hours-from-dayTimeDuration($tz) let $tzm := fn:minutes-from-dayTimeDuration($tz)let $tzh := fn:hours-from-duration($tz) let $tzm := fn:minutes-from-duration($tz) let $plusMinus := if ($tzh >= 0) then "+" else "-" let $tzhString := eg:convertTo2CharString(fn:abs($tzh)) let $tzmString := eg:convertTo2CharString(fn:abs($tzm)) return fn:concat($plusMinus, $tzhString, ":", $tzmString) }
Conversion from primitive types to date and time types follows the rules below.
When
a
value
of
any
primitive
type
is
cast
as
xs:dateTime
,
the
xs:dateTime
value
TV
is
derived
from
ST
and
SV
as
follows:
If
ST
is
xs:dateTime
,
then
TV
is
SV
.
If
ST
is
xs:date
,
then
let
SYR
be
eg:convertYearToString(
fn:year-from-date(
SV
))
,
let
SMO
be
eg:convertTo2CharString(
fn:month-from-date(
SV
))
,
let
SDA
be
eg:convertTo2CharString(
fn:day-from-date(
SV
))
and
let
STZ
be
eg:convertTZtoString(
fn:timezone-from-date(
SV
))
;
TV
is
xs:dateTime(
fn:concat(
SYR
,
'-',
SMO
,
'-',
SDA
,
'T00:00:00
'
,
STZ
)
)
.
If
ST
is
xs:untypedAtomic
or
xs:string
,
see
17.1.1
18.1.1
Casting
from
xs:string
and
xs:untypedAtomic
.
When
a
value
of
any
primitive
type
is
cast
as
xs:time
,
the
xs:time
value
TV
is
derived
from
ST
and
SV
as
follows:
If
ST
is
xs:time
,
then
TV
is
SV
.
If
ST
is
xs:dateTime
,
then
TV
is
xs:time(
fn:concat(
eg:convertTo2CharString(
fn:hours-from-dateTime(
SV
)),
':',
eg:convertTo2CharString(
fn:minutes-from-dateTime(
SV
)),
':',
eg:convertSecondsToString(
fn:seconds-from-dateTime(
SV
)),
eg:convertTZtoString(
fn:timezone-from-dateTime(
SV
))
))
.
If
ST
is
xs:untypedAtomic
or
xs:string
,
see
17.1.1
18.1.1
Casting
from
xs:string
and
xs:untypedAtomic
.
When
a
value
of
any
primitive
type
is
cast
as
xs:date
,
the
xs:date
value
TV
is
derived
from
ST
and
SV
as
follows:
If
ST
is
xs:date
,
then
TV
is
SV
.
If
ST
is
xs:dateTime
,
then
let
SYR
be
eg:convertYearToString(
fn:year-from-dateTime(
SV
))
,
let
SMO
be
eg:convertTo2CharString(
fn:month-from-dateTime(
SV
))
,
let
SDA
be
eg:convertTo2CharString(
fn:day-from-dateTime(
SV
))
and
let
STZ
be
eg:convertTZtoString(fn:timezone-from-dateTime(
SV
))
;
TV
is
xs:date(
fn:concat(
SYR
,
'-',
SMO
,
'-',
SDA
,
STZ
)
)
.
If
ST
is
xs:untypedAtomic
or
xs:string
,
see
17.1.1
18.1.1
Casting
from
xs:string
and
xs:untypedAtomic
.
When
a
value
of
any
primitive
type
is
cast
as
xs:gYearMonth
,
the
xs:gYearMonth
value
TV
is
derived
from
ST
and
SV
as
follows:
If
ST
is
xs:gYearMonth
,
then
TV
is
SV
.
If
ST
is
xs:dateTime
,
then
let
SYR
be
eg:convertYearToString(
fn:year-from-dateTime(
SV
))
,
let
SMO
be
eg:convertTo2CharString(
fn:month-from-dateTime(
SV
))
and
let
STZ
be
eg:convertTZtoString(
fn:timezone-from-dateTime(
SV
))
;
TV
is
xs:gYearMonth(
fn:concat(
SYR
,
'-',
SMO
,
STZ
)
)
.
If
ST
is
xs:date
,
then
let
SYR
be
eg:convertYearToString(
fn:year-from-date(
SV
))
,
let
SMO
be
eg:convertTo2CharString(
fn:month-from-date(
SV
))
and
let
STZ
be
eg:convertTZtoString(
fn:timezone-from-date(
SV
))
;
TV
is
xs:gYearMonth(
fn:concat(
SYR
,
'-',
SMO
,
STZ
)
)
.
If
ST
is
xs:untypedAtomic
or
xs:string
,
see
17.1.1
18.1.1
Casting
from
xs:string
and
xs:untypedAtomic
.
When
a
value
of
any
primitive
type
is
cast
as
xs:gYear
,
the
xs:gYear
value
TV
is
derived
from
ST
and
SV
as
follows:
If
ST
is
xs:gYear
,
then
TV
is
SV
.
If
ST
is
xs:dateTime
,
let
SYR
be
eg:convertYearToString(
fn:year-from-dateTime(
SV
))
and
let
STZ
be
eg:convertTZtoString(
fn:timezone-from-dateTime(
SV
))
;
TV
is
xs:gYear(fn:concat(
SYR
,
STZ
))
.
If
ST
is
xs:date
,
let
SYR
be
eg:convertYearToString(
fn:year-from-date(
SV
))
;
and
let
STZ
be
eg:convertTZtoString(
fn:timezone-from-date(
SV
))
;
TV
is
xs:gYear(fn:concat(
SYR
,
STZ
))
.
If
ST
is
xs:untypedAtomic
or
xs:string
,
see
17.1.1
18.1.1
Casting
from
xs:string
and
xs:untypedAtomic
.
When
a
value
of
any
primitive
type
is
cast
as
xs:gMonthDay
,
the
xs:gMonthDay
value
TV
is
derived
from
ST
and
SV
as
follows:
If
ST
is
xs:gMonthDay
,
then
TV
is
SV
.
If
ST
is
xs:dateTime
,
then
let
SMO
be
eg:convertTo2CharString(
fn:month-from-dateTime(
SV
))
,
let
SDA
be
eg:convertTo2CharString(
fn:day-from-dateTime(
SV
))
and
let
STZ
be
eg:convertTZtoString(
fn:timezone-from-dateTime(
SV
))
;
TV
is
xs:gYearMonth(
fn:concat(
'--',
SMO
'-',
SDA
,
STZ
)
)
.
If
ST
is
xs:date
,
then
let
SMO
be
eg:convertTo2CharString(
fn:month-from-date(
SV
))
,
let
SDA
be
eg:convertTo2CharString(
fn:day-from-date(
SV
))
and
let
STZ
be
eg:convertTZtoString(
fn:timezone-from-date(
SV
))
;
TV
is
xs:gYearMonth(
fn:concat(
'--',
SMO
,
'-',
SDA
,
STZ
)
)
.
If
ST
is
xs:untypedAtomic
or
xs:string
,
see
17.1.1
18.1.1
Casting
from
xs:string
and
xs:untypedAtomic
.
When
a
value
of
any
primitive
type
is
cast
as
xs:gDay
,
the
xs:gDay
value
TV
is
derived
from
ST
and
SV
as
follows:
If
ST
is
xs:gDay
,
then
TV
is
SV
.
If
ST
is
xs:dateTime
,
then
let
SDA
be
eg:convertTo2CharString(
fn:day-from-dateTime(
SV
))
and
let
STZ
be
eg:convertTZtoString(
fn:timezone-from-dateTime(
SV
))
;
TV
is
xs:gDay(
fn:concat(
'---'
,
SDA
,
STZ
))
.
If
ST
is
xs:date
,
then
let
SDA
be
eg:convertTo2CharString(
fn:day-from-date(
SV
))
and
let
STZ
be
eg:convertTZtoString(
fn:timezone-from-date(
SV
))
;
TV
is
xs:gDay(
fn:concat(
'---'
,
SDA
,
STZ
))
.
If
ST
is
xs:untypedAtomic
or
xs:string
,
see
17.1.1
18.1.1
Casting
from
xs:string
and
xs:untypedAtomic
.
When
a
value
of
any
primitive
type
is
cast
as
xs:gMonth
,
the
xs:gMonth
value
TV
is
derived
from
ST
and
SV
as
follows:
If
ST
is
xs:gMonth
,
then
TV
is
SV
.
If
ST
is
xs:dateTime
,
then
let
SMO
be
eg:convertTo2CharString(
fn:month-from-dateTime(
SV
))
and
let
STZ
be
eg:convertTZtoString(
fn:timezone-from-dateTime(
SV
))
;
TV
is
xs:gMonth(
fn:concat(
'--'
,
SMO
,
STZ
))
.
If
ST
is
xs:date
,
then
let
SMO
be
eg:convertTo2CharString(
fn:month-from-date(
SV
))
and
let
STZ
be
eg:convertTZtoString(
fn:timezone-from-date(
SV
))
;
TV
is
xs:gMonth(
fn:concat(
'--'
,
SMO
,
STZ
))
.
If
ST
is
xs:untypedAtomic
or
xs:string
,
see
17.1.1
18.1.1
Casting
from
xs:string
and
xs:untypedAtomic
.
When
a
value
of
any
primitive
type
is
cast
as
xs:boolean
,
the
xs:boolean
value
TV
is
derived
from
ST
and
SV
as
follows:
If
ST
is
xs:boolean
,
then
TV
is
SV
.
If
ST
is
xs:float
,
xs:double
,
xs:decimal
or
xs:integer
and
SV
is
0
,
+0
,
-0
,
0.0
,
0.0E0
or
NaN
,
then
TV
is
false
.
If
ST
is
xs:float
,
xs:double
,
xs:decimal
or
xs:integer
and
SV
is
not
one
of
the
above
values,
then
TV
is
true
.
If
ST
is
xs:untypedAtomic
or
xs:string
,
see
17.1.1
18.1.1
Casting
from
xs:string
and
xs:untypedAtomic
.
Values
of
type
xs:base64Binary
can
be
cast
as
xs:hexBinary
and
vice
versa,
since
the
two
types
have
the
same
value
space.
Casting
to
xs:base64Binary
and
xs:hexBinary
is
also
supported
from
the
same
type
and
from
xs:untypedAtomic
,
xs:string
and
subtypes
of
xs:string
using
[XML
Schema
Part
2:
Datatypes
Second
Edition]
semantics.
Casting
to
xs:anyURI
is
supported
only
from
the
same
type,
xs:untypedAtomic
or
xs:string
.
When
a
value
of
any
primitive
type
is
cast
as
xs:anyURI
,
the
xs:anyURI
value
TV
is
derived
from
the
ST
and
SV
as
follows:
If
ST
is
xs:untypedAtomic
or
xs:string
see
17.1.1
18.1.1
Casting
from
xs:string
and
xs:untypedAtomic
.
Casting
from
xs:string
or
xs:untypedAtomic
to
xs:QName
or
xs:NOTATION
is
described
in
18.1.1
Casting
from
xs:string
and
xs:untypedAtomic
.
It
is
also
possible
to
cast
from
xs:NOTATION
to
xs:QName
,
or
from
xs:QName
to
any
type
derived
by
restriction
from
xs:NOTATION
.
(Casting
to
xs:NOTATION
itself
is
not
allowed,
because
xs:NOTATION
is
an
abstract
type.)
The
resulting
xs:QName
or
xs:NOTATION
has
the
same
prefix,
local
name,
and
namespace
URI
parts
as
the
supplied
value.
Casting
a
value
to
a
derived
type
can
be
separated
into
four
cases.
Note
that
xs:untypedAtomic
,
xs:integer
and
the
two
derived
types
of
xs:duration
:
xs:yearMonthDuration
and
xs:dayTimeDuration
are
treated
as
primitive
types.
When
SV
is
an
instance
of
a
type
that
is
derived
by
restriction
from
TT
.
This
is
described
in
section
17.3
18.3
Casting
from
derived
types
to
parent
types
.
When
SV
is
an
instance
of
a
type
derived
by
restriction
from
the
same
primitive
type
as
TT
.
This
is
described
in
17.4
18.4
Casting
within
a
branch
of
the
type
hierarchy
.
When
the
derived
type
is
derived,
directly
or
indirectly,
from
a
different
primitive
type
than
the
primitive
type
of
ST
.
This
is
described
in
17.5
18.5
Casting
across
the
type
hierarchy
.
When SV is an instance of the TT , the cast always succeeds (Identity cast).
Except
in
the
case
of
xs:NOTATION
,
it
is
always
possible
to
cast
a
value
of
any
atomic
type
to
an
atomic
type
from
which
it
is
derived,
directly
or
indirectly,
by
restriction.
For
example,
it
is
possible
to
cast
an
xs:unsignedShort
to
an
xs:unsignedInt
,
an
xs:integer
,
or
an
xs:decimal
.
Since
the
value
space
of
the
original
type
is
a
subset
of
the
value
space
of
the
target
type,
such
a
cast
is
always
successful.
The
result
will
have
the
same
value
as
the
original,
but
will
have
a
new
type
annotation.
It
is
possible
to
cast
an
SV
to
a
TT
if
the
type
of
the
SV
and
the
TT
type
are
both
derived
by
restriction
(directly
or
indirectly)
from
the
same
primitive
type,
provided
that
the
supplied
value
conforms
to
the
constraints
implied
by
the
facets
of
the
target
type.
This
includes
the
case
where
the
target
type
is
derived
from
the
type
of
the
supplied
value,
as
well
as
the
case
where
the
type
of
the
supplied
value
is
derived
from
the
target
type.
For
example,
an
instance
of
xs:byte
can
be
cast
as
xs:unsignedShort
,
provided
the
value
is
not
negative.
If
the
value
does
not
conform
to
the
facets
defined
for
the
target
type,
then
an
error
is
raised
[
err:FORG0001
].
See
[XML
Schema
Part
2:
Datatypes
Second
Edition]
.
In
the
case
of
the
pattern
facet
(which
applies
to
the
lexical
space
rather
than
the
value
space),
the
pattern
is
tested
against
the
canonical
lexical
representation
of
the
value,
as
defined
for
the
source
type
(or
the
result
of
casting
the
value
to
an
xs:string
,
in
the
case
of
types
that
have
no
canonical
lexical
representation
defined
for
them).
Note
that
this
will
cause
casts
to
fail
if
the
pattern
excludes
the
canonical
lexical
representation
of
the
source
type.
For
example,
if
the
type
my:distance
is
defined
as
a
restriction
of
xs:decimal
with
a
pattern
that
requires
two
digits
after
the
decimal
point,
casting
of
an
xs:integer
to
my:distance
will
always
fail,
because
the
canonical
representation
of
an
xs:integer
does
not
conform
to
this
pattern.
In
some
cases,
casting
from
a
parent
type
to
a
derived
type
requires
special
rules.
See
17.1.4
18.1.4
Casting
to
duration
types
for
rules
regarding
casting
to
xs:yearMonthDuration
and
xs:dayTimeDuration
.
See
17.4.1
18.4.1
Casting
to
xs:ENTITY
,
below,
for
casting
to
xs:ENTITY
and
types
derived
from
it.
[XML
Schema
Part
2:
Datatypes
Second
Edition]
says
that
"The
value
space
of
ENTITY
is
the
set
of
all
strings
that
match
the
NCName
production
...
and
have
been
declared
as
an
unparsed
entity
in
a
document
type
definition."
However,
[XSL
Transformations
(XSLT)
Version
2.0]
and
[XQuery
1.0:
An
XML
Query
Language]
do
not
check
that
constructed
values
of
type
xs:ENTITY
match
declared
unparsed
entities.
Thus,
this
rule
is
relaxed
in
this
specification
and,
in
casting
to
xs:ENTITY
and
types
derived
from
it,
no
check
is
made
that
the
values
correspond
to
declared
unparsed
entities.
When the ST and the TT are derived, directly or indirectly, from different primitive types, this is called casting across the type hierarchy. Casting across the type hierarchy is logically equivalent to three separate steps performed in order. Errors can occur in either of the latter two steps.
Cast
the
SV
,
up
the
hierarchy,
to
the
primitive
type
of
the
source,
as
described
in
17.3
18.3
Casting
from
derived
types
to
parent
types
.
If
SV
is
an
instance
of
xs:string
or
xs:untypedAtomic
,
check
its
value
against
the
pattern
facet
of
TT
,
and
raise
an
error
[
err:FORG0001
]
if
the
check
fails.
Cast
the
value
to
the
primitive
type
of
TT
,
as
described
in
17.1
18.1
Casting
from
primitive
types
to
primitive
types
.
If
TT
is
derived
from
xs:NOTATION
,
assume
for
the
purposes
of
this
rule
that
casting
to
xs:NOTATION
succeeds.
Cast
the
value
down
to
the
TT
,
as
described
in
17.4
18.4
Casting
within
a
branch
of
the
type
hierarchy
The error text provided with these errors is non-normative.
Unidentified error.
This error is raised whenever an attempt is made to divide by zero.
This error is raised whenever numeric operations result in an overflow or underflow.
This
error
is
raised
if
the
decimal
format
name
supplied
to
fn:format-number
is
not
a
valid
QName,
or
if
the
prefix
in
the
QName
is
undeclared,
or
if
there
is
no
decimal
format
in
the
static
context
with
a
matching
name.
This
error
is
raised
if
the
picture
string
supplied
to
fn:format-number
has
invalid
syntax.
This
error
is
raised
if
the
picture
string
supplied
to
fn:format-date
,
fn:format-time
,
or
fn:format-dateTime
has
invalid
syntax.
This
error
is
raised
if
the
picture
string
supplied
to
fn:format-date
selects
a
component
that
is
not
present
in
a
date,
or
if
the
picture
string
supplied
to
fn:format-time
selects
a
component
that
is
not
present
in
a
time.
This
appendix
summarizes
the
relationship
between
certain
functions
defined
in
[XML
Path
Language
(XPath)
Version
1.0]
and
the
corresponding
functions
defined
in
this
document.
The
first
column
of
the
table
provides
the
signature
of
functions
defined
in
this
document.
The
second
column
provides
the
signature
of
the
corresponding
function
in
[XML
Path
Language
(XPath)
Version
1.0]
.
The
third
column
discusses
describes
the
differences
in
the
semantics
of
the
corresponding
functions.
The
functions
appear
in
the
order
they
appear
in
[XML
Path
Language
(XPath)
Version
1.0]
.
The evaluation of the arguments to the functions defined in this document depends on whether the XPath 1.0 compatibility mode is on or off. See [XML Path Language (XPath) 2.0] . If the mode is on, the following conversions are applied, in order, before the argument value is passed to the function:
If
the
expected
type
is
a
single
item
or
an
optional
single
item,
(examples:
xs:string,
xs:string?,
xs:untypedAtomic,
xs:untypedAtomic?,
node(),
node()?,
item(),
item()?
),
then
the
given
value
V
is
effectively
replaced
by
fn:subsequence(V,
1,
1)
.
If
the
expected
type
is
xs:string
or
xs:string?
,
then
the
given
value
V
is
effectively
replaced
by
fn:string(V)
.
If
the
expected
type
is
numeric
or
optional
numeric,
then
the
given
value
V
is
effectively
replaced
by
fn:number(V)
.
Otherwise, the given value is unchanged.
XQuery 1.0 and XPath 2.0 | XPath 1.0 | Notes | |||||||
---|---|---|---|---|---|---|---|---|---|
fn:last
()
as
xs:integer
|
last()
=>
number
|
Precision of numeric results may be different. | |||||||
fn:position
()
as
xs:integer
|
position()
=>
number
|
Precision of numeric results may be different. | |||||||
fn:count
(
$arg
as
item*
)
as
xs:integer
|
count(node-set)
=>
number
|
Precision of numeric results may be different. | |||||||
fn:id
(
$arg
as
xs:string*
)
as
element()*
|
id(object)
=>
node-set
|
XPath 2.0 behavior is different for boolean and numeric arguments. The recognition of a node as an id value is sensitive to the manner in which the datamodel is constructed. In XPath 1.0 the whole string is treated as a unit. In XPath 2.0 each string is treated as a list. | |||||||
fn:local-name
()
as
xs:string
|
local-name(node-set?)
=>
string
|
If compatibility mode is off, an error will occur if argument has more than one node. | |||||||
fn:local-name
(
$arg
as
node()?
)
as
xs:string
|
|||||||||
fn:namespace-uri
()
as
xs:string
|
namespace-uri(node-set?)
=>
string
|
If compatibility mode is off, an error will occur if argument has more than one node. | |||||||
fn:namespace-uri
(
$arg
as
node?
)
as
xs:string
|
|||||||||
fn:name
(
$arg
as
node()?
)
as
xs:string
|
name(node-set?)
=>
string
|
If compatibility mode is off, an error will occur if argument has more than one node. The rules for determining the prefix are more precisely defined in [XML Path Language (XPath) 2.0] . Function is not "well-defined" for parentless attribute nodes. | |||||||
fn:string
()
as
xs:string
|
string(object)
=>
string
|
If compatibility mode is off, an error will occur if argument has more than one node. Representations of numeric values are XPath 1.0 compatible except for the special values positive and negative infinity, and for values outside the range 1.0e-6 to 1.0e+6. | |||||||
fn:string
(
$arg
as
item()?
)
as
xs:string
|
|||||||||
|
concat(string,
string,
string*)
=>
string
|
If compatibility mode is off, an error will occur if an argument has more than one node. If compatibility mode on, the first node in the sequence is used. | |||||||
fn:starts-with
(
$arg1
as
xs:string?
,
$arg2
as
xs:string?
)
as
xs:boolean
|
starts-with(string,
string)
=>
boolean
|
If compatibility mode is off, an error will occur if either argument has more than one node or is a number or a boolean. If compatibility mode is on, implicit conversion is performed. | |||||||
|
|||||||||
fn:contains
(
$arg1
as
xs:string?
,
$arg2
as
xs:string?
)
as
xs:boolean
|
contains(string,
string)
=>
boolean
|
If compatibility mode is off, an error will occur if either argument has more than one node or is a number or a boolean. If compatibility mode is on, implicit conversion is performed. | |||||||
|
|||||||||
fn:substring-before
(
$arg1
as
xs:string?
,
$arg2
as
xs:string?
)
as
xs:string
|
substring-before(string,
string)
=>
string
|
If compatibility mode is off, an error will occur if either argument has more than one node or is a number or a boolean. If compatibility mode is on, implicit conversion is performed. | |||||||
|
|||||||||
fn:substring-after
(
$arg1
as
xs:string?
,
$arg2
as
xs:string?
)
as
xs:string
|
substring-after(string,
string)
=>
string
|
If compatibility mode is off, an error will occur if either argument has more than one node or is a number or a boolean. If compatibility mode is on, implicit conversion is performed. | |||||||
|
|||||||||
|
substring(string,
number,
number?)
=>
string
|
If
compatibility
mode
is
off,
an
error
will
occur
if
$sourceString
has
more
than
one
node
or
is
a
number
or
a
boolean.
If
compatibility
mode
is
on,
implicit
conversion
is
performed.
|
|||||||
|
|||||||||
fn:string-length
(
$arg
as
xs:string?
)
as
xs:integer?
|
string-length(string?)
=>
number
|
If compatibility mode is off, numbers and booleans will give errors for first arg. Also, multiple nodes will give error. | |||||||
fn:string-length
()
as
xs:integer?
|
|||||||||
fn:normalize-space
(
$arg
as
xs:string?
)
as
xs:string
|
normalize-space(string?)
=>
string
|
If
compatibility
mode
is
off,
an
error
will
occur
if
$arg
has
more
than
one
node
or
is
a
number
or
a
boolean.
If
compatibility
mode
is
on,
implicit
conversion
is
performed.
|
|||||||
fn:normalize-space
()
as
xs:string
|
|||||||||
|
translate(string,
string,
string)=>
string
|
. | |||||||
fn:boolean
(
$arg
as
item()*
)
as
xs:boolean
|
boolean(object)
=>
boolean
|
||||||||
fn:not
(
$arg
as
item()*
)
as
xs:boolean
|
not(boolean)
=>
boolean
|
||||||||
fn:true
()
as
xs:boolean
|
true()
=>
boolean
|
||||||||
fn:false
()
as
xs:boolean
|
false()
=>
boolean
|
||||||||
fn:lang
(
$testlang
as
xs:string
)
as
xs:boolean
|
lang(string)
=>
boolean
|
If compatibility mode is off, numbers and booleans will give errors. Also, multiple nodes will give error. If compatibility mode is on, implicit conversion is performed. | |||||||
fn:number
()
as
xs:double
|
number(object?)
=>
number
|
Error if argument has more than one node when not in compatibility node. | |||||||
fn:number
(
$arg
as
xs:anyAtomicType?
)
as
xs:double
|
|||||||||
fn:sum
(
$arg
as
xs:anyAtomicType*
)
as
xs:anyAtomicType
|
sum(node-set)
=>
number
|
2.0
raises
an
error
if
sequence
contains
values
that
cannot
be
added
together
such
as
NMTOKENS
and
other
subtypes
of
string.
1.0
returns
NaN
.
|
|||||||
fn:floor
(
$arg
as
numeric?
)
as
numeric?
|
floor(number)=>
number
|
In
2.0,
if
argument
is
()
,
the
result
is
()
.
In
1.0,
the
result
is
NaN
.
If
compatibility
mode
is
off,
an
error
will
occur
with
more
than
one
node.
If
compatibility
mode
is
on,
implicit
conversion
is
performed.
|
|||||||
fn:ceiling
(
$arg
as
numeric?
)
as
numeric?
|
ceiling(number)=>
number
|
In
2.0,
if
argument
is
()
,
the
result
is
()
.
In
1.0,
the
result
is
NaN
.
If
compatibility
mode
is
off,
an
error
will
occur
with
more
than
one
node.
If
compatibility
mode
is
on,
implicit
conversion
is
performed.
|
|||||||
fn:round
(
$arg
as
numeric?
)
as
numeric?
|
round(number)=>
number
|
In
2.0,
if
argument
is
()
,
the
result
is
()
.
In
1.0,
the
result
is
NaN
.
If
compatibility
mode
is
off,
an
error
will
occur
with
more
than
one
node.
If
compatibility
mode
is
on,
implicit
conversion
is
performed.
|
Certain functions that were proposed for inclusion in this function library have been excluded on the basis that it is straightforward for users to implement these functions themselves using XSLT 2.0 or XQuery 1.0.
This Appendix provides sample implementations of some of these functions.
To emphasize that these functions are examples of functions that vendors may write, their names carry the prefix 'eg'. Vendors are free to define such functions in any namespace. A group of vendors may also choose to create a collection of such useful functions and put them in a common namespace.
In
some
situations,
users
may
want
to
provide
default
values
for
missing
information
that
may
be
signaled
by
elements
that
are
omitted,
have
no
value
or
have
the
empty
sequence
as
their
value.
For
example,
a
missing
middle
initial
may
be
indicated
by
omitting
the
element
or
a
non-existent
bonus
signaled
with
an
empty
sequence.
This
section
includes
examples
of
functions
that
provide
such
defaults.
These
functions
return
xs:anyAtomicType*
.
Users
may
want
to
write
functions
that
return
more
specific
types.
eg:if-empty
(
|
$node
|
as
node()?
,
|
$value
|
as
xs:anyAtomicType
)
as
xs:anyAtomicType*
|
If the first argument is the empty sequence or an element without simple or complex content, if-empty() returns the second argument; otherwise, it returns the content of the first argument.
XSLT implementation
<xsl:function name="eg:if-empty" as="xs:anyAtomicType*"> <xsl:param name="node" as="node()?"/> <xsl:param name="value" as="xs:anyAtomicType"/> <xsl:choose> <xsl:when test="$node and $node/child::node()"> <xsl:sequence select="fn:data($node)"/> </xsl:when> <xsl:otherwise> <xsl:sequence select="$value"/> </xsl:otherwise> </xsl:choose> </xsl:function>
XQuery implementation
declare function eg:if-empty ( $node as node()?, $value as xs:anyAtomicType) as xs:anyAtomicType* { if ($node and $node/child::node()) then fn:data($node) else $value }
eg:if-absent
(
|
$node
|
as
node()?
,
|
$value
|
as
xs:anyAtomicType
)
as
xs:anyAtomicType*
|
If the first argument is the empty sequence, if-absent() returns the second argument; otherwise, it returns the content of the first argument.
XSLT implementation
<xsl:function name="eg:if-absent"> <xsl:param name="node" as="node()?"/> <xsl:param name="value" as="xs:anyAtomicType"/> <xsl:choose> <xsl:when test="$node"> <xsl:sequence select="fn:data($node)"/> </xsl:when> <xsl:otherwise> <xsl:sequence select="$value"/> </xsl:otherwise> </xsl:choose> </xsl:function>
XQuery implementation
declare function eg:if-absent ( $node as node()?, $value as xs:anyAtomicType) as xs:anyAtomicType* { if ($node) then fn:data($node) else $value }
eg:value-union
(
|
$arg1
|
as
xs:anyAtomicType*
,
|
$arg2
|
as
xs:anyAtomicType*
)
as
xs:anyAtomicType*
|
This function returns a sequence containing all the distinct items in $arg1 and $arg2, in an undefined order.
XSLT implementation
xsl:function name="eg:value-union" as="xs:anyAtomicType*"> <xsl:param name="arg1" as="xs:anyAtomicType*"/> <xsl:param name="arg2" as="xs:anyAtomicType*"/> <xsl:sequence select="fn:distinct-values(($arg1, $arg2))"/> </xsl:function>
XQuery implementation
declare function eg:value-union ( $arg1 as xs:anyAtomicType*, $arg2 as xs:anyAtomicType*) as xs:anyAtomicType* { fn:distinct-values(($arg1, $arg2)) }
eg:value-intersect
(
|
$arg1
|
as
xs:anyAtomicType*
,
|
$arg2
|
as
xs:anyAtomicType*
)
as
xs:anyAtomicType*
|
This function returns a sequence containing all the distinct items that appear in both $arg1 and $arg2, in an undefined order.
XSLT implementation>
<xsl:function name="eg:value-intersect" as="xs:anyAtomicType*"> <xsl:param name="arg1" as="xs:anyAtomicType*"/> <xsl:param name="arg2" as="xs:anyAtomicType*"/> <xsl:sequence select="fn:distinct-values($arg1[.=$arg2])"/> </xsl:function>
XQuery implementation
declare function eg:value-intersect ( $arg1 as xs:anyAtomicType*, $arg2 as xs:anyAtomicType* ) as xs:anyAtomicType* { fn:distinct-values($arg1[.=$arg2]) }
eg:value-except
(
|
$arg1
|
as
xs:anyAtomicType*
,
|
$arg2
|
as
xs:anyAtomicType*
)
as
xs:anyAtomicType*
|
This function returns a sequence containing all the distinct items that appear in $arg1 but not in $arg2, in an undefined order.
XSLT implementation
<xsl:function name="eg:value-except" as="xs:anyAtomicType*"> <xsl:param name="arg1" as="xs:anyAtomicType*"/> <xsl:param name="arg2" as="xs:anyAtomicType*"/> <xsl:sequence select="fn:distinct-values($arg1[not(.=$arg2)])"/> </xsl:function>
XQuery implementation
declare function eg:value-except ( $arg1 as xs:anyAtomicType*, $arg2 as xs:anyAtomicType*) as xs:anyAtomicType* { fn:distinct-values($arg1[not(.=$arg2)]) }
eg:index-of-node
(
$seqParam
as
node()*
,
$srchParam
as
node()
)
as
xs:integer*
This
function
returns
a
sequence
of
positive
integers
giving
the
positions
within
the
sequence
$seqParam
of
nodes
that
are
identical
to
$srchParam
.
The
nodes
in
the
sequence
$seqParam
are
compared
with
$srchParam
under
the
rules
for
the
is
operator.
If
a
node
compares
identical,
then
the
position
of
that
node
in
the
sequence
$srchParam
is
included
in
the
result.
If
the
value
of
$seqParam
is
the
empty
sequence,
or
if
no
node
in
$seqParam
matches
$srchParam,
then
the
empty
sequence
is
returned.
The index is 1-based, not 0-based.
The result sequence is in ascending numeric order.
XSLT implementation
<xsl:function name="eg:index-of-node" as="xs:integer*"> <xsl:param name="sequence" as="node()*"/> <xsl:param name="srch" as="node()"/> <xsl:for-each select="$sequence"> <xsl:if test=". is $srch"> <xsl:sequence select="position()"/> </xsl:if> </xsl:for-each> </xsl:function>
XQuery implementation
declare function eg:index-of-node($sequence as node()*, $srch as node()) as xs:integer* { for $n at $i in $sequence where ($n is $srch) return $i }
eg:string-pad
(
$padString
as
xs:string?
,
$padCount
as
xs:integer
)
as
xs:string
Returns
a
xs:string
consisting
of
a
given
number
of
copies
of
an
xs:string
argument
concatenated
together.
XSLT implementation
<xsl:function name="eg:string-pad" as="xs:string"> <xsl:param name="padString" as="xs:string?"/> <xsl:param name="padCount" as="xs:integer"/> <xsl:sequence select="fn:string-join((for $i in 1 to $padCount return $padString), '')"/> </xsl:function>
XQuery implementation
declare function eg:string-pad ( $padString as xs:string?, $padCount as xs:integer) as xs:string { fn:string-join((for $i in 1 to $padCount return $padString), "") }
This
returns
the
zero-length
string
if
$padString
is
the
empty
sequence,
which
is
consistent
with
the
general
principle
that
if
an
xs:string
argument
is
the
empty
sequence
it
is
treated
as
if
it
were
the
zero-length
string.
fn:eg:distinct-nodes-stable
(
$arg
as
node()*
)
as
node()*
This function illustrates one possible implementation of a distinct-nodes function. It removes duplicate nodes by identity, preserving the first occurrence of each node.
XPath
$arg[empty(subsequence($arg, 1, position()-1) intersect .)]
XSLT implementation
<xsl:function name="eg:distinct-nodes-stable" as="node()*"> <xsl:param name="arg" as="node()*"/> <xsl:sequence select="$arg[empty(subsequence($arg, 1, position()-1) intersect .)]"/> </xsl:function>
XQuery implementation
declare function distinct-nodes-stable ($arg as node()*) as node()* { for $a at $apos in $arg let $before_a := fn:subsequence($arg, 1, $apos - 1) where every $ba in $before_a satisfies not($ba is $a) return $a }
This appendix provides a summary of features defined in this specification whose effect is explicitly · implementation-defined · . The conformance rules require vendors to provide documentation that explains how these choices have been exercised.
Editorial note | |
This list is incomplete in this working draft. |
The
destination
of
the
trace
output
is
·
implementation-defined
·
.
See
4
The
Trace
Function
3.2.1
fn:trace
.
For
xs:integer
operations,
implementations
that
support
limited-precision
integer
operations
·
must
·
either
raise
an
error
[
err:FOAR0002
]
or
provide
an
·
implementation-defined
·
mechanism
that
allows
users
to
choose
between
raising
an
error
and
returning
a
result
that
is
modulo
the
largest
representable
integer
value.
See
6.2
4.2
Arithmetic
Operators
on
Numeric
Values
.
For
xs:decimal
values
the
number
of
digits
of
precision
returned
by
the
numeric
operators
is
·
implementation-defined
·
.
See
6.2
4.2
Arithmetic
Operators
on
Numeric
Values
.
See
also
17.1.3.3
18.1.3.3
Casting
to
xs:decimal
and
17.1.3.4
18.1.3.4
Casting
to
xs:integer
If
the
number
of
digits
in
the
result
of
a
numeric
operation
exceeds
the
number
of
digits
that
the
implementation
supports,
the
result
is
truncated
or
rounded
in
an
·
implementation-defined
·
manner.
See
6.2
4.2
Arithmetic
Operators
on
Numeric
Values
.
See
also
17.1.3.3
18.1.3.3
Casting
to
xs:decimal
and
17.1.3.4
18.1.3.4
Casting
to
xs:integer
It
is
·
implementation-defined
·
which
version
of
Unicode
is
supported
by
the
features
defined
in
this
specification,
but
it
is
recommended
that
the
most
recent
version
of
Unicode
be
used.
See
7.1
5.1
String
Types
.
For
7.4.6
5.4.6
fn:normalize-unicode
,
conforming
implementations
·
must
·
support
normalization
form
"NFC"
and
·
may
·
support
normalization
forms
"NFD",
"NFKC",
"NFKD",
"FULLY-NORMALIZED".
They
·
may
·
also
support
other
normalization
forms
with
·
implementation-defined
·
semantics.
The
ability
to
decompose
strings
into
collation
units
suitable
for
substring
matching
is
an
·
implementation-defined
·
property
of
a
collation.
See
7.5
5.5
Functions
Based
on
Substring
Matching
.
All
minimally
conforming
processors
·
must
·
support
year
values
with
a
minimum
of
4
digits
(i.e.,
YYYY)
and
a
minimum
fractional
second
precision
of
1
millisecond
or
three
digits
(i.e.,
s.sss).
However,
conforming
processors
·
may
·
set
larger
·
implementation-defined
·
limits
on
the
maximum
number
of
digits
they
support
in
these
two
situations.
See
10.1.1
9.1.1
Limits
and
Precision
.
The
result
of
casting
a
string
to
xs:decimal
,
when
the
resulting
value
is
not
too
large
or
too
small
but
nevertheless
has
too
many
decimal
digits
to
be
accurately
represented,
is
implementation-defined.
See
17.1.1
18.1.1
Casting
from
xs:string
and
xs:untypedAtomic
.
Various
aspects
of
the
processing
provided
by
15.5.4
14.5.5
fn:doc
are
·
implementation-defined
·
.
Implementations
may
provide
external
configuration
options
that
allow
any
aspect
of
the
processing
to
be
controlled
by
the
user.
The
manner
in
which
implementations
provide
options
to
weaken
the
·
stable
·
characteristic
of
15.5.6
14.5.7
fn:collection
and
15.5.4
14.5.5
fn:doc
are
·
implementation-defined
·
.
The
following
changes
have
been
made
since
the
first
edition
of
the
Functions
and
Operators
by
Section
2
Accessors
2.1
fn:node-name
specification
for
XPath
2.0
and
XQuery
1.0
published
on
23
January
2007:
Errata E1 through E47 have been applied.
A
two-argument
version
of
the
fn:node-name
fn:round
(
$arg
function
has
been
introduced.
(Bugzilla
6240)
A
single-argument
version
of
the
function
has
been
introduced.
as
fn:string-join
Specifications
for
the
functions
,
node()?
)
as
fn:format-date
xs:QName?
fn:format-time
2.2
fn:nilled
,
and
fn:nilled
fn:format-dateTime
(
$arg
have
been
transferred
from
the
XSLT
2.0
specification.
The
specification
of
as
fn:format-number
node()?
)
as
has
been
transferred
from
the
XSLT
specification.
A
function
xs:boolean?
fn:format-integer
2.3
fn:string
is
introduced.
The
function
fn:string
fn:generate-id
()
as
is
introduced,
transferred
from
the
XSLT
specification.
A range of trigonometric functions is defined (in a new namespace).
New
functions
and
xs:string
fn:parse
fn:string
fn:serialize
(
$arg
are
defined.
A
new
function
is
defined.
as
fn:analyze-string
The syntax of regular expressions is extended to allow non-capturing groups.
A
new
flag
is
introduced
for
the
item()?
$flags
)
argument
of
functions
that
use
regular
expressions:
the
flag
causes
all
characters
in
a
regular
expression
to
be
treated
as
ordinary
characters
rather
than
metacharacters.
as
q
Supporting the new language feature of higher-order functions, a number of functions are defined that operate on function items as their arguments.
The
description
of
the
function
has
been
rewritten
to
allow
for
the
introduction
of
try/catch
facilities
into
XQuery
and
XSLT.
xs:string
fn:error
The section describing what it means for functions to be contextual and/or stable has been rewritten.
The following editorial changes have been made since the first edition of the Functions and Operators specification for XPath 2.0 and XQuery 1.0 published on 23 January 2007. These are not explicitly marked in the change-highlighted version of the specification:
A quick reference section containing links to the functions has been added before the full table of contents.
The section on constructor functions has been moved so that it is now adjacent to the closely-related section on casting.
The
function
fn:data
fn:dateTime
(
$arg
has
been
moved
out
of
the
section
describing
constructor
functions,
and
is
no
longer
described
as
"a
special
constructor
function".
It
is
now
an
ordinary
function
described
in
the
appropriate
section
along
with
other
functions
on
dates
and
times.
This
allows
the
term
"constructor
function"
to
be
associated
exclusively
with
single-argument
functions
whose
name
is
the
same
as
the
type
name
of
the
value
that
they
return,
and
avoids
any
suggestion
that
this
function
has
special
behavior.
Similarly,
the
functions
as
fn:true
item()*
)
as
and
xs:anyAtomicType*
fn:false
2.5
fn:base-uri
are
no
longer
described
as
constructor
functions.
Where
a
function
is
referred
to
by
name,
the
reference
is
now
always
in
the
form
(for
example)
fn:base-uri
()
as
xs:anyURI?
rather
than
fn:base-uri
fn:base-uri()
(
.
The
latter
form
is
used
only
to
indicate
a
call
on
the
function
in
which
no
arguments
are
supplied.
The specification of each function now consists of a set of standard subsections: Summary, Operator Mapping, Signature, Rules, Error Conditions, Notes, and Examples.
The "Summary" of the effect of each function is now just that: it never contains any information that cannot be found in the more detailed rules, and it does not attempt to list unusual or error conditions. Such rules have been moved into separate paragraphs. Sometimes the language used in the summary is relatively informal. Although the summary remains normative, it must be regarded as being subservient to the rules that follow.
Functions are always called , never invoked .
The specification no longer discusses functions, it now specifies or defines them.
Rules
have
been
rewritten
in
a
more
consistent
style:
"If
$arg
is
X,
the
function
returns
Y"
(avoiding
alternatives
such
as
"Returns
Y
if
is
X",
and
avoiding
the
passive
"is
returned").
as
$arg
The section heading for a section that defines a function is now always the name of the function. Some function definitions have been moved into subsections to achieve this.
Statements
within
the
rules
of
a
function
that
follow
inevitably
from
other
rules
have
in
many
cases
been
downgraded
to
notes.
An
example
is
the
statement
that
node()?
remove($seq,
N)
)
returns
an
empty
sequence
if
is
an
empty
sequence.
as
$seq
The functions for durations and those for dates/times have been split into separate sections.
The
xs:anyURI?
fn:boolean
2.6
fn:document-uri
function
has
been
moved
from
"General
Functions
and
Operators
on
Sequences"
to
"Functions
on
Boolean
Values".
In
the
interests
of
automating
the
testing
of
examples,
the
convention
has
been
adopted
that
the
result
of
an
example
expression
is
wherever
possible
given
in
the
form
of
a
simple
but
legal
XPath
expression.
Specifically
a
numeric
or
string
literal
is
used
for
numbers
and
strings;
the
expressions
fn:document-uri
true()
(
and
for
booleans;
constructors
such
as
$arg
false()
for
other
atomic
types;
expressions
such
as
as
xs:duration('PT0S')
node()?
(1,
2,
3,
4)
)
for
sequences.
The
expression
will
always
return
a
value
of
the
correct
type;
so
the
value
zero
is
shown
as
as
xs:double
,
not
as
xs:anyURI?
0.0e0
0
,
which
is
the
way
the
value
would
be
serialized
on
output.
The
value
NaN
is
given
as
xs:double('NaN')
.
Previously
results
were
sometimes
given
in
this
form,
sometimes
in
the
form
of
a
serialization
of
the
result
value,
and
sometimes
(particularly
for
dates,
times,
and
durations)
in
the
form
of
an
informal
description.
In
some
cases
where
one
function
can
be
readily
specified
in
terms
of
another,
the
opportunity
has
been
taken
to
simplify
the
specification.
For
example,
all
the
operator
support
functions
of
the
form
op:xx-greater-than
are
now
specified
by
reference
to
the
corresponding
op:xx-less-than
function
with
the
arguments
reversed.
This
reduces
the
risk
of
introducing
errors
and
inconsistencies.
In some cases, the rules for a function have been reordered. For example, the rule describing how an empty sequence is handled now generally comes before any rule that works only if the argument is not an empty sequence.
Some non-normative examples and notes have been added.
fn:error
(
$error
$code
as
xs:QName?
,
$description
as
xs:string
,
$error-object
as
item()*
)
as
none
fn:format-integer
(
$value
as
xs:integer?
,
$picture
as
xs:string
,
$language
as
xs:language
)
as
xs:string
fn:format-number
(
$value
as
numeric?
,
$picture
as
xs:string
,
$decimal-format-name
as
xs:string
)
as
xs:string
fn:compare
(
$comparand1
as
xs:string?
,
$comparand2
as
xs:string?
,
$collation
as
xs:string
)
as
xs:integer?
fn:substring
(
$sourceString
as
xs:string?
,
$startingLoc
$start
as
xs:double
,
$length
as
xs:double
)
as
xs:string
fn:translate
(
$arg
as
xs:string?
,
$mapString
as
xs:string
,
$transString
as
xs:string
)
as
xs:string
fn:starts-with
(
$arg1
as
xs:string?
,
$arg2
as
xs:string?
,
$collation
as
xs:string
)
as
xs:boolean
fn:substring-before
(
$arg1
as
xs:string?
,
$arg2
as
xs:string?
,
$collation
as
xs:string
)
as
xs:string
fn:substring-after
(
$arg1
as
xs:string?
,
$arg2
as
xs:string?
,
$collation
as
xs:string
)
as
xs: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
fn:resolve-uri
fn:analyze-string
(
$relative
$input
as
xs:string?
,
$pattern
as
xs:string
)
as
xs:anyURI?
element(fn:analyze-string-result)
fn:resolve-uri
fn:analyze-string
(
$relative
$input
as
xs:string?
,
$base
$pattern
as
xs:string
,
$flags
as
xs:string
)
as
xs:anyURI?
element(fn:analyze-string-result)
op:yearMonthDuration-less-than
(
$arg1
as
xs:yearMonthDuration
,
$arg2
as
xs:yearMonthDuration
)
as
xs:boolean
op:yearMonthDuration-greater-than
(
$arg1
as
xs:yearMonthDuration
,
$arg2
as
xs:yearMonthDuration
)
as
xs:boolean
op:dayTimeDuration-less-than
(
$arg1
as
xs:dayTimeDuration
,
$arg2
as
xs:dayTimeDuration
)
as
xs:boolean
op:dayTimeDuration-greater-than
(
$arg1
as
xs:dayTimeDuration
,
$arg2
as
xs:dayTimeDuration
)
as
xs:boolean
op:dateTime-equal
fn:years-from-duration
(
$arg1
as
xs:dateTime
,
$arg2
$arg
as
xs:dateTime
xs:duration?
)
as
xs:boolean
xs:integer?
op:dateTime-less-than
fn:months-from-duration
(
$arg1
as
xs:dateTime
,
$arg2
$arg
as
xs:dateTime
xs:duration?
)
as
xs:boolean
xs:integer?
op:dateTime-greater-than
fn:days-from-duration
(
$arg1
$arg
as
xs:dateTime
,
xs:duration?
)
$arg2
as
xs:integer?
op:date-equal
fn:minutes-from-duration
(
$arg1
$arg
as
xs:date
,
xs:duration?
)
$arg2
as
xs:integer?
op:date-less-than
op:add-yearMonthDurations
(
$arg1
as
xs:date
xs:yearMonthDuration
,
$arg2
as
xs:date
xs:yearMonthDuration
)
as
xs:boolean
xs:yearMonthDuration
op:date-greater-than
op:subtract-yearMonthDurations
(
$arg1
as
xs:date
xs:yearMonthDuration
,
$arg2
as
xs:date
xs:yearMonthDuration
)
as
xs:boolean
xs:yearMonthDuration
op:time-equal
op:multiply-yearMonthDuration
(
$arg1
as
xs:time
xs:yearMonthDuration
,
$arg2
as
xs:time
xs:double
)
as
xs:boolean
xs:yearMonthDuration
op:time-less-than
op:divide-yearMonthDuration
(
$arg1
as
xs:time
xs:yearMonthDuration
,
$arg2
as
xs:time
xs:double
)
as
xs:boolean
xs:yearMonthDuration
op:time-greater-than
op:divide-yearMonthDuration-by-yearMonthDuration
(
$arg1
as
xs:time
xs:yearMonthDuration
,
$arg2
as
xs:time
xs:yearMonthDuration
)
as
xs:boolean
xs:decimal
op:gYearMonth-equal
op:add-dayTimeDurations
(
$arg1
as
xs:gYearMonth
xs:dayTimeDuration
,
$arg2
as
xs:gYearMonth
xs:dayTimeDuration
)
as
xs:boolean
xs:dayTimeDuration
op:gYear-equal
op:subtract-dayTimeDurations
(
$arg1
as
xs:gYear
xs:dayTimeDuration
,
$arg2
as
xs:gYear
xs:dayTimeDuration
)
as
xs:boolean
xs:dayTimeDuration
op:gMonthDay-equal
op:multiply-dayTimeDuration
(
$arg1
as
xs:gMonthDay
xs:dayTimeDuration
,
$arg2
as
xs:gMonthDay
xs:double
)
as
xs:boolean
xs:dayTimeDuration
op:gMonth-equal
op:divide-dayTimeDuration
(
$arg1
as
xs:gMonth
xs:dayTimeDuration
,
$arg2
as
xs:gMonth
xs:double
)
as
xs:boolean
xs:dayTimeDuration
op:gDay-equal
op:divide-dayTimeDuration-by-dayTimeDuration
(
$arg1
as
xs:gDay
xs:dayTimeDuration
,
$arg2
as
xs:gDay
xs:dayTimeDuration
)
as
xs:boolean
xs:decimal
fn:years-from-duration
fn:dateTime
(
$arg
$arg1
as
xs:duration?
)
as
xs:integer?
fn:months-from-duration
(
xs:date?
,
$arg
$arg2
as
xs:duration?
xs:time?
)
as
xs:integer?
xs:dateTime?
fn:days-from-duration
op:dateTime-equal
(
$arg
$arg1
as
xs:duration?
xs:dateTime
,
$arg2
as
xs:dateTime
)
as
xs:integer?
xs:boolean
fn:hours-from-duration
op:dateTime-less-than
(
$arg
$arg1
as
xs:duration?
xs:dateTime
,
$arg2
as
xs:dateTime
)
as
xs:integer?
xs:boolean
fn:minutes-from-duration
op:dateTime-greater-than
(
$arg
$arg1
as
xs:duration?
xs:dateTime
,
$arg2
as
xs:dateTime
)
as
xs:integer?
xs:boolean
fn:seconds-from-duration
op:date-equal
(
$arg
$arg1
as
xs:duration?
xs:date
,
$arg2
as
xs:date
)
as
xs:decimal?
xs:boolean
fn:year-from-dateTime
op:date-less-than
(
$arg
$arg1
as
xs:dateTime?
xs:date
,
$arg2
as
xs:date
)
as
xs:integer?
xs:boolean
fn:month-from-dateTime
op:date-greater-than
(
$arg
$arg1
as
xs:dateTime?
xs:date
,
$arg2
as
xs:date
)
as
xs:integer?
xs:boolean
fn:day-from-dateTime
op:time-equal
(
$arg
$arg1
as
xs:dateTime?
xs:time
,
$arg2
as
xs:time
)
as
xs:integer?
xs:boolean
fn:hours-from-dateTime
op:time-less-than
(
$arg
$arg1
as
xs:dateTime?
xs:time
,
$arg2
as
xs:time
)
as
xs:integer?
xs:boolean
fn:minutes-from-dateTime
op:time-greater-than
(
$arg
$arg1
as
xs:dateTime?
xs:time
,
$arg2
as
xs:time
)
as
xs:integer?
xs:boolean
fn:seconds-from-dateTime
op:gYearMonth-equal
(
$arg
$arg1
as
xs:dateTime?
xs:gYearMonth
,
$arg2
as
xs:gYearMonth
)
as
xs:decimal?
xs:boolean
fn:timezone-from-dateTime
op:gYear-equal
(
$arg
$arg1
as
xs:dateTime?
xs:gYear
,
$arg2
as
xs:gYear
)
as
xs:dayTimeDuration?
xs:boolean
fn:year-from-date
op:gMonthDay-equal
(
$arg
$arg1
as
xs:date?
xs:gMonthDay
,
$arg2
as
xs:gMonthDay
)
as
xs:integer?
xs:boolean
fn:month-from-date
op:gMonth-equal
(
$arg
$arg1
as
xs:date?
xs:gMonth
,
$arg2
as
xs:gMonth
)
as
xs:integer?
xs:boolean
fn:day-from-date
op:gDay-equal
(
$arg
$arg1
as
xs:date?
xs:gDay
,
$arg2
as
xs:gDay
)
as
xs:integer?
xs:boolean
fn:timezone-from-date
fn:year-from-dateTime
(
$arg
as
xs:date?
xs:dateTime?
)
as
xs:dayTimeDuration?
xs:integer?
fn:seconds-from-time
fn:hours-from-dateTime
(
$arg
as
xs:time?
xs:dateTime?
)
as
xs:decimal?
xs:integer?
fn:timezone-from-time
fn:minutes-from-dateTime
(
$arg
as
xs:time?
xs:dateTime?
)
as
xs:dayTimeDuration?
xs:integer?
op:add-yearMonthDurations
fn:seconds-from-dateTime
(
$arg1
as
xs:yearMonthDuration
,
$arg2
$arg
as
xs:yearMonthDuration
xs:dateTime?
)
as
xs:yearMonthDuration
xs:decimal?
op:subtract-yearMonthDurations
fn:timezone-from-dateTime
(
$arg1
as
xs:yearMonthDuration
,
$arg2
$arg
as
xs:yearMonthDuration
xs:dateTime?
)
as
xs:yearMonthDuration
xs:dayTimeDuration?
op:multiply-yearMonthDuration
fn:year-from-date
(
$arg1
as
xs:yearMonthDuration
,
$arg2
$arg
as
xs:double
xs:date?
)
as
xs:yearMonthDuration
xs:integer?
op:divide-yearMonthDuration
fn:month-from-date
(
$arg1
as
xs:yearMonthDuration
,
$arg2
$arg
as
xs:double
xs:date?
)
as
xs:yearMonthDuration
xs:integer?
op:divide-yearMonthDuration-by-yearMonthDuration
fn:day-from-date
(
$arg1
as
xs:yearMonthDuration
,
$arg2
$arg
as
xs:yearMonthDuration
xs:date?
)
as
xs:decimal
xs:integer?
op:add-dayTimeDurations
fn:timezone-from-date
(
$arg1
as
xs:dayTimeDuration
,
$arg2
$arg
as
xs:dayTimeDuration
xs:date?
)
as
xs:dayTimeDuration
xs:dayTimeDuration?
op:subtract-dayTimeDurations
fn:hours-from-time
(
$arg1
as
xs:dayTimeDuration
,
$arg2
$arg
as
xs:dayTimeDuration
xs:time?
)
as
xs:dayTimeDuration
xs:integer?
op:multiply-dayTimeDuration
fn:minutes-from-time
(
$arg1
as
xs:dayTimeDuration
,
$arg2
$arg
as
xs:double
xs:time?
)
as
xs:dayTimeDuration
xs:integer?
op:divide-dayTimeDuration
fn:seconds-from-time
(
$arg1
as
xs:dayTimeDuration
,
$arg2
$arg
as
xs:double
xs:time?
)
as
xs:dayTimeDuration
xs:decimal?
op:divide-dayTimeDuration-by-dayTimeDuration
fn:timezone-from-time
(
$arg1
as
xs:dayTimeDuration
,
$arg2
$arg
as
xs:dayTimeDuration
xs:time?
)
as
xs:decimal
xs:dayTimeDuration?
fn:adjust-dateTime-to-timezone
(
$arg
as
xs:dateTime?
,
$timezone
as
xs:dayTimeDuration?
)
as
xs:dateTime?
xs:dateTime
op:subtract-dateTimes
(
$arg1
as
xs:dateTime
,
$arg2
as
xs:dateTime
)
as
xs:dayTimeDuration?
xs:dayTimeDuration
op:add-yearMonthDuration-to-dateTime
(
$arg1
as
xs:dateTime
,
$arg2
as
xs:yearMonthDuration
)
as
xs:dateTime
op:add-dayTimeDuration-to-dateTime
(
$arg1
as
xs:dateTime
,
$arg2
as
xs:dayTimeDuration
)
as
xs:dateTime
op:subtract-yearMonthDuration-from-dateTime
(
$arg1
as
xs:dateTime
,
$arg2
as
xs:yearMonthDuration
)
as
xs:dateTime
op:subtract-dayTimeDuration-from-dateTime
(
$arg1
as
xs:dateTime
,
$arg2
as
xs:dayTimeDuration
)
as
xs:dateTime
op:subtract-yearMonthDuration-from-date
(
$arg1
as
xs:date
,
$arg2
as
xs:yearMonthDuration
)
as
xs:date
fn:resolve-QName
fn:format-dateTime
(
$qname
$value
as
xs:string?
xs:dateTime?
,
$element
$picture
as
element()
)
xs:string
,
as
$language
xs:QName?
as
fn:QName
(
xs:string?
,
$paramURI
$calendar
as
xs:string?
,
$paramQName
$country
as
xs:string
xs:string?
)
as
xs:QName
xs:string?
op:QName-equal
fn:format-dateTime
(
$arg1
$value
as
xs:QName
xs:dateTime?
,
$arg2
$picture
as
xs:QName
xs:string
)
as
xs:boolean
xs:string?
fn:prefix-from-QName
fn:format-date
(
$arg
$value
as
xs:QName?
)
xs:date?
,
as
$picture
xs:NCName?
as
fn:local-name-from-QName
(
xs:string
,
$arg
$language
as
xs:QName?
)
xs:string?
,
as
$calendar
xs:NCName?
as
fn:namespace-uri-from-QName
(
xs:string?
,
$arg
$country
as
xs:QName?
xs:string?
)
as
xs:anyURI?
xs:string?
fn:namespace-uri-for-prefix
fn:format-date
(
$prefix
$value
as
xs:string?
xs:date?
,
$element
$picture
as
element()
xs:string
)
as
xs:anyURI?
xs:string?
fn:in-scope-prefixes
fn:format-time
(
$element
$value
as
element()
xs:time?
,
$picture
as
xs:string*
xs:string
,
$language
op:hexBinary-equal
as
$value1
xs:string?
,
$calendar
as
xs:hexBinary
xs:string?
,
$value2
$country
as
xs:hexBinary
xs:string?
)
as
xs:boolean
xs:string?
op:base64Binary-equal
fn:format-time
(
$value1
$value
as
xs:base64Binary
xs:time?
,
$value2
$picture
as
xs:base64Binary
xs:string
)
as
xs:boolean
xs:string?
op:NOTATION-equal
fn:resolve-QName
(
$arg1
$qname
as
xs:NOTATION
xs:string?
,
$arg2
$element
as
xs:NOTATION
element()
)
as
xs:boolean
xs:QName?
fn:name
fn:QName
as
$paramURI
xs:string
as
fn:name
(
xs:string?
,
$arg
$paramQName
as
node()?
xs:string
)
as
xs:string
xs:QName
fn:local-name
op:QName-equal
(
$arg
$arg1
as
node()?
)
xs:QName
,
as
$arg2
xs:string
as
fn:namespace-uri
xs:QName
as
xs:anyURI
xs:boolean
fn:namespace-uri
fn:prefix-from-QName
(
$arg
as
node()?
xs:QName?
)
as
xs:anyURI
14.4
fn:number
fn:number
()
as
xs:double
xs:NCName?
fn:lang
fn:namespace-uri-from-QName
(
$testlang
$arg
as
xs:string?
xs:QName?
)
as
xs:boolean
xs:anyURI?
fn:lang
fn:namespace-uri-for-prefix
(
$testlang
$prefix
as
xs:string?
,
$node
$element
as
node()
element()
)
as
xs:boolean
xs:anyURI?
op:is-same-node
fn:in-scope-prefixes
(
$parameter1
as
node()
,
$parameter2
$element
as
node()
element()
)
as
xs:boolean
xs:string*
op:node-before
op:hexBinary-equal
(
$parameter1
$value1
as
node()
xs:hexBinary
,
$parameter2
$value2
as
node()
xs:hexBinary
)
as
xs:boolean
op:node-after
op:base64Binary-equal
(
$parameter1
$value1
as
node()
xs:base64Binary
,
$parameter2
$value2
as
node()
xs:base64Binary
)
as
xs:boolean
op:concatenate
(
$seq1
as
item()*
,
$seq2
as
item()*
)
as
item()*
fn:index-of
fn:distinct-values
(
$seqParam
$arg
as
xs:anyAtomicType*
,
$srchParam
as
xs:anyAtomicType
)
as
xs:integer*
xs:anyAtomicType*
fn:index-of
fn:distinct-values
(
$seqParam
$arg
as
xs:anyAtomicType*
,
$srchParam
as
xs:anyAtomicType
,
$collation
as
xs:string
)
as
xs:integer*
xs:anyAtomicType*
fn:distinct-values
fn:index-of
(
$arg
$seqArg
as
xs:anyAtomicType*
,
$searchArg
as
xs:anyAtomicType
)
as
xs:anyAtomicType*
xs:integer*
fn:distinct-values
fn:index-of
(
$arg
$seqArg
as
xs:anyAtomicType*
,
$searchArg
as
xs:anyAtomicType
,
$collation
as
xs:string
)
as
xs:anyAtomicType*
xs:integer*
fn:subsequence
(
$sourceSeq
as
item()*
,
$startingLoc
as
xs:double
,
$length
as
xs:double
)
as
item()*
fn:deep-equal
(
$parameter1
as
item()*
,
$parameter2
as
item()*
,
$collation
as
string
xs:string
)
as
xs:boolean
fn:implicit-timezone
fn:parse
$arg
as
xs:dayTimeDuration
xs:string
,
$baseURI
as
xs:string
)
as
document-node(element(*,
xs:untyped))
op:add-dayTimeDuration-to-date
(
$arg1
as
xs:date
,
$arg2
as
xs:dayTimeDuration
)
as
xs:date
(§
op:add-dayTimeDuration-to-dateTime
(
$arg1
as
xs:dateTime
,
$arg2
as
xs:dayTimeDuration
)
as
xs:dateTime
(§
op:add-dayTimeDuration-to-time
(
$arg1
as
xs:time
,
$arg2
as
xs:dayTimeDuration
)
as
xs:time
(§
op:add-dayTimeDurations
(
$arg1
as
xs:dayTimeDuration
,
$arg2
as
xs:dayTimeDuration
)
as
xs:dayTimeDuration
(§
op:add-yearMonthDuration-to-date
(
$arg1
as
xs:date
,
$arg2
as
xs:yearMonthDuration
)
as
xs:date
(§
op:add-yearMonthDuration-to-dateTime
(
$arg1
as
xs:dateTime
,
$arg2
as
xs:yearMonthDuration
)
as
xs:dateTime
(§
op:add-yearMonthDurations
(
$arg1
as
xs:yearMonthDuration
,
$arg2
as
xs:yearMonthDuration
)
as
xs:yearMonthDuration
(§
fn:adjust-date-to-timezone
(
$arg
as
xs:date?
,
$timezone
as
xs:dayTimeDuration?
)
as
xs:date?
(§
fn:adjust-dateTime-to-timezone
(
$arg
as
xs:dateTime?
)
as
xs:dateTime?
xs:dateTime
(§
fn:adjust-dateTime-to-timezone
(
$arg
as
xs:dateTime?
,
$timezone
as
xs:dayTimeDuration?
)
as
xs:dateTime?
xs:dateTime
(§
fn:adjust-time-to-timezone
(
$arg
as
xs:time?
,
$timezone
as
xs:dayTimeDuration?
)
as
xs:time?
(§
fn:analyze-string
(
$input
as
xs:string?
,
$pattern
as
xs:string
)
as
element(fn:analyze-string-result)
(§
5.6.5
)
fn:analyze-string
(
$input
as
xs:string?
,
$pattern
as
xs:string
,
$flags
as
xs:string
)
as
element(fn:analyze-string-result)
(§
5.6.5
)
op:base64Binary-equal
(
$value1
as
xs:base64Binary
,
$value2
as
xs:base64Binary
)
as
xs:boolean
(§
op:boolean-greater-than
(
$arg1
as
xs:boolean
,
$arg2
as
xs:boolean
)
as
xs:boolean
(§
fn:codepoint-equal
(
$comparand1
as
xs:string?
,
$comparand2
as
xs:string?
)
as
xs:boolean?
(§
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?
(§
fn:concat
(
$arg1
as
xs:anyAtomicType?
,
$arg2
as
xs:anyAtomicType?
,
...
)
as
xs:string
(§
fn:contains
(
$arg1
as
xs:string?
,
$arg2
as
xs:string?
,
$collation
as
xs:string
)
as
xs:boolean
(§
op:dateTime-greater-than
(
$arg1
as
xs:dateTime
,
$arg2
as
xs:dateTime
)
as
xs:boolean
(§
op:dateTime-less-than
(
$arg1
as
xs:dateTime
,
$arg2
as
xs:dateTime
)
as
xs:boolean
(§
fn:days-from-duration
op:dayTimeDuration-greater-than
(
$arg
$arg1
as
xs:duration?
xs:dayTimeDuration
,
$arg2
as
xs:dayTimeDuration
)
as
xs:integer?
xs:boolean
(§
op:dayTimeDuration-greater-than
op:dayTimeDuration-less-than
(
$arg1
as
xs:dayTimeDuration
,
$arg2
as
xs:dayTimeDuration
)
as
xs:boolean
(§
op:dayTimeDuration-less-than
fn:days-from-duration
(
$arg1
as
xs:dayTimeDuration
,
$arg2
$arg
as
xs:dayTimeDuration
xs:duration?
)
as
xs:boolean
xs:integer?
(§
fn:deep-equal
(
$parameter1
as
item()*
,
$parameter2
as
item()*
,
$collation
as
string
xs:string
)
as
xs:boolean
(§
fn:distinct-values
(
$arg
as
xs:anyAtomicType*
,
$collation
as
xs:string
)
as
xs:anyAtomicType*
(§
op:divide-dayTimeDuration
(
$arg1
as
xs:dayTimeDuration
,
$arg2
as
xs:double
)
as
xs:dayTimeDuration
(§
op:divide-dayTimeDuration-by-dayTimeDuration
(
$arg1
as
xs:dayTimeDuration
,
$arg2
as
xs:dayTimeDuration
)
as
xs:decimal
(§
op:divide-yearMonthDuration
(
$arg1
as
xs:yearMonthDuration
,
$arg2
as
xs:double
)
as
xs:yearMonthDuration
(§
op:divide-yearMonthDuration-by-yearMonthDuration
(
$arg1
as
xs:yearMonthDuration
,
$arg2
as
xs:yearMonthDuration
)
as
xs:decimal
(§
fn:ends-with
(
$arg1
as
xs:string?
,
$arg2
as
xs:string?
,
$collation
as
xs:string
)
as
xs:boolean
(§
fn:error
(
$error
$code
as
xs:QName?
,
$description
as
xs:string
,
$error-object
as
item()*
)
as
none
(§
op:except
(
$parameter1
$arg1
as
node()*
,
$parameter2
$arg2
as
node()*
)
as
node()*
(§
fn:format-date
(
$value
as
xs:date?
,
$picture
as
xs:string
,
$language
as
xs:string?
,
$calendar
as
xs:string?
,
$country
as
xs:string?
)
as
xs:string?
(§
9.8.2
)
fn:format-dateTime
(
$value
as
xs:dateTime?
,
$picture
as
xs:string
,
$language
as
xs:string?
,
$calendar
as
xs:string?
,
$country
as
xs:string?
)
as
xs:string?
(§
9.8.1
)
fn:format-integer
(
$value
as
xs:integer?
,
$picture
as
xs:string
,
$language
as
xs:language
)
as
xs:string
(§
4.5.1
)
fn:format-number
(
$value
as
numeric?
,
$picture
as
xs:string
,
$decimal-format-name
as
xs:string
)
as
xs:string
(§
4.6.2
)
fn:format-time
(
$value
as
xs:time?
,
$picture
as
xs:string
,
$language
as
xs:string?
,
$calendar
as
xs:string?
,
$country
as
xs:string?
)
as
xs:string?
(§
9.8.3
)
op:gMonthDay-equal
(
$arg1
as
xs:gMonthDay
,
$arg2
as
xs:gMonthDay
)
as
xs:boolean
(§
op:gYearMonth-equal
(
$arg1
as
xs:gYearMonth
,
$arg2
as
xs:gYearMonth
)
as
xs:boolean
(§
op:hexBinary-equal
(
$value1
as
xs:hexBinary
,
$value2
as
xs:hexBinary
)
as
xs:boolean
(§
fn:index-of
(
$seqParam
$seqArg
as
xs:anyAtomicType*
,
$srchParam
$searchArg
as
xs:anyAtomicType
)
as
xs:integer*
(§
fn:index-of
(
$seqParam
$seqArg
as
xs:anyAtomicType*
,
$srchParam
$searchArg
as
xs:anyAtomicType
,
$collation
as
xs:string
)
as
xs:integer*
(§
fn:insert-before
(
$target
as
item()*
,
$position
as
xs:integer
,
$inserts
as
item()*
)
as
item()*
(§
op:intersect
(
$parameter1
$arg1
as
node()*
,
$parameter2
$arg2
as
node()*
)
as
node()*
(§
op:is-same-node
(
$parameter1
$arg1
as
node()
,
$parameter2
$arg2
as
node()
)
as
xs:boolean
(§
fn:matches
(
$input
as
xs:string?
,
$pattern
as
xs:string
,
$flags
as
xs:string
)
as
xs:boolean
(§
fn:max
(
$arg
as
xs:anyAtomicType*
,
$collation
as
string
xs:string
)
as
xs:anyAtomicType?
(§
fn:min
(
$arg
as
xs:anyAtomicType*
,
$collation
as
string
xs:string
)
as
xs:anyAtomicType?
(§
op:multiply-dayTimeDuration
(
$arg1
as
xs:dayTimeDuration
,
$arg2
as
xs:double
)
as
xs:dayTimeDuration
(§
op:multiply-yearMonthDuration
(
$arg1
as
xs:yearMonthDuration
,
$arg2
as
xs:double
)
as
xs:yearMonthDuration
(§
fn:namespace-uri-for-prefix
(
$prefix
as
xs:string?
,
$element
as
element()
)
as
xs:anyURI?
(§
op:node-after
(
$parameter1
$arg1
as
node()
,
$parameter2
$arg2
as
node()
)
as
xs:boolean
(§
op:node-before
(
$parameter1
$arg1
as
node()
,
$parameter2
$arg2
as
node()
)
as
xs:boolean
(§
fn:normalize-unicode
(
$arg
as
xs:string?
,
$normalizationForm
as
xs:string
)
as
xs:string
(§
fn:not
(
$arg
as
item()*
)
as
xs:boolean
(§
fn:position
fn:parse
$arg
as
xs:integer
xs:string
)
as
document-node(element(*,
xs:untyped))
(§
fn:prefix-from-QName
fn:parse
(
$arg
as
xs:QName?
xs:string
,
$baseURI
as
xs:string
)
as
xs:NCName?
document-node(element(*,
xs:untyped))
(§
fn:QName
fn:partial-apply
(
$paramURI
$func
as
xs:string?
function()
,
$paramQName
$arg
as
xs:string
item()*
)
as
xs:QName
function()
(§
op:QName-equal
fn:partial-apply
(
$arg1
$func
as
xs:QName
function()
,
$arg2
$arg
as
xs:QName
item()*
,
$argNum
as
xs:integer
)
as
xs:boolean
function()
(§
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
(§
fn:starts-with
(
$arg1
as
xs:string?
,
$arg2
as
xs:string?
,
$collation
as
xs:string
)
as
xs:boolean
(§
fn:subsequence
(
$sourceSeq
as
item()*
,
$startingLoc
as
xs:double
,
$length
as
xs:double
)
as
item()*
(§
fn:substring
(
$sourceString
as
xs:string?
,
$startingLoc
$start
as
xs:double
)
as
xs:string
(§
fn:substring
(
$sourceString
as
xs:string?
,
$startingLoc
$start
as
xs:double
,
$length
as
xs:double
)
as
xs:string
(§
fn:substring-after
(
$arg1
as
xs:string?
,
$arg2
as
xs:string?
,
$collation
as
xs:string
)
as
xs:string
(§
fn:substring-before
(
$arg1
as
xs:string?
,
$arg2
as
xs:string?
,
$collation
as
xs:string
)
as
xs:string
(§
op:subtract-dates
op:subtract-dateTimes
(
$arg1
as
xs:date
xs:dateTime
,
$arg2
as
xs:date
xs:dateTime
)
as
xs:dayTimeDuration?
xs:dayTimeDuration
(§
op:subtract-dateTimes
op:subtract-dates
(
$arg1
as
xs:dateTime
xs:date
,
$arg2
as
xs:dateTime
xs:date
)
as
xs:dayTimeDuration?
xs:dayTimeDuration
(§
op:subtract-dayTimeDuration-from-date
(
$arg1
as
xs:date
,
$arg2
as
xs:dayTimeDuration
)
as
xs:date
(§
op:subtract-dayTimeDuration-from-dateTime
(
$arg1
as
xs:dateTime
,
$arg2
as
xs:dayTimeDuration
)
as
xs:dateTime
(§
op:subtract-dayTimeDuration-from-time
(
$arg1
as
xs:time
,
$arg2
as
xs:dayTimeDuration
)
as
xs:time
(§
op:subtract-dayTimeDurations
(
$arg1
as
xs:dayTimeDuration
,
$arg2
as
xs:dayTimeDuration
)
as
xs:dayTimeDuration
(§
op:subtract-yearMonthDuration-from-date
(
$arg1
as
xs:date
,
$arg2
as
xs:yearMonthDuration
)
as
xs:date
(§
op:subtract-yearMonthDuration-from-dateTime
(
$arg1
as
xs:dateTime
,
$arg2
as
xs:yearMonthDuration
)
as
xs:dateTime
(§
op:subtract-yearMonthDurations
(
$arg1
as
xs:yearMonthDuration
,
$arg2
as
xs:yearMonthDuration
)
as
xs:yearMonthDuration
(§
fn:sum
(
$arg
as
xs:anyAtomicType*
,
$zero
as
xs:anyAtomicType?
)
as
xs:anyAtomicType?
(§
fn:tokenize
(
$input
as
xs:string?
,
$pattern
as
xs:string
,
$flags
as
xs:string
)
as
xs:string*
(§
fn:translate
(
$arg
as
xs:string?
,
$mapString
as
xs:string
,
$transString
as
xs:string
)
as
xs:string
(§
op:union
(
$parameter1
$arg1
as
node()*
,
$parameter2
$arg2
as
node()*
)
as
node()*
(§
op:yearMonthDuration-greater-than
(
$arg1
as
xs:yearMonthDuration
,
$arg2
as
xs:yearMonthDuration
)
as
xs:boolean
(§
op:yearMonthDuration-less-than
(
$arg1
as
xs:yearMonthDuration
,
$arg2
as
xs:yearMonthDuration
)
as
xs:boolean
(§