XQuery 1.0 and XPath 2.0 Functions and Operators -- Review Version

1 Introduction

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 these functions and operators is specified in [XPath 2.0], [XQuery 1.0: An XML Query Language] and [XSLT 2.0].

This document defines a few new datatypes, 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] defines a number of primitive and derived datatypes, collectively known as built-in datatypes. This document defines operations on these datatypes as well as the two datatypes defined in 1.5 xdt:anyAtomicType and xdt:untypedAtomic and the two totally ordered subtypes of xs:duration defined in 9.2 Two Totally Ordered Subtypes of Duration, for use in [XPath 2.0], [XQuery 1.0: An XML Query Language]and [XSLT 2.0]and related XML standards. This document also discusses operators and functions on nodes and node sequences as defined in the [XQuery 1.0 and XPath 2.0 Data Model] for use in [XPath 2.0], [XQuery 1.0: An XML Query Language]and [XSLT 2.0]and other related XML standards.

Referencesto specific sections of some of the above documents areindicated by cross-document links in this document. Eachsuch link consists of a pointerto a specific section followedasuperscript specifying the linkeddocument. Thesuperscripts have the following meanings: 'XQ'[XQuery 1.0: An XML Query Language],'XT' [XSLT 2.0],'XP' [XPath 2.0],'DM' [XQuery 1.0 and XPath 2.0 Data Model]and 'FS'[XQuery 1.0 and XPath 2.0 Formal Semantics].

1.1 FunctionOverloading

Ingeneral, the specifications named above do not support function overloading. Consequently,there are no overloaded functions in this document except for legacy [XPath 1.0]functions such as fn:string(),whichaccepts a single argument ofa variety of types, and concat()which acceptsavariablenumber of xs:string arguments. Inaddition, the functions defined in 6 Functions and Operators on Numericsthat accept numeric argumentsaccept arguments of type xs:integer,xs:decimal, xs:floator xs:double. See1.2 Function stable Most Signatures and Descriptions. Operatorssuch as "+" may be overloaded.

1.2 Function Signatures and Descriptions

Eachfunction is defined by specifying its signature, a description ofthe return type and each ofthe parameters and its semantics. For many functions, examples are included to illustrate theiruse.

Eachfunction's signature is presented ina form like this:

fn:function-name($parameter-name as parameter-type, ...) as return-type

Inthis notation, function-name, in bold-face,isthenameof thefunction whose signature isbeing specified. Ifthe function takes no parameters,then the name is followed by an empty set ofparentheses: "()";otherwise, the name isfollowed by a parenthesized list of parameter declarations,each declaration specifying the static type ofthe parameter, in italics, and a non-normative nameused to describe the function's semantics. If thereare twoor more parameter declarations, they are separatedby a comma. The return-type,also in italics,specifies the static type of the value returnedby the function. Inmost cases, the dynamic typereturned by the function is the same as its statictype. Thetypes "node"and "item"are indicated in function signatures as "node()" and "item()" repectively.

In some cases the word "numeric" is usedin function signaturesas ashorthand to indicate the four numeric types: xs:integer,xs:decimal, xs:floatand xs:double. Forexample, a function with the signature

fn:numeric-function($arg as numeric) as ...

representsthe followingfour functions 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 ...

Similarly, for return types.

For most functions there is a initialparagraph describing what the function does followedby semantic rules. These rulesare meant to be followed in the order thatthey appear in this document.

In some cases, the dynamic type returned by afunction depends onthetype(s) of itsargument(s). These special functions are indicated byusing bolditalicsfor the return type. Thesemantic rules specifyingthe type of the value returned are documentedin thefunction definition. The rules are described more formally in Section 6.2 Standard functions with specific typing rules^FS.

Thefunction name is a QNameas defined in [XML Schema Part 2: Datatypes]and must adhereto its syntactic conventions. Following [XPath 1.0], function names are composed of English words separated by hyphens,"-". Ifa function name contains a [XML Schema Part 2: Datatypes]datatype name, it may have intercapitalized spelling andis usedin the function name as such. For example, fn:get-timezone-from-dateTime.

As is customary, theparameter type name indicates thatthefunction accepts arguments of that type, or types derived fromit, in that position. This is called subtype substitution.Details of the semantics of passing arguments to functionsare discussed in Section B.1 Type Promotion^XQ .

Somefunctions accept the emptysequence as an argument and some may return the empty sequence. This is indicated in the function signature by following the parameter or returntype name with a question mark: "?",indicating that either a singlevalue or the empty sequence must appear. Seebelow.

fn:function-name($parameter-name as parameter-type?) as return-type?

Notethat thisfunction signature is different from a signature in which the parameter isomitted. See,for example, the two signatures forfn:string(). Inthe first signature, the parameteris omitted and theargument defaults tothe context-item(.). Inthe second signature, the argumentmust be present but may bethe empty sequence ().

Somefunctions accepta sequenceas an argument.This is indicated byfollowingthe nameof type of the items in the sequence with *. The sequence may contain zero or more items of the named type. Forexample, the function below acceptsa sequence of xs:double andreturns a xs:doubleor the empty sequence.

fn:median($arg as xs:double*) as xs:double?

1.3 NamespaceTerminology

Thisdocument uses the phrase "namespace URI" toidentify the concept identified in [Namespaces in XML] as "namespace name", and the phrase "local name" to identifythe concept identified in [Namespaces in XML]as "local part".

It alsouses the term "expanded-QName".

[Definition] Expanded-QName: Anexpanded-QName is a pair ofvalues consisting of a namespaceURI and a local name. They belong to the value space of the [XML Schema Part 2: Datatypes]datatypexs:QName. When this document refers toxs:QName we always mean thevalue space, i.e. a namespace URI, local name pair (and notthe lexical spacereferring to constructs of the form prefix:local-name).

1.4 Type Hierarchy

The diagram below shows the types for which functions are defined inthis document. These include the built-in types defined by [XML Schema Part 2: Datatypes] (shownon the right) as well as types defined in [XPath 2.0](shown on the left). Solidlines connect a base datatypeabove to a derived datatype exceptin the case of xsIDREFS, xs:IDREFS, xs:NMTOKENS, xs:ENTITIES and user-defined listand union types. These types are lists or unions of their parent types(s) ratherthan true subtypes.Dashed lines connect a uniontype above with its component types below.

Theinformation in the above diagram isreproduced below in tabular form. Forease of presentation the information is divided into three tables. The firsttable shows the top three layers of the hierarchy starting at xs:anyType. The second table shows the typesderived from xdt:anyAtomicType. The third table showsthe types defined in [XPath 2.0]

Each type whose name is indented is derived from thetypewhosename appearsnearest above with one less level of indent.

xs:anyType
	user-defined complex types
	xdt:untypedAny
	xs:anySimpleType
		user-defined list and union types
		xs:IDREFS
		xs:NMTOKENS
		xs:ENTITIES
		xdt:anyAtomicType

The table below shows the datatypes derived from xdt:anyAtomicType.This includes all the [XML Schema Part 2: Datatypes]built-in datatypes as wellas the two totallyordered subtypes of duration defined 9.2 Two Totally Ordered Subtypes of Duration.

Each type whose nameis indented is derived from the type whose name appears nearest above with one less level of indent.

xdt:untypedAtomic
xs:dateTime
xs:date
xs:time
xs:duration
	xdt:yearMonthDuration
	xdt:dayTimeDuration
xs:float
xs:double
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: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

Thetable below shows type hierarchy for the types introduced in [XPath 2.0].For these types, each type whose nameis indented is a component of the union type whose name appears nearest above with one less level of indent.

item
	xdt:anyAtomicType
	node
		attribute
			user-defined attribute types
		comment
		document
			user-defined document types
		element
			user-defined element types
		processing-instruction
		text

1.5 xdt:anyAtomicType and xdt:untypedAtomic

1.5.1 xdt:anyAtomicType

The abstract datatype xdt:anyAtomicTypeis a child of xs:anySimpleType and is the base type for allthe primitive atomic types described in [XML Schema Part 2: Datatypes].This datatypecannot be used in [XML Schema Part 1: Structures]type declarations, norcan it beused as a base for user-defined atomic types. Itcan be used,as discussed in the Section 3.12 Expressions on SequenceTypes^XQ, todefine a required type (for example in a function signature) to indicate that any of the primitive atomic types or xdt:untypedAtomicis acceptable. Thisdatatype resides inthe namespace http://www.w3.org/2003/11/xpath-datatypes.

1.5.2 xdt:untypedAtomic

Theabstract datatype xdt:untypedAtomicis a child of xdt:anyAtomicTypeand serves as a special type annotation to indicate atomic values that have notbeen validated by a XML Schema or a DTD or have received an instance type annotationof xs:anySimpleType in the PSVI. This datatype cannot be used in [XML Schema Part 1: Structures]type declarations, nor can it be used asa base for user-defined atomic types.It can be used, as discussed inthe Section 3.12 Expressions on SequenceTypes^XQ, todefine a required type (for example in afunction signature) to indicate that only an untyped atomic value is acceptable. This datatype resides in the namespace http://www.w3.org/2003/11/xpath-datatypes.

1.5.3 xdt:untypedAny

The abstract datatype xdt:untypedAnyis a child of xs:anyTypeand serves as a special type annotation to indicate types that have notbeen validated by a XML Schema or a DTD. This type cannot be usedin [XML Schema Part 1: Structures]typedeclarations, nor can it beused asa base for user-defined types. It can be used, asdiscussed in the Section 3.12 Expressions on SequenceTypes^XQ, to define a requiredtype (for example ina function signature) to indicate that only an untyped value is acceptable. This datatyperesides in the namespace http://www.w3.org/2003/11/xpath-datatypes.

1.6 xs:dateTime,xs:date andxs:time values

xs:dateTime, xs:date and xs:time valuesare represented in the Section 3.3.1 Mapping PSVI Additions to Types^DMastuples: a xs:dateTime, xs:dateor xs:time value without a timezone and a timezone represented as a xdt:dayTimeDuration value.The value space of these types consistsof the normalized value for these datatypes. Thismeans that the xs:dateTime, xs:dateor xs:timeis first normalized to UTC or timezone Z. To create a value from a lexical representation of xs:dateTime, xs:dateand xs:timelexical representations that have a timezone are converted to timezone Zas defined by[XML Schema Part 2: Datatypes]and the timezone in the lexical representationis converted toa xdt:dayTimeDuration value. Lexicalrepresentations that do not contain a timezone are assumedto be in timezone Zand the timezonepart of the value set to the empty sequence "()".

We also define the localizedvaluefor a xs:dateTime, xs:date and xs:timeas the xs:dateTime, xs:dateand xs:timevalue in its original timezone or no timezone, as thecase may be,followed by thetimezonerepresented as a xdt:dayTimeDuration.Lexical representations that donot contain a timezone are given a timezone valueset to the empty sequence "()".

1.6.1 Examples

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

1.7 Namespaces andPrefixes

The functions and operators discussed in this document are contained in one of three namespaces (see [Namespaces in XML]) and referenced using a xs:QName.Constructor functions for the built-in datatypes defined in [XML Schema Part 2: Datatypes] discussed in 5 Constructor Functions are in the XML Schema namespace, http://www.w3.org/2001/XMLSchema,and named in this document using the xs: prefix. The namespace prefix used in this document is fn: for the functions available to users and op: for the operator functions. The purpose ofthe functions indicated by the op: prefix is to definethe semantics of operators in the host languages. In [XQuery 1.0: An XML Query Language]and [XPath 2.0] they are not directly accessible by users.

The datatypes described in this document in 1.5 xdt:anyAtomicType and xdt:untypedAtomic and 9.2 Two Totally Ordered Subtypes of Duration are contained in a separate namespace and are named using the prefix xdt:.

The namespace prefix for these functions and datatypes can vary, as long as the prefix is bound to the correct URI.

The URIs of the namespaces are:

http://www.w3.org/2001/XMLSchema for constructors
http://www.w3.org/2003/11/xpath-functions for functions.
http://www.w3.org/2003/11/xpath-datatypes for the datatypes.

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 [XPath 2.0], [XQuery 1.0: An XML Query Language] and [XSLT 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:multiply(

$arg1 as numeric

, $arg2 as numeric

) as numeric

1.8 Terminology

The terminology used to describe thefunctions and operators on [XML Schema Part 2: Datatypes]is defined in the body of this specification. The terms defined in the following list are used in building those definitions:

[Definition] for compatibility: A feature of this specification included to ensure that implementations that use this feature remain compatible with [XPath 1.0]
[Definition] may: Conforming documents and processors are permitted to, but need not, behave as described.
[Definition] must: Conforming documents and processors are required to behave as described; otherwise, they are either non-conformant or else in error.
[Definition] implementation defined: Possibly differing between implementations, but specified and documented by the implementor for each particular implementation.
[Definition] implementation-dependent: Possibly differing between implementations, but not specified by this or other W3C specification, and notrequired to be specified by the implementor for any particular implementation.
[Definition] stable: Most of the functions in the core library have the property that calling the same function twice with the same arguments returns the same result: these functions are said to be stable. This category includes a number of functions such as fn:doc(), fn:collection(), fn:current-dateTime(), fn:current-date and fn:current-time() whose result depends on the external environment. Where the function returns nodes, stability means that the returned nodes are identical, not merely equal. The scope over which the results are stable depends on the processing context. In XSLT, it applies to any two calls on the function executed during the same transformation. In XQuery, it applies to any two calls executed during the evaluation of a top-level expression i.e. an expression not contained in any other expression. In other contexts, the scope is specified by the host environment that invokes the function library.
Some other functions, for example fn:position() and fn:last(), depend on the dynamic context and may, therefore, produce different results each time they are called. These functions are said to be contextual.

2 Accessors

Accessors andtheir semantics are described in [XQuery 1.0 and XPath 2.0 Data Model].Some of these accessors are exposed to the user through the functions described below.

Function	Accessor	Accepts	Returns

2.1 fn:node-name

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$argis theempty sequence, the empty sequence is returned.

2.2 fn:string

fn:string() as xs:string

fn:string(

$arg as item()?

) as xs:string

Summary: Returns the value of $arg represented as a xs:string. If no argument is supplied, thisfunction returns the string value ofthe context item (.).

If $arg is the empty sequence, the zero-length string is returned.

If $arg is a node, the function returns the string-value of the node, as obtained using the dm:string-valueaccessor defined in the Section 5.5 string-value Accessor^DM.

If $arg is an atomic value, then the function returns the same string as is returned by the expression "$argcastasxs:string"(see 17 Casting Functions).

2.3 fn:data

fn:data(

$arg as item()*

) as xdt:anyAtomicType*

Summary: fn:data takes a sequence of items and returns a sequence of atomic values.

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.
If the item is a node, fn:data() returns the typed value of the node as defined by the accessor function dm:typed-value in Section 5.6 typed-value Accessor^DM.

2.4 fn:base-uri

fn:base-uri(

$arg as node()?

) as xs:string?

Summary: Returns the value of the base-uri property for $arg as defined by the accessor function dm:base-uri for that kind of node in Section 5.1 base-uri Accessor^DM.

If $arg is the empty sequence, the empty sequence is returned.

Document, element and processing-instruction nodes have a base-uri property whichmay be empty. The base-uri of all other node types is the empty sequence. If the base-uri property for $argis non-empty, its value isreturned. If the base-uri propertyfor $argis empty, the base-uri of that node's parent is returned. If the node has no parent, the empty sequence is returned.

fn:base-uri() as xs:string

Summary: This version of the function returns the value of the base-uri property from the static context using the preceding rules. The static context is discussed in Section 2.1.1 Static Context^XQ .

2.5 fn:document-uri

fn:document-uri(

$arg as node()?

) as xs:string?

Summary: Returns the value of the document-uri property for $arg as defined by the accessor function dm:document-uri in Section 5.1 base-uri Accessor^DM.

If $arg is the empty sequence, the empty sequence is returned.

Returns theempty sequence if the node is not a document node or if its document-uri property is a relative URI. Otherwise, returns an absolute URI expressed as an xs:string.

If the document-uri property of $arg is not the empty sequence, then the following expression always holds:


fn:doc(fn:document-uri($arg)) is $arg

3 The Error Function

In this document, as well as in [XQuery 1.0: An XML Query Language], [XPath 2.0], and [XQuery 1.0 and XPath 2.0 Formal Semantics], the phrase "an error is raised" is used to describethe behavior of conforming processorsin certain situations.When such situations arise in a runningsystem, a conforming implementationof this specification must invoke the fn:error function defined in this section.

The phrase is normally accompanied by specification of a specific error, in which case the phrase "an error is raised [name of error]" is used. The"name of error" specifies aphrase that is mnemonic for the actual error, but the error code to which it refersis an xs:QName. Each error defined in this document is identified by an xs:QName that is in the namespace asssociated with the xdt: prefix. It is the xs:QName that is actually passed as an argument to the fn:error function invocation. Invocation of this function causes the evaluation phase of the outermost XQuery or transformation to be terminated. For a more detailed treatment of error handing, see Section 2.5.2 Handling Dynamic Errors^XQ and Section 6.2.5 The fn:error function^FS.

The fn:error function is a general function that may be invoked as above but may also be invoked from XQuery and XPath 2.0 applications with, forexample, an xs:string argument.

fn:error() as none

fn:error(

$arg as item()?

) as none

One version of thefn:error function takesno argments;asecond version of the function accepts an optional item() as argument. The fn:error function never returns a value.

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

4 The Trace Function

This function is intended to be used in debugging queries by providing a trace of their execution.

fn:trace($value as item()*, $label as xs:string) as item()*

The input $value is returned, unchanged, as the result of the function. In addition, the inputs $value and $label are directed to a trace data set. The location and format of the trace data set are ·implementation dependent·. The ordering of output from invocations of the fn:trace() function is ·implementation dependent·.

4.1 Examples

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

5 Constructor Functions

5.1 Constructor Functions for XML Schema Built-in Types

Every built-in atomic type that is defined in [XML Schema Part 2: Datatypes], except xs:NOTATIONhas an associated constructorfunction; as do xdt:untypedAtomic, defined in 1.5 xdt:anyAtomicType and xdt:untypedAtomic and the two derived types xdt:yearMonthDuration and xdt:dayTimeDuration defined in 9.2 Two Totally Ordered Subtypes of Duration.The form of that function for a type pref:TYPE is:

pref:TYPE(

$arg as xdt:anyAtomicType

) as pref:TYPE

For example, the signature of the constructor function corresponding to the xs:unsignedInt type defined in [XML Schema Part 2: Datatypes] is:

xs:unsignedInt(

$arg as xdt: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 value equal to the xs:unsignedInt 12. The standard features described in Section 2.3.2 Atomization^XQ would 'atomize' the node to extract its 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 [invalid value for constructor].

If the argument to a constructor function is an xs:string,whitespace normalization is appliedas indicated by the whiteSpace facet for the datatype. The resulting whitespace-normalized stringmust be a valid lexical form for the type, as specified in [XML Schema Part 2: Datatypes]. The semantics of constructor functions wheninvoked with a xs:string are identical to XML Schema validation. In the case of xs:dateTime, xs:date and xs:time, the value returned differs from [XML Schema Part 2: Datatypes] and is defined in 1.6 xs:dateTime,of xs:date andargument(s). These xs:time values.

The semantics of the constructor function "xs:TYPE(arg)" areidentical to the semantics of "arg cast as xs:TYPE". See 17 Casting Functions. In some cases, the semantics of casting areexplained using constructor functions; but there is no circularity. The constructors used invariably take xs:string arguments and, in this case, the semantics arethe semantics of XML Schema validation as discussed above.

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.

The following constructor functions for the built-in types are supported:

xs:string(
$arg as xdt:anyAtomicType
) as xs:string
xs:boolean(
$arg as xdt:anyAtomicType
) as xs:boolean
xs:decimal(
$arg as xdt:anyAtomicType
) as xs:decimal
xs:float(
$arg as xdt:anyAtomicType
) as xs:float
Implementations ·may· return negative zero for xs:float("-0.0E0").
xs:double(
$arg as xdt:anyAtomicType
) as xs:double
Implementations ·may· return negative zero for xs:double("-0.0E0").
xs:duration(
$arg as xdt:anyAtomicType
) as xs:duration
xs:dateTime(
$arg as xdt:anyAtomicType
) as (xs:dateTime, xdt:dayTimeDuration)
xs:time(
$arg as xdt:anyAtomicType
) as (xs:time, xdt:dayTimeDuration)
xs:date(
$arg as xdt:anyAtomicType
) as (xs:date, xdt:dayTimeDuration)
xs:gYearMonth(
$arg as xdt:anyAtomicType
) as xs:gYearMonth
xs:gYear(
$arg as xdt:anyAtomicType
) as xs:gYear
xs:gMonthDay(
$arg as xdt:anyAtomicType
) as xs:gMonthDay
xs:gDay(
$arg as xdt:anyAtomicType
) as xs:gDay
xs:gMonth(
$arg as xdt:anyAtomicType
) as xs:gMonth
xs:hexBinary(
$arg as xdt:anyAtomicType
) as xs:hexBinary
xs:base64Binary(
$arg as xdt:anyAtomicType
) as xs:base64Binary
xs:anyURI(
$arg as xdt:anyAtomicType
) as xs:anyURI
xs:QName($arg as xdt:anyAtomicType) as xs:QName
See 17.14 Casting to xs:QName for semantics of xs:QName.

xs:normalizedString(
$arg as xdt:anyAtomicType
) as xs:normalizedString
xs:token(
$arg as xdt:anyAtomicType
) as xs:token
xs:language(
$arg as xdt:anyAtomicType
) as xs:language
xs:NMTOKEN(
$arg as xdt:anyAtomicType
) as xs:NMTOKEN
xs:Name(
$arg as xdt:anyAtomicType
) as xs:Name
xs:NCName(
$arg as xdt:anyAtomicType
) as xs:NCName
xs:ID(
$arg as xdt:anyAtomicType
) as xs:ID
xs:IDREF(
$arg as xdt:anyAtomicType
) as xs:IDREF
xs:ENTITY(
$arg as xdt:anyAtomicType
) as xs:ENTITY
xs:integer(
$arg as xdt:anyAtomicType
) as xs:integer
xs:nonPositiveInteger(
$arg as xdt:anyAtomicType
) as xs:nonPositiveInteger
xs:negativeInteger(
$arg as xdt:anyAtomicType
) as xs:negativeInteger
xs:long(
$arg as xdt:anyAtomicType
) as xs:long
xs:int(
$arg as xdt:anyAtomicType
) as xs:int
xs:short(
$arg as xdt:anyAtomicType
) as xs:short
xs:byte(
$arg as xdt:anyAtomicType
) as xs:byte
xs:nonNegativeInteger(
$arg as xdt:anyAtomicType
) as xs:nonNegativeInteger
xs:unsignedLong(
$arg as xdt:anyAtomicType
) as xs:unsignedLong
xs:unsignedInt(
$arg as xdt:anyAtomicType
) as xs:unsignedInt
xs:unsignedShort(
$arg as xdt:anyAtomicType
) as xs:unsignedShort
xs:unsignedByte(
$arg as xdt:anyAtomicType
) as xs:unsignedByte
xs:positiveInteger(
$arg as xdt:anyAtomicType
) as xs:positiveInteger

xdt:yearMonthDuration(
$arg as xdt:anyAtomicType
) as xdt:yearMonthDuration
xdt:dayTimeDuration(
$arg as xdt:anyAtomicType
) as xdt:dayTimeDuration
xdt:untypedAtomic(
$arg as xdt:anyAtomicType
) as xdt:untypedAtomic

5.2 Constructor Functions for User-Defined Types

For every globally-defined atomic type in the static context (See Section 2.1.1 Static Context^XQ that is derived by restriction from a primitive type, except types derived from xs:NOTATION, 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 5.1 Constructor Functions for XML Schema Built-in Types.

In the case of types whose name has a null namespace URI, it will not be possible to call the constructor function if a default namespace for functions is defined. In this case, the cast syntax must be used instead.

Consider a situation where the static context contains a type called hatSize defined in a schema that is bound to the prefix my. In such a case the constructor function:

my:hatSize(

$arg as xdt:anyAtomicType

) as my:hatSize

is available to users.

6 Functions and Operators on Numerics

This section discusses arithmetic operators on the numeric datatypes defined in [XML Schema Part 2: Datatypes]. It uses an approach that permits lightweight implementation whenever possible.

6.1 Numeric Types

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

xs:decimal
	xs:integer
xs:float
xs:double

They also apply to types derived by restriction from these types.

Note:

The value space for xs:float and xs:double, as defined in the errata to [XML Schema Part 2: Datatypes], defines only a single zero. [IEEE 754-1985] arithmetic, however, can produce distinct results of positive zero and negative zero. Theseare two differentmachine representations for the same value. The text accompanyingseveral functions discusses behaviour for both positive andnegative zero inputsin the interest of alignmentwith [IEEE 754-1985].

6.2 Operators on Numeric Values

The following functions definethe semanticsof operators defined in [XQuery 1.0: An XML Query Language] and [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 to return the same type. The one exception is op:numeric-divide, which returns an xs:decimal if called with two xs:integer operands.)

Operands of type xdt:untypedAtomic are converted to xs:double, except for arguments to 6.2.5 op:numeric-integer-divide which are converted to xs:integer. If the two operands are not of the same type, subtype substitution and type promotion areused to obtain two operands of the same type. Section B.1 Type Promotion^XQdescribes the semantics of these operations in detail.

Subtype substitution: A derived type may substitute for its base type. In particular, xs:integer may be used where xs:decimal is expected.
Type promotion: xs:decimal may be promoted to xs:float, and xs:float may be promoted to xs:double.

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:float, and xs:float can be promoted to xs:double. As far as possible, the promotions should be done in a single step. Specifically, when a decimal is promoted to a double, it should not be converted to a float and then to 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.

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 a number of options:
- Raising an error [numeric operation overflow/underflow]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 a number of options:
- Raising an error [numeric operation overflow/underflow]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 [numeric operation overflow/underflow].On underflow, 0.0 must be returned.
For xs:integer operations, implementations that support limited precision integer operations ·must·:
- Either, they ·may· choose to always raise an error [numeric operation overflow/underflow].
- Or, 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.

The number of digits of precision returned by various numeric functions is ·implementation dependent·.

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

6.2.5 op:numeric-integer-divide

`op:numeric-integer-divide`(	`$arg1`	`as` `xs:integer`,
`op:numeric-integer-divide`(	`$arg2`	`as` `xs:integer`) `as` `xs:integer`

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

If the divisor is zero,then an error is raised [division by zero].

6.2.5.1 Examples

op:numeric-integer-divide(10,3) returns 3
op:numeric-integer-divide(3,-2) returns -1
op:numeric-integer-divide(-3,2) returns -1
op:numeric-integer-divide(-3,-2) returns 1

6.2.6 op:numeric-mod

op:numeric-mod(

$arg1 as numeric

, $arg2 as numeric

) as numeric

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

If $arg2 is zero,then an error is raised [division by zero].

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

If either operand is NaN, the result is NaN.
If the dividend is positive or negative infinity, or the divisor is positive or negative zero (0), or both, the result is NaN.
If the dividend is finite and the divisor is an infinity, the result equals the dividend.
If the dividend is positive or negative zero and the divisor is finite, the result is the same as the dividend.
In the remaining cases, where neither positive or negative infinity, nor positive or negative zero, nor NaN is involved, the result obeys (a/b)*b+(a mod b) = a. Division is truncating division, analogous to integer division, not [IEEE 754-1985] rounding division.

6.2.6.1 Examples

op:numeric-mod(10,3) returns 1.
op:numeric-mod(6,-2) returns 0.
op:numeric-mod(4.5,1.2) returns 0.9.
op:numeric-mod(1.23E2, 0.6E1) returns 3.0E0.

6.2.7 op:numeric-unary-plus

op:numeric-unary-plus(

$arg as numeric

) as numeric

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

6.2.8 op:numeric-unary-minus

op:numeric-unary-minus(

$arg as numeric

) as numeric

Summary: Backs up the unary "-" operator and returns its operand with the sign reversed: (- $arg). If $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 and +INF return -INF. -INF returns INF.

6.3 Comparison of Numeric Values

This specification defines the following comparison operators on numeric values. Comparisons take two arguments of the same type. Arguments of type xdt:untypedAtomic are converted to xs:double. If the arguments are of different types, one argument is promoted to the type of the other as described above in 6.2 Operators on Numeric Values. Each comparison operator returns a boolean value. If either, or both, operands are NaN, false is returned.

Operator	Meaning
`op:numeric-equal`	Equality comparison
`op:numeric-less-than`	Less-than comparison
`op:numeric-greater-than`	Greater-than comparison

6.3.1 op:numeric-equal

op:numeric-equal(

$arg1 as numeric

, $arg2 as numeric

) as xs:boolean

Summary: Returns true if and only if the value of $arg1 is equal to the value of $arg2. For xs:float and xs:double values, positivezero and negativezero compare equal. NaN does not equal itself.

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

6.3.2 op:numeric-less-than

op:numeric-less-than(

$arg1 as numeric

, $arg2 as numeric

) as xs:boolean

Summary: Returns true if and only if $arg1 is less 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 $arg2 is NaN, the function returns false.

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

6.3.3 op:numeric-greater-than

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 $arg2 is NaN, the function returns false.

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

6.4 Functions on Numeric Values

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.
If the argument is xdt:untypedAtomic it is converted to xs:double.
For xs:float and xs:double arguments, if the argument is "NaN", "NaN" is returned.
Except for fn:abs(), forxs: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 the argument.
`fn:ceiling`	Returns thelargest smallest number with no fractional part that is greater than or equal to the argument.
`fn:floor`	Returns the largest number with no fractional part that is less than or equal to the argument.
`fn:round`	Rounds to the nearest number with no fractional part.
`fn:round-half-to-even`	Takes a number and a precision and returns a number rounded to the given precision. If the fractional part is exactly half, the result is the number whose least significant digit is even.

6.4.1 fn:abs

fn:abs($arg as numeric?) as numeric?

Summary: Returns the absolutevalue of $arg. If $argis negativereturns -$argotherwise returns $arg. If type of $arg is one of the four numeric types xs:float, xs:double,xs:decimalor xs:integerthe type of the return is the same as the type of $arg. If the type of $arg is a type derived from one of the numeric types, the type of the return is the parent numeric type.

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

For detailed type semantics, see Section 6.2.1 The fn:abs, fn:ceiling, fn:floor, fn:round, and fn:round-half-to-even functions^FS

6.4.1.1 Examples

fn:abs(10.5) returns 10.5.
fn:abs(-10.5) returns 10.5.

6.4.2 fn:ceiling

fn:ceiling(

$arg as numeric?

) as numeric?

Summary:Returns the smallest (closest to negative infinity) number with no fractional part that is not less than the value of $arg. If type of $arg is one of the four numeric types xs:float, xs:double, xs:decimal or xs:integer the type of the return is the same as the type of $arg. If the type of $arg is a type derived from one of the numeric types, the type of the return is the parent numeric type.

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

For detailed type semantics, see Section 6.2.1 The fn:abs, fn:ceiling, fn:floor, fn:round, and fn:round-half-to-even functions^FS

6.4.2.1 Examples

fn:ceiling(10.5) returns 11.
fn:ceiling(-10.5) returns -10.

6.4.3 fn:floor

fn:floor($arg as numeric?) as numeric?

Summary: Returns the largest (closest to positive infinity) number with no fractional part that is not greater than thevalue of $arg. If type of $arg is one of the four numeric types xs:float, xs:double, xs:decimal or xs:integer thetype of the return is the same as the type of $arg. If the type of $arg is a type derived fromone of the numeric types, the type of the return is the parent numeric type.

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

For detailed type semantics, see Section 6.2.1 The fn:abs, fn:ceiling, fn:floor, fn:round, and fn:round-half-to-even functions^FS

6.4.3.1 Examples

fn:floor(10.5) returns 10.
fn:floor(-10.5) returns -11.

6.4.4 fn:round

fn:round($arg as numeric?) as numeric?

Summary: Returns the number with no fractional part that is closest to the argument. If there are two such numbers, then the one that is closest to positive infinity is returned. More formally, fn:round(x) produces the same result as fn:floor(x+0.5). If type of $arg is one of the four numeric types xs:float, xs:double, xs:decimal or xs:integer the type of the return is the same as the type of $arg. If the type of $arg is a type derived from one of the numeric types, the type of the return is the parent numeric type.

For detailed type semantics, see Section 6.2.1 The fn:abs, fn:ceiling, fn:floor, fn:round, and fn:round-half-to-even functions^FS

6.4.4.1 Examples

fn:round(2.5) returns 3.
fn:round(2.4999) returns 2.
fn:round(-2.5) returns -2 (not the possible alternative, -3).

6.4.5 fn:round-half-to-even

fn:round-half-to-even(

$arg as numeric?

) as numeric?

fn:round-half-to-even(

$arg as numeric?

, $precision as xs:integer

) as numeric?

Summary: The value returned is the nearest (that is, numerically closest) numeric to $argthat is a multipleof ten to the power of minus $precision. If two suchvalues areequally near (e.g. if the fractional part in $argis exactly .500...), returns the one whose least significant digitis even. If type of $argis one ofthe four numeric types xs:float, xs:double,xs:decimalor xs:integerthetype of the return is the same as the type of $arg. Ifthe typeof $arg is a type derived from oneof the numeric types, the type of the returnis the parent numerictype.

Thefirst signature of this function producesthe same result as the second signature with$precision=0.

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

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

For detailed type semantics, see Section 6.2.1 The fn:abs, fn:ceiling, fn:floor, fn:round, and fn:round-half-to-even functions^FS

6.4.5.1 Examples

fn:round-half-to-even(1.5) returns the value corresponding to 2.
fn:round-half-to-even(2.5) returns the value corresponding to 2.
fn:round-half-to-even(3.567812E+3, 2) returns the value corresponding to 3567.81E0.
fn:round-half-to-even(4.7564E-3, 2) returns the value corresponding to 0.0E0.
fn:round-half-to-even(35612.25, -2) returns the value corresponding to 35600.

7 Functions on Strings

This section discusses functions and operators on the [XML Schema Part 2: Datatypes] xs:string datatype and the datatypes derived from it.

7.1 String Types

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

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

Note:

This document uses the term "code point",sometimes spelt "codepoint", asdefined in [The Unicode Standard], ranging from #x0000 to #x10FFFF inclusive. The use ofthe word "character"in this document isin the sense of production [2] of [XML 1.0 Recommendation (Second Edition)], so it may include codepoints which have not yet been assignedto characters."

Note:

Infunctions that involve character counting such as fn:substring,fn:string-lengthand fn:translate, what iscounted is the of XML characters in the string(or equivalently, the numberof Unicode code points). Some implementations may represent a code point above xFFFF using two 16-bit values known as a surrogate. A surrogate counts as one character, not two.

Unless explicitly stated, the xs:string values returned by thefunctions in this document are not normalizedin the sense of [Character Model for the World Wide Web 1.0].

7.2 Functions to Assemble and Disassemble Strings

Function	Meaning
`fn:codepoints-to-string`	Creates an `xs:string` from a sequence of code points.
`fn:string-to-codepoints`	Returns the sequence of code points that constitute an `xs:string`.

7.2.1 fn:codepoints-to-string

fn:codepoints-to-string(

$arg as xs:integer*

) as xs:string

Creates an xs:string from a sequence of code points. Returns the zero-length string if $arg is the empty sequence. If any of the code pointsin $arg is not a legal XML character, an error is raised [codepoint not valid].

7.2.1.1 Examples

fn:codepoints-to-string((2309, 2358,2378, 2325)) returns"अशॊक"

7.2.2 fn:string-to-codepoints

fn:string-to-codepoints(

$arg as xs:string?

) as xs:integer*

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

7.2.2.1 Examples

fn:string-to-codepoints("Thérèse") returns the sequence (84, 104, 233, 114, 232, 115, 101)

7.3 Equality and Comparison of Strings

7.3.1 Collations

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 values).The [Character Model for the World Wide Web 1.0] 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 that two different codepoints are, in fact, equal for comparisonpurposes (e.g., "v" and "w" are considered equivalent in Swedish). Strings can be compared codepoint-by-codepoint or in a linguistically appropriatemanner, 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 collation with a distinguished name, http://www.w3.org/2003/11/xpath-functions/collation/codepoint, provides the ability to compare strings based on code point values. Every implementation of XQuery/XPath must support the collation based on code point values.

While the [Character Model for the World Wide Web 1.0] recommends that all strings be subjected to early Unicode normalization, 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 interoperable results of operations on XML documents in general, there may be collations that operate on unnormalized strings, other collations that raise runtime errors when unnormalized strings are encountered, and still other collations that implicitly normalize strings for the purposes of collating them. For alignment with the [Character Model for the World Wide Web 1.0], applications may choose collations that treat unnormalized strings as though they were normalized (that is, that implicitly normalize the strings). Note that collations based on the Unicode collation algorithm 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 of functions that use a collation but allow it to be omitted.

Functions such as fn:compareand fn:maxthat compare xs:string values usea single collation URI to identify all aspectsof the collation rules. This means that any parameters such as the strength of the collation must be specified as part ofthe collation URI. For example, suppose thereis a collation"http://www.example.com/collations/French" thatrefers to a French collation that compares on the basis of base characters. Collations that use the same basic rules, butwith higher strengths, for example, base characters and accents, or base characters, accents and case, would need to be given differentnames, say "http://www.example.com/collations/French1" and "http://www.example.com/collations/French2". Note that somespecifications use the term collation to refer to an algorithm that can be parameterized, but in this specification, each possible parameterization is considered to bea distinct collation.

The XQuery/XPath static context includes a provision for a default collation that canbe used for string comparisons (including orderingoperations). However, the static context is not required to have a default collation specified. Seethe description of the static context in Section 2.1.1 Static Context^XQ. Ifthe static context does not havea default collation specified, a system defined default can beinvoked. If this is not provided, the Unicode code point collation is used as the defaultcollation.

The decision of what collation to use for a given comparison or ordering function is determined by the following algorithm:

If the function specifies an explicit collation, CollationA (e.g., if the optional collation argument is specified in an invocation of the fn:compare() function), then:
- If CollationA is supported by the implementation, then CollationA is used.
- Otherwise, an error is raised [unsupported collation].
If no collation is explicitly specified for the function and the function is fn:contains, fn:starts-with, fn:ends-with, fn:substring-before or fn:substring-after the Unicode code point collation (http://www.w3.org/2003/11/xpath-functions/collation/codepoint) is used.
If no collation is explicitly specified for the function and the function is not one of the abovefunctions and the XQuery/XPath static context specifies a collation, CollationB, then:
- If CollationB is supported by the implementation, then CollationB is used.
- Otherwise, an error is raised [unsupported collation].
Otherwise, the Unicode code pointcollation (http://www.w3.org/2003/11/xpath-functions/collation/codepoint)is used.

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.

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.

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

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

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

7.3.2.1 Examples

fn:compare('abc', 'abc') returns 0.
fn:compare('Strasse', 'Straße') returns 0 if and only if the default collation includes provisions that equate "ss" and the (German) character "ß" ("sharp-s"). (Otherwise, the returned value depends on the semantics of the default collation.)
fn:compare('Strasse', 'Straße', 'deutsch') returns 0 if the collation identified by the relative URI constructed from the string value "deutsch" includes provisions that equate "ss" and the (German) character "ß" ("sharp-s"). (Otherwise, the returned value depends on the semantics of that collation.)
fn:compare('Strassen', 'Straße') returns 1 if the default collation includes provisions that treat differences between"ss" and the (German) character "ß" ("sharp-s")with less strengththan thedifferences between the base characters, such as the final"n".

7.4 Functions on String Values

The following functions are defined on values of typexs:stringand types derived from it. Several of these functions use collations.See 7.3.1 Collations for a discussion of collations.

Function	Meaning

Note:

Whenthe above operators and functions are applied to datatypes derived from xs:string, they are guaranteed to return legal xs:strings, but they might not return a legal value for the particular subtype to which they were applied.

7.4.1 fn:concat

fn:concat(

$arg1 as xs:string?

, $arg2 as xs:string?

, ...) as xs:string

Summary: Accepts two or more xs:strings as arguments. Returns the xs:string that is the concatenation of the values of its arguments. If any of the arguments is the empty sequence, the argument is treated as the zero-length string.

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

7.4.1.1 Examples

fn:concat('un', 'grateful') returns " ungrateful ".
fn:concat('Thy ', (), 'old ', "groans ", "", ' ring', ' yet', ' in', ' my', 'ancient',' ears.') returns " Thy old groans ring yet in my ancient ears. ".
fn:concat('Ciao!',()) returns " Ciao! ".
fn:concat('Ingratitude, ', 'thou', 'marble-hearted', ' fiend!') returns " Ingratitude,thou marble-hearted fiend! ".

7.4.2 fn:string-join

fn:string-join(

$arg1 as xs:string*

, $arg2 as xs:string

) as xs:string

Summary: Returns a xs:string created by concatenating the members of the $arg1 sequence using $arg2 as a separator. 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 zero-length string is returned.

7.4.2.1 Examples

fn:string-join(('Now', 'is', 'the', 'time', '...'), ' ') returns "Now is the time ...".
fn:string-join(('Blow, ', 'blow,', 'thou ', 'winter ', 'wind!'), '') returns " Blow, blow, thou winter wind!".
fn:string-join((), 'separator') returns "".
Assume a document:
```
<doc>
  <chap>
    <section>
    </section>
  </chap>
</doc>
```
with the <section> as the context node, the [XPath 2.0] expression:
fn:string-join(for $n in ancestor-or-self::* return name($n), '/')
returns "doc/chap/section"

7.4.3 fn:substring

`fn:substring`(	`$sourceString`	`as` `xs:string?`,
`fn:substring`(	`$startingLoc`	`as` `xs:double`) `as` `xs:string`

`fn:substring`(	`$sourceString`	`as` `xs:string?`,
	`$startingLoc`	`as` `xs:double`,
	`$length`	`as` `xs:double`) `as` `xs:string`

Summary: Returns the portion of the valueof $sourceString beginning at the position indicated bythe value of $startingLoc and continuing for the number of charactersindicated by the value of $length. More specifically, returns the characters in $sourceString whoseposition $pobeys:

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

Inthe abovecomputation, the rules for op:numeric-less-than()and op:numeric-greater-than() apply.

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

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

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

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

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

7.4.3.1 Examples

fn:substring("motor car", 6) returns " car".
Characters starting at position 6 to the end of $sourceString are selected.
fn:substring("metadata", 4, 3) returns "ada".
Characters at positions greater than or equal to 4 and less than 7 are selected.
fn:substring("12345", 1.5, 2.6) returns "234".
Characters at positions greater than or equal to 2 and less than 5 are selected.

fn:substring("12345",0, 3) returns"12".

Characters at positions greaterthan or equal to 0 and less than 3 are selected.

fn:substring("12345", 5, -3) returns "".

Charactersat positions greater than orequal to 5 and less than 2 areselected.

fn:substring("12345",0 div 0E0.0, 3)returns "".

Since 0 div 0 returns NaN,and NaNcompared to any othernumber returns false, no characters are selected.

fn:substring("12345",1, 0 div 0E0.0) returns "".

As above.

fn:substring((),1, 3)returns "".

Asabove.

fn:substring("12345", -42, 1 div 0E0.0) returns "12345".

Characters at positions greater than or equal to -42 and less thanINF are selected.

fn:substring("12345",-1 div 0E0.0, 1div 0E0.0)returns "".

Since-INF+ INFreturns NaN,no characters are selected.

7.4.4 fn:string-length

fn:string-length() as xs:integer

fn:string-length($arg as xs:string) as xs:integer

Summary: Returnsan xs:integer equal to the length in characters of the value of $arg.

If the value of $argis the empty sequence, the xs:integer 0 isreturned.

If no argument is supplied, $argdefaults to the string value (calculated using fn:string())of the context item (.).

7.4.4.1 Examples

fn:string-length("Harp not on that string, madam; that is past.") returns 45.
fn:string-length(()) returns 0.

7.4.5 fn:normalize-space

fn:normalize-space() as xs:string

fn:normalize-space($arg as xs:string?) as xs:string

Summary: Returnsthe valueof $argwith whitespacenormalized by stripping leading andtrailingwhitespace and replacing sequences ofone or more than one whitespace character with a single space, #x20.

The whitespace charactersare defined in [XML 1.0 Recommendation (Second Edition)]as TAB(#x9),LINE FEED (#xA),CARRIAGE RETURN (#xD) and SPACE (#x20). If the value of $arg is the empty sequence, returns the zero-length string. Ifno argument is supplied, $arg defaults tothe string value (calculated using fn:string()) of the context item (.).

7.4.5.1 Examples

fn:normalize-space("The wealthy curled darlings of our nation. ") returns "Thewealthy curled darlings of our nation.".
fn:normalize-space(()) returns "".

7.4.6 fn:normalize-unicode
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 the valueof
					$arg normalized according to the
					normalization criteria for a normalizationform
					identified by the value of
					$normalizationForm.  The effective
					valueof the $normalizationFormis
					computedby removing leading and trailing blanks,
					ifpresent, and convertingto upper case.
 If the value of  $arg isthe empty sequence, returns
					thezero-length string.
See[Character Model for the World Wide Web 1.0] 
fora description of
					the normalization forms.
Ifthe $normalizationFormis absent, as in the first format above, it shall be assumed tobe "NFC"
If the effective value of $normalizationForm is "NFC",then the valuereturned
					by the function is the value of $arg in Unicode Normalization Form C (NFC).
Ifthe effective value of $normalizationForm is "NFD",then the value returned by the function isthe value of $argin Unicode Normalization Form D (NFD).
Ifthe effective value of$normalizationForm is"NFKC",then the value returned bythe function is the value of $arg in UnicodeNormalization Form KC (NFKC).
If the effective value of $normalizationForm
is "NFKD",then the valuereturned by the function is the value of $arg in Unicode Normalization Form KD (NFKD).
If the effective value of $normalizationForm is "fully-normalized",then the valuereturned by the function is thevalue
					of $arg is the fullynormalized form.

Ifthe effective value of $normalizationForm isthe zero-length string, no normalization is performed and $arg isreturned.
Conformingimplementations ·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.  Ifthe effective value of the $normalizationFormis other than one of the values supported bythe implementation, then an error is raised [unsupported normalization form].


7.4.7 fn:upper-case
fn:upper-case($arg as xs:string?) as xs:string
Summary:Returns the value of $srcvalafter translating every
     characterto its upper-case correspondent. Every character that does
     nothave an upper-case correspondent is included in the returned value
     inits original form. The precise mapping is determined using [Unicode Case Mappings].

									If thevalue of  $arg is the
					empty sequence, the zero-length string is returned.
Note:
Case mappings may change
thelength of a string.  In general, the two functions are not inverses of each other
					fn:lower-case(fn:upper-case($arg)) is not 
guaranteedto return $arg, nor is
fn:upper-case(fn:lower-case($arg)).The Latin small letter dotless i (as used in Turkish) is
         perhapsthe most prominentlower-case letterwhich willnot
         round-trip.  TheLatin capital letter i with dot above is the most
         prominentupper-case letter which will not round trip; there are
         others.

Thesefunctions maynot alwaysbe linguistically appropriate (e.g. Turkish i
withoutdot) or appropriate for the application (e.g. titlecase).Incases such as Turkish,a simple translation should be used
first.
 
Resultsmay violateuser expectations(in Quebec,for example, the
         standarduppercase equivalent of "è"is "È", while inmetropolitan
         Franceit is morecommonly "E";onlyone of these issupported by
         thefunctions as defined).

       Manycharacters of class Ll lack uppercase equivalents in the
         Unicodecase mappingtables;
         manycharacters of class Lu lacklowercase equivalents.

7.4.7.1 Examples

									fn:upper-case("abCd0") returns "ABCD0".


7.4.8 fn:lower-case
fn:lower-case($arg as xs:string?) as xs:string
Summary, returns the valueof $srcval after translating every
     characterto its lower-case correspondent. Every character that does
     not have anlower-case correspondent is included in the returned value
     in its original form. The precise mapping is determined using [Unicode Case Mappings].
 If the value of  $arg is the
					empty sequence, the zero-length string is returned.
Note:
Case  mappings may change
thelength ofa string.  In general,the two functions are not inverses of eachother
					fn:lower-case(fn:upper-case($arg))is not 
guaranteedto return $arg, nor isfn:upper-case(fn:lower-case($arg)). The Latin small letter dotless i (as used inTurkish) is
         perhaps the most prominent lower-case letter which will not
         round-trip.  TheLatin capital letter i with dot above isthe most
         prominentupper-case letter which will not round trip; there are
         others.

Thesefunctions may not always be linguistically appropriate (e.g. Turkish i
withoutdot) or appropriate for the application (e.g. titlecase).
In cases suchas Turkish, a simple translation should be used
first.
 
Resultsmay violate user expectations (in Quebec, for example, the
         standard uppercase equivalent of "è" is "È", while in metropolitan
         France it is more commonly "E"; onlyone of these is supported by
         the functions as defined).

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

7.4.8.1 Examples

									fn:lower-case("ABc!D") returns "abc!d".


7.4.9 fn:translate
fn:translate( $arg  as xs:string?,
$mapString  as xs:string,
$transString  as xs:string) as xs:string
Summary:Returns the value of $arg
					modified so that every characterin the value of
					$arg thatoccurs at some position
					Nin the value of
					$mapString hasbeen replaced by the
					characterthatoccursat position N
					in the valueof $transString. 
 If the value of  $arg is the
					empty sequence, the zero-length string is returned.
Every character in the value of $arg thatdoes not appear in the value of $mapString is unchanged.
Every characterin the value of
					$arg that appears at some position
					Min the value of
					$mapString, wherethe value of
					$transStringis less than
					M characters in length, isomitted
					from the returned value. If
					$mapString isthe zero-length
					string $arg isreturned.
If a character occurs more than oncein $mapString,
					then the first occurrence determines the
					replacement character.If
					$transString is longer than $mapString,the excess characters areignored.

7.4.9.1 Examples

									fn:translate("bar","abc","ABC") returns "BAr" 

									fn:translate("--aaa--","abc-","ABC") returns"AAA".

									fn:translate("abcdabc", "abc", "AB") returns "ABdAB".


7.4.10 fn:escape-uri
fn:escape-uri( $uri-part  as xs:string?,
$escape-reserved  as xs:boolean) as xs:string
Summary: This function applies the URI escaping
					rulesdefined in section 2 of [RFC 2396]as amended by [RFC 2732], with one exception,  tothe string supplied as$uri-part, which typically represents allor part of a URI.The effect of the function is toreplace any special character in the string by an escape sequence

ofthe form %HH, whereHH... is the hexadecimal representation of theoctets used to represent thecharacter in UTF-8. 
The set of characters that
are escapeddepends on the setting of the boolean argument
  $escape-reserved.
If $uri-part is the empty sequence, returns the
					zero-length string.
If $escape-reserved is
					true, all characters are escaped
					other than the lower case lettersa-z, the upper case
					lettersA-Z, the digits 0-9, the PERCENT SIGN "%" andthe NUMBER SIGN "#" characters andthe characters
					referredto in[RFC 2396]as "marks":
					specifically,HYPHEN-MINUS ("-"),  LOWLINE ("_"),
					FULLSTOP ".",  EXCLAMATIONMARK "!",  TILDE"~",
					ASTERISK  "*", APOSTROPHE "'",  LEFT PARENTHESIS
					"(", and RIGHT PARENTHESIS ")". 

 
If$escape-reservedis
					false,the behavior differs in that
					charactersreferred to in [RFC 2396]
					and[RFC 2732]as reserved
					characters,together with the NUMBER SIGN '#'
					character,(See [Uniform Resource Identifiers (URI): Generic Syntax])are not escaped. These charactersare
					SEMICOLON
						";", SOLIDUS"/",
							
							
								
									QUESTION MARK"?",
							
						
					
				
				
					COLON ":", COMMERCIAL AT "@",  AMPERSAND "&",
						
						
					EQUALS SIGN "=", PLUS SIGN "+",  DOLLAR SIGN "$",
					COMMA "," NUMBER SIGN "#", LEFT SQUARE BRACKET "["
						
							
						
					and RIGHT SQUARE BRACKET "]".

						[RFC 2396]does not define whetherescaped URIs should use lower case or upper case for hexadecimal digits. To ensure that escaped URIs can be compared using string comparisonfunctions, this function mustalways generate hexadecimal values using the upper-case lettersA-F.
Generally,$escape-reservedshould be set totrue when escaping a string that is to form a single partof a URI, and to false when escaping an entire URI or URI reference. 

7.4.10.1 Examples

									fn:escape-uri ("http://www.example.com/spinaltap.micro.umn.edu/00/Weather/CA/Los%20Angeles#ocean", true()) returns "http%3A%2F%2Fwww.example.com%2Fspinaltap.micro.umn.edu%2F00%2FWeather%2FCA%2FLos%20Angeles%23ocean"
								

									fn:escape-uri ("http://example.com/spinaltap.micro.umn.edu/00/Weather/CA/Los%20Angeles#ocean",false()) returns"http://example.com/spinaltap.micro.umn.edu/00/Weather/CA/Los%20Angeles#ocean"


7.5 Functions Based on Substring Matching
The functions described in thesection examine a string $arg1to see whetherit contains another string $arg2 as a substring. The result depends on whether $arg2 isa substring of $arg1,and if so, onthe range of characters in $arg1which $arg2matches.

Inthe absenceof a collation argument, or when the Unicode code point
Collationis used, this simply involvesdetermining whether
$arg1 contains a contiguous sequence of characters whose
codepoints are the same, one for one, withthe code points of the characters in $arg2.

When a collationis specified, the rules are more complex.
Allcollations support the capability of decidingwhether two strings
areconsidered equal, andif not, which of thestrings should be regarded as
precedingthe other. For functions such as fn:compare(), 
this is all that is required.For other functions, such as
fn:contains() , the collation needs to support an
additionalproperty:it must be able to decomposethe stringinto asequence
ofcollationunits, each unit consisting of one or more characters, such that two
stringscan be compared by pairwise comparisonof these units. The
string$arg1 is then considered to contain
$arg2as a substring if the sequence of collation units
corresponding to $arg2 is a subsequence of thesequence
ofthe collation units corresponding to$arg1. The characters in $arg1that match are the characters correspondingto 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, inwhich 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 expressionfn:contains("Jaeger","eg")will return false. 
The results of these functions thus depends stronglyon the properties of the 
collationthat is used.

Inthe definitions below, we say that$arg1contains
		$arg2at positions mthrough
		nif the collation units corresponding to
		charactersin positions mto nof
		$arg1are the same as the collation units
		correspondingto all the characters of
					$arg2.In
		thesimple case of the Unicode codepoint collation, thecollation units are the same as thecharacters
					
					
						of thestring.

It is possible to definecollations that do not have the abilityto
decomposea string into unitssuitable for substring matching.  
Anargument to afunction defined in this
sectionmay be a URI that identifies a collation that is able to
comparetwo strings, but that does not have the capability to split
thestring into
					collationunits.Such a collationmay fail, orgive unexpected
resultsand the system may rejectit.

7.5.1 fn:contains
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
Summary:Returns anxs:boolean indicating whether or
					not the value of $arg1 contains(at
					thebeginning, at the end, or anywherewithin) a
					sequenceof collation units thatmatch the
					collation units of $arg2
					accordingto the collation that is used.
The collation used by theinvocation of this functionis determined
					accordingto therules in 7.3.1 Collations.  If the specified collationis
					unsuitable for this function an error ·may· be raised[collation unsuitable for this function].
 If the value of  $arg1 or
					$arg2 is the empty sequence, it is
					interpretedas the zero-length string. 
Ifthe value of $arg2is the zero-lengthstring, then the function returns true.
Ifthe value of $arg1is the zero-length string, the function returns false. 		

7.5.1.1 Examples
Thecollation used for the purposes of these examples is the Unicode default collation.

									fn:contains("goldenrod","rod") returns true.  

									fn:contains("", "rod") returns false. 

									fn:contains((),"") returns true. 

7.5.2 fn:starts-with
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
Summary: Returns an xs:boolean indicating whether or
					not the value of $arg1 starts with a
					sequence of collation units that matches the
					collation units of $arg2 according to the collation that is used. 
If the value of $arg1 or
					$arg2 is the empty sequence, it is
					interpretedas the zero-length string.
If the value of$arg2 is the zero-lengthstring, then the function returns true.  If the value of $arg1is the zero-length string and the value of$arg2 is not the zero-length string, then the function returns false. 
The collation used bythe invocation of this functionis determined
					accordingto the rules in 7.3.1 Collations. If the specifiedcollation is
					unsuitable for this function an error ·may·be raised [collation unsuitable for this function].

7.5.2.1 Examples
The collation used for the purposes of these examples is the Unicode default collation.

									fn:starts-with("goldenrod", "gold") returns true. 

									fn:starts-with("goldenrod","rod") returns false.

									fn:starts-with("goldenrod","") returns true.

									fn:starts-with("How sharper thana serpent's tooth it is
tohave a thankless child!", "How sharp") returns true. 

									fn:starts-with((), "")returns true.

7.5.3 fn:ends-with
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
Summary: Returns an xs:boolean indicating whetheror
not the value of $arg1ends with a sequence of collation
units that match the collation units of $arg2 according to the specified collation.
Ifthe valueof $arg1or $arg2is the empty sequence, it is
					interpretedas the zero-length string.
Ifthe value of $arg2is the zero-length string, then the function returns true.  Ifthe value of $arg1 is the zero-length stringand the value of$arg2is not the zero-length string, then the function returns false.
The collationused by the invocation of this functionis determined
according to the rules in 7.3.1 Collations.If the specified collation is
					unsuitablefor this function an error ·may·be raised [collation unsuitable for this function].

7.5.3.1 Examples
The collationused for the purposes of these examples is the Unicodedefault collation.

									fn:ends-with("goldenrod","rod") returns true. 

									fn:ends-with("","rod")returns false.

									fn:ends-with((),"")returns true.

7.5.4 fn:substring-before
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
Summary:Returns the substring of the value of $arg1 that precedesin the value of $arg1the first occurrence of a string that is equal to the value of $arg2according to the collation that is used.
If the value of  $arg1or
					$arg2is the empty sequence, it is interpreted as the zero-length string.
Ifthe value of $arg2is the
zero-lengthstring, then the function returns the zero-length string.
If thevalue of$arg1does not
					containa string that is equal to thevalue of
					$arg2,then the function returns the
					zero-length string. 
Thecollation used by the invocation of this function is determined
accordingto the rules in 7.3.1 CollationsIf the specified collation is
					unsuitablefor this function an error ·may·be raised [collation unsuitable for this function].

7.5.4.1 Examples

									fn:substring-before("xpath-functions.xml",".") returns "xpath-functions". 

									fn:substring-before("Baloney!","") returns "Baloney!".

7.5.5 fn:substring-after
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
Summary: Returns the substring of the value of $arg1that follows in the value of $arg1the first occurrence of astring that is equal to the value of $arg2according to the collation that is used. 
If the value of  $arg1 or
					$arg2 isthe empty sequence, it is interpreted as the zero-length string.
If thevalue of $arg2 is the zero-length string, then the function returns the valueof $arg1.
If the value of $arg1 does not
containa string that is equal to the value of $arg2,
then the function returns the zero-length string. 
The collation used bythe invocation of this function is determined
according to therules in 7.3.1 CollationsIf the specified collation is
					unsuitable for this functionan error ·may· be raised [collation unsuitable for this function].

7.5.5.1 Examples

									fn:substring-after("antidisestablishmentarianism","dis") returns "establishmentarianism". 
								

									fn:substring-after("Who
									there?","") returns
									"Who there?".


7.6 String Functions that Use Pattern Matching
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 an xs:boolean value that indicates whether the value of the first argument is matched by the regular expression that is the value of the second argument. 

								fn:replace
							 Returns the value of the first argument with every substring matched by the regular expression that is the value of the second argument replaced by the replacement string that is the value of the third argument. 

								fn:tokenize
							 Returns a sequence of one or more xs:strings whose values are substrings of the value of the first argument separated by substrings that match the regular expression that is the value of the second argument.

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

7.6.1.1 Flags
All these functions provide an optional
						parameter, $flags, toset options
						for the interpretation of the regular
						expression. The parameter accepts a xs:string, in
						which individualletters are used to set
						options.The presence of a letter within the
						string indicates that the option is on; its
						absence indicates thatthe 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 [invalid regular expression flags].
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
metacharacter . matches any character except a newline
(#x0A) character. In 
dot-all mode, the metacharacter . matches any character whatsoever. Suppose
the input contains "hello" and "world" on two lines. This will not be
matched by the regular expression "hello.*world"unless dot-all mode is
enabled.

									m: If present, the match operates in multi-line mode. By default, the
metacharacter ^ 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.

									i: If present, the match operates in case-insensitive mode. Otherwise, the match operates incase-sensitive mode. In case-sensitive mode, a character in the input string matches a character specified by the pattern only if the Unicode code-points match. In case-insensitive mode, a character in the input string matches a character specified by the pattern if there is a canonical caseless match between the two characters as defined in section 2.5 of [Unicode Case Mappings].

x: If present, whitespace characters within the regular
expression are ignored.  By default, whitespace characters match
themselves.  This allows, for example, regular expressions to be broken up into
lines for readability.
The regular expression syntax and semantics are identical to those defined in [XML Schema Part 2: Datatypes] with the following additions:
 Two meta-characters, ^ and $ are added. Bydefault, the metacharacter ^
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]:
          			[10] Char ::= [^.\?*+()|#x5B#x5D]
is modified to read:
          			[10] Char ::= [^.\?*+()|^$#x5B#x5D]
The characters #x5B and #x5D correspond to "["and "]"respectively.
The following production:
          [11] charClass ::= charClassEsc | charClassExpr | WildCardEsc
is modified to read:
          [11] charClass ::= charClassEsc | charClassExpr | WildCardEsc | "^" | "$"
In string mode, the metacharacter
								. matches any character
								whatsoever. In multiline mode, the
								metacharacter . matches
								any character except a newline
								(#x0A) character. Suppose
								the input contains "hello" and "world"
								on two lines.  This will not be
								matched by the regular expression
								"hello.*world" in
								multiline mode. 

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

									[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] allows a
								regular expression to contain
								parenthesized sub-expressions, but
								attaches no special significance to
								them. The fn:replace()
								function described below allows access
								to the parts of the input string that
								matched a sub-expression (called
								captured substrings). The
								sub-expressions are numbered according
								to the position of the opening
								parenthesis in left-to-right order
								within the top-level regular
								expression: the first opening
								parenthesis identifies captured
								substring 1, the second identifies
								captured substring 2, and so on. 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.

Back-referencesare allowed. The construct \nwhere n isa single
digitis alwaysrecognized as a back-reference; if this is followed by
furtherdigits,these digitsare takento bepart of the back-referenceif
andonly if the back-reference is preceded by sufficiently many capturing
subexpressions.A back-reference matches the string that wasmatched by the
n'th capturing subexpression within the regular expression, that is, the
parenthesizedsubexpression whose opening left parenthesis is then'th
unescapedleft parenthesis within the regular expression. The closing right
parenthesisof this subexpression must occur before the back-reference. For
example,the regular expression ('|").*\1matches a sequence of characters
delimitedeither by an apostrophe at the start and end, or by aquotation
markat the startand end. 
Backreferences change the followingproduction:
          [23]charClassEsc	::=( SingleCharEsc | MultiCharEsc | catEsc |
complEsc  )
to
          [23]charClassEsc	::=(SingleCharEsc |MultiCharEsc | catEsc |
complEsc| backReference )
          [23a]backReference ::= "\" [0-9]+ 	

							
						

7.6.2 fn:matches
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
Summary: The function returns true if
					$input matches the regular expression
					supplied as $pattern as influenced by
					the value of $flags, if present; otherwise, it returns false. 
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 Flags.
If $input is the empty sequence, itis interpretedas thezero-length string.
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). 
Note:
This is different from the behavior of patterns in [XML Schema Part 2: Datatypes], where regular expressions are implicitly anchored.
An error is raised [invalid regular expression]if the value of $pattern is invalid according to the rules described in section 7.6.1 Regular Expression Syntax. 
An error is raised [invalid regular expression flags]if the value of $flags is invalid according to the rules described in section 7.6.1 Regular Expression Syntax. 

						
					

						
					

						
					

7.6.2.1 Examples

									fn:matches("abracadabra", "bra") returns true

									fn:matches("abracadabra", "^a.*a$") returns true

									fn:matches("abracadabra", "^bra") returns false
Given the source document:
<poem author="Wilhelm Busch"> 
Kaum hat dies der Hahn gesehen,
Fängt er auch schon an zu krähen:
«Kikeriki! Kikikerikih!!»
Tak, tak, tak! - da kommen sie.
</poem>
the following function calls produce the following results, with the poem element as the context node:

									fn:matches(., "Kaum.*krähen") returns false

									fn:matches(., "Kaum.*krähen", "s") returns true

									fn:matches(., "^Kaum.*gesehen,$", "m") returns true

									fn:matches(., "^Kaum.*gesehen,$") returns false

									fn:matches(., "kiki", "i") returns true
Note:
Regular expression matching is defined on the basis of Unicode code-points; it takes no account of collations.

7.6.3 fn:replace
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
Summary: 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.
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 Flags.
The $flags argument is interpreted in the same manner as for the fn:matches() function. 
If $input is the empty sequence, itis interpretedas the zero-lengthstring.
If two overlapping substrings of $input both match the $pattern, then only the first one (that is, the one whose first character comes first in the $input string) is replaced.
Within the $replacement string,
the variables $1 to $9 may be used to refer
to the substring captured by each of the first nine parenthesized
sub-expressions in the regular expression. $0 refers
to the substring captured by the regular expression as a whole.
A literal "$" symbol must be written as "\$". A literal "\" symbol must be written as "\\".
 
For each match of the pattern, these variables are assigned the value of the content of the relevant captured sub-expression, and the modified replacement string is then substituted for the characters in $input that matched the pattern.
If a variable $n is present in the replacement string, but there is no nth captured substring (which may happen because there were fewer than n parenthesized sub-expressions, or because the nth parenthesized sub-expression was not matched) then the variable is replaced by a zero-length string.

If two alternatives within the pattern both match at the same position in the $input, then the match that is chosen is the one matched by the first alternative. For example:
fn:replace("abcd", "(ab)|(a)", "[1=$1][2=$2]") returns "[1=ab][2=]cd" 
An error is raised [invalid regular expression]if the value of $pattern is invalid according to the rules described in section 7.6.1 Regular Expression Syntax. 
An error is raised [invalid regular expression flags]if the value of $flags is invalid according to the rules described in section 7.6.1 Regular Expression Syntax. 
An error is raised [regular expression matches zero-length string]if the patternmatches 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 [invalid replacement string]if the value of $replacement contains a "$" character that is not immediately followed by a digit 1-9 and not immediately preceded by a "\".
An error is raised [invalid replacement string]if the value of $replacement contains a "\" character that is not part of a "\\" pair, unless it is immediately followed by a "$" character.

						
					

7.6.3.1 Examples

									replace("abracadabra", "bra", "*") returns "a*cada*"
								

									replace("abracadabra", "a.*a", "*") returns "*"
								

									replace("abracadabra", "a.*?a", "*") returns "*c*bra"
								

									replace("abracadabra", "a", "") returns "brcdbr"
								

									replace("abracadabra", "a(.)", "a$1$1") returns "abbraccaddabbra"
								
replace("abracadabra", ".*?", "$1") raises an error, because the pattern matches the zero-length string
								
replace("AAAA", "A+",
								"b") returns "b"
replace("AAAA", "A+?",
								"b") returns "bbbb"
replace("darted",
								"^(.*?)d(.*)$", "$1c$2")
								returns
								"carted".
								The first
								"d" is replaced.

7.6.4 fn:tokenize
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+
Summary: This function breaks the $input string into a sequence of strings, treating any substring that matches $pattern as a separator. The separators themselves are not returned.
The 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 Flags.
 The $flags argument is interpreted in the same way as for the fn:matches() function.
If $input is the empty sequence,
					the result is the zero-length string.
If the supplied $pattern matches a zero-length string, thatis, if fn:matches("",$pattern, $flags) returnstrue,then an error is raised: [regular expression matches zero-length string].
If a separator occurs at the start of the $input string, the result sequence will start with a zero-length string. Zero-length strings will also occur in the result sequence if a separator occurs at the end of the $input string, or if two adjacent substrings match the supplied $pattern.

If two alternatives within the supplied $pattern both match at the same position in the $input string, then the match that is chosen is the first. For example:
fn:tokenize("abracadabra", "(ab)|(a)") returns ("", "r", "c", "d", "r", "")

An error is raised [invalid regular expression]if the value of $pattern is invalid according to the rules described in section 7.6.1 Regular Expression Syntax.
 
An error is raised [invalid regular expression flags]if the value of $flags is invalid according to the rules described in section 7.6.1 Regular Expression Syntax.

7.6.4.1 Examples

									fn:tokenize("The cat sat on the mat", "\s+") returns ("The", "cat", "sat", "on", "the", "mat")
								

									fn:tokenize("1, 15, 24, 50", ",\s*") returns ("1", "15", "24", "50")
								

									fn:tokenize("1,15,,24,50,", ",") returns ("1", "15", "", "24", "50", "")
								
fn:tokenize("abba", ".?")
							raises the error [regular expression matches zero-length string].
fn:tokenize("Some unparsed <br> HTML <BR> text", "\s*<br>\s*", "i") returns ("Some unparsed", "HTML", "text")

Function	Meaning
`fn:matches`	Returns an `xs:boolean` value that indicates whether the value of the first argument is matched by the regular expression that is the value of the second argument.
`fn:replace`	Returns the value of the first argument with every substring matched by the regular expression that is the value of the second argument replaced by the replacement string that is the value of the third argument.
`fn:tokenize`	Returns a sequence of one or more `xs:string`s whose values are substrings of the value of the first argument separated by substrings that match the regular expression that is the value of the second argument.


8 Functions and Operators on Boolean Values
This section defines functionsand operators on the [XML Schema Part 2: Datatypes] boolean datatype.

8.1 Additional Boolean Constructor Functions
The following additional constructor functions are defined on the boolean type. 
Function Meaning

								fn:true
							

								fn:false
							

8.1.1 fn:true
fn:true() as xs:boolean
Summary: Returns the xs:boolean value
					true. Equivalent to xs:boolean("1").

8.1.1.1 Examples

									fn:true() returns true. 

8.1.2 fn:false
fn:false() as xs:boolean
Summary: Returns the xs:boolean value false. Equivalent to xs:boolean("0").

8.1.2.1 Examples

									fn:false() returns false. 

8.2 Operators on Boolean Values
The following functions define the semantics of
				operatorson boolean values in [XQuery 1.0: An XML Query Language] and [XPath 2.0]:
Operator Meaning

								op:boolean-equal
							 Equality of xs:boolean values

								op:boolean-less-than
							 A less-than operator on xs:boolean values: false is less than true.

								op:boolean-greater-than
							 A greater-than operator on xs:boolean values: true is greater than false.
The ordering operators op:boolean-less-than and
op:boolean-greater-than are provided for application purposes and for
compatibility with [XPath 1.0].  The [XML Schema Part 2: Datatypes]
			datatype xs:boolean is not ordered.

8.2.1 op:boolean-equal
op:boolean-equal($value1 as xs:boolean, $value2 as xs:boolean) as xs:boolean
Summary:Returns true if both arguments are true or if both arguments are false.  Returnsfalse if one of the arguments is true and the other argument is false. 
This function backs up the "eq" operator on xs:boolean values. 

8.2.2 op:boolean-less-than
op:boolean-less-than($arg1 as xs:boolean
, $arg2 as xs:boolean
) as xs:boolean
Summary: Returns true if $arg1 is false and $arg2 is true.  Otherwise, returns false.
This function backs up the "lt" and "ge" operators on xs:boolean values. 

8.2.3 op:boolean-greater-than
op:boolean-greater-than($arg1 as xs:boolean
, $arg2 as xs:boolean
) as xs:boolean
Summary: Returns true if $arg1 is true and $arg2 is false.  Otherwise, returns false.
This function backs up the "gt" and "le" operators on xs:boolean values. 

8.3 Functions on Boolean Values
The following functions are defined on boolean values:
Function Meaning

								fn:not
							 Inverts the xs:boolean value of the argument.

8.3.1 fn:not
fn:not($arg as item()*
) as xs:boolean
Summary: $arg is first reduced to
					an effective boolean value by applying the
					fn:boolean() function. 
					Returns true if the effective boolean value is false, and false if the effective boolean value is true. 

8.3.1.1 Examples

									fn:not(fn:true()) returns false.

Function	Meaning
`fn:true`
`fn:false`

Operator	Meaning
`op:boolean-equal`	Equality of `xs:boolean` values
`op:boolean-less-than`	A less-than operator on `xs:boolean` values: `false` is less than `true`.
`op:boolean-greater-than`	A greater-than operator on `xs:boolean` values: `true` is greater than `false`.

Function	Meaning
`fn:not`	Inverts the `xs:boolean` value of the argument.


9 Functions and Operators on Durations, Dates and Times
This section discusses operations on the [XML Schema Part 2: Datatypes] date and time types.  Italso discusses operations on two subtypes of xs:duration that are defined in this document.  See 9.2 Two Totally Ordered Subtypes of Duration.
The functions described in this section follow the principle of
			locale-independent storage for these datatypes that
			originated with [XML Schema Part 2: Datatypes].  Thus, a single
			calendar (Gregorian) and a single timezone (UTC) is chosen
			to represent normalized date and time values.  Since the
			value tuple (See Section 
3.3.1 Mapping PSVI Additions to Types^DM) also contains the timezone specified in the
			lexical representation, applicationsand other processing systems are free to present this information in locale-specific representations.

				
			

				
			

				
			

				
			

9.1 Duration, Date and Time Types
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
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 the 9.2 Two Totally Ordered Subtypes of Duration:
xdt:yearMonthDuration
xdt:dayTimeDuration
No operators are defined on the [XML Schema Part 2: Datatypes] datatype 
xs:duration.
Appendix C.6 Working With xs:duration Values discusses how
to work with xs:duration values.

9.1.1 Limits
 andPrecision
For a number of the above datatypes [XML Schema Part 2: Datatypes] extends the basic [ISO 8601] lexical representations, such as 
YYYY-MM-DDThh:mm:ss.s for dateTime, by allowing 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. 
For this specification, all minimally conforming processors must support year values with a minimum of 4 digits (i.e., YYYY) and a minimum fractional second precision of 1 millisecond or three digits (i.e., s.sss). However, conforming processors may set larger ·implementation-defined· limits on the maximum number of digits they support in these two situations.
A processor that limits the number of digits in
				date and time datatype representations may encounter
				overflow and underflow conditions when it tries to
				execute the functions in 9.7 Adding and Subtracting Durations From dateTime, date and time.  In these situations, the processor ·must· return zero in case of underflow and ·must· raise an error [overflow in date/time arithmetic]in case of overflow.
The value spaces of the two totally ordered subtypes of xs:duration described in 9.2 Two Totally Ordered Subtypes of Duration are xs:integer months for xdt:yearMonthDuration and xs:decimal seconds for xdt:dayTimeDuration.  If a processor limits the number of digits allowed in the representation of xs:integer and xs:decimal then overflow and underflow situations can arise when it tries to execute the functions in 9.5 Arithmetic Functions on xdt:yearMonthDuration and xdt:dayTimeDuration.  In these situations the processor ·must· return zero in case of underflow and ·must· raise an error [overflow in duration arithmetic]in case of overflow.

					
				

9.2 Two Totally Ordered Subtypes of Duration
Two totally ordered subtypes of xs:duration are defined in this specification using the mechanisms described in [XML Schema Part 2: Datatypes] for defining user-defined types. They are available in the namespace http://www.w3.org/2003/11/xpath-datatypes.
Note:
The W3C XML Query Working Group has requested the W3C XML Schema Working Group that these two subtypes of xs:duration be included in the built-in datatypes described in [XML Schema Part 2: Datatypes].  If the W3C XML Schema Working Group agrees to this request, these two datatypes will be removed from the above name space and moved into the XML Schema namespace http://www.w3.org/2001/XMLSchema.

9.2.1 xdt:yearMonthDuration

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

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

9.2.1.1 Lexical representation
The lexical representation for xdt: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 xdt:yearMonthDuration of 1 year, 2 months, one would write: P1Y2M. One could also indicate a xdt: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 prededing digit and M must have one preceding digit.

9.2.1.2 Calculating the value from the lexical representation
The value of a xdt: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.

9.2.1.3 Canonical representation
The canonical representation of xdt: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.  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".

9.2.1.4 Order relation on xdt:yearMonthDuration
Let the function that calculates the value of an xdt:yearMonthDuration in the manner described above  be called V(d).   Then for two xdt:yearMonthDuration values x and y, x > y if and only if V(x) > V(y). The order relation on yearMonthDuration is a total order.

9.2.2 xdt:dayTimeDuration
[Definition] xdt: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 xdt:dayTimeDuration is the set of fractional second values. The components of xdt:dayTimeDuration correspond to the day, hour, minute and second components defined in Section 5.5.3.2 of [ISO 8601], respectively. xdt:dayTimeDuration is derived from xs:duration as follows.  To make the long pattern easier to read, it has been formatted on six lines using additional new line andspace characters in the pattern string.  These additional characters should notbe interpreted as part of 
the pattern.
<xs:simpleType name='dayTimeDuration'>
    <xs:restriction base='xs:duration'>
     	 <xs:pattern value="[\-]?P([0-9]+D(T([0-9]+(H([0-9]+(M([0-9]+(\.[0-9]*)?S
     	 	|\.[0-9]+S)?|(\.[0-9]*)?S)|(\.[0-9]*)?S)?|M([0-9]+
     	 	(\.[0-9]*)?S|\.[0-9]+S)?|(\.[0-9]*)?S)|\.[0-9]+S))?
     	 	|T([0-9]+(H([0-9]+(M([0-9]+(\.[0-9]*)?S|\.[0-9]+S)?
     	 	|(\.[0-9]*)?S)|(\.[0-9]*)?S)?|M([0-9]+(\.[0-9]*)?S|\.[0-9]+S)?
     	 	|(\.[0-9]*)?S)|\.[0-9]+S))"/>
    </xs:restriction>
</xs:simpleType>

9.2.2.1 Lexical representation
The lexical representation for xdt: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 P4D251M are all allowed. P-134D is not allowed (invalid location of minus sign), although -P134D is allowed. 

9.2.2.2 Calculating the value of a xdt:dayTimeDuration from the lexical representation
The value of a xdt: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.

9.2.2.3 Canonical representation
The canonical representation of xdt: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], 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. 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".

9.2.2.4 Order relation on xdt:dayTimeDuration
Let the function that calculates the value of a xdt:dayTimeDuration in the manner described above be called V(d).   Then for two xdt:dayTimeDuration values x and y, x > y if and only if V(x) > V(y). The order relation on xdt:dayTimeDuration is a total order. 

9.3 Comparisons of Duration, Date and Time Values
Operator Meaning

								op:yearMonthDuration-equal
							 Equality comparison on xdt:yearMonthDuration values

								op:yearMonthDuration-less-than
							 Less-than comparison on xdt:yearMonthDuration values

								op:yearMonthDuration-greater-than
							 Greater-than comparison on xdt:yearMonthDuration values

								op:dayTimeDuration-equal
							 Equality comparison on xdt:dayTimeDuration values

								op:dayTimeDuration-less-than
							 Less-than comparison on xdt:dayTimeDuration values

								op:dayTimeDuration-greater-than
							 Greater-than comparison on xdt:dayTimeDuration values

								op:dateTime-equal
							 Equality comparison on xs:dateTime values

								op:dateTime-less-than
							 Less-than comparison on xs:dateTime values

								op:dateTime-greater-than
							 Greater-than comparison on xs:dateTime values

								op:date-equal
							 Equality comparison on xs:date values

								op:date-less-than
							 Less-than comparison on xs:date values

								op:date-greater-than
							 Greater-than comparison on xs:date values

								op:time-equal
							 Equality comparison on xs:time values

								op:time-less-than
							 Less-than comparison on xs:time values

								op:time-greater-than
							 Greater-than comparison on xs:time values

								op:gYearMonth-equal
							 Equality comparison on xs:gYearMonth values

								op:gYear-equal
							 Equality comparison on xs:gYear values

								op:gMonthDay-equal
							 Equality comparison on xs:gMonthDay values

								op:gMonth-equal
							 Equality comparison on xs:gMonth values

								op:gDay-equal
							 Equality comparison on xs:gDay values
The following comparison operators are defined on the [XML Schema Part 2: Datatypes] date, time and duration datatypes. Each operator takes two operands of the same type and returns a boolean result. As discussed in [XML Schema Part 2: Datatypes], the order relation on xs:duration and the date and time datatypes is not a total order but, rather, a partial order.  For this reason, no functions are defined on xs:duration.  A full complement of comparison and arithmetic functions are defined on the two subtypes of duration described in 9.2 Two Totally Ordered Subtypes of Duration.
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 evaluation context, is assumed to be present as part of the value.  This creates a total order for all date and time values. The order relations on date and time datatypes is defined in [XML Schema Part 2: Datatypes].
Note that for xs:dateTime, xs:date and xs:time, as discussed in 1.6 xs:dateTime,of xs:date andargument(s).  These xs:time values the value is defined as a tuple.  Comparison operators on these three datatypes operate on the first, or normalized value, part of the tuple and disregard the second, or timezone, part of the tuple.  If the timezone part is (), the implicit timezone is used to adjust the normalized value as necessary.

					
				

				
			

9.3.1 op:yearMonthDuration-equal
op:yearMonthDuration-equal( $arg1  as xdt:yearMonthDuration,
$arg2  as xdt:yearMonthDuration) as xs:boolean
Summary: Returns true if and only if $arg1 is equal to $arg2. Returns false otherwise.
This function backs up the "eq" and "ne" operators on xdt:yearMonthDuration values.

9.3.2 op:yearMonthDuration-less-than
op:yearMonthDuration-less-than( $arg1  as xdt:yearMonthDuration,
$arg2  as xdt:yearMonthDuration) as xs:boolean
Summary: Returns true if and only if $arg1 is less than $arg2. Returns false otherwise.
This function backs up the "lt" and "ge" operators on xdt:yearMonthDuration values.

9.3.3 op:yearMonthDuration-greater-than
op:yearMonthDuration-greater-than( $arg1  as xdt:yearMonthDuration,
$arg2  as xdt:yearMonthDuration) as xs:boolean
Summary: Returns true if and only if $arg1 is greater than $arg2. Returns false otherwise.
This function backs up the "gt" and "le" operators on xdt:yearMonthDuration values.

9.3.4 op:dayTimeDuration-equal
op:dayTimeDuration-equal( $arg1  as xdt:dayTimeDuration,
$arg2  as xdt:dayTimeDuration) as xs:boolean
Summary: Returns true if and only if the value of $arg1 is equal to the value of $arg2. Returns false otherwise.
This function backs up the "eq" and "ne" operators on xdt:dayTimeDuration values.

9.3.5 op:dayTimeDuration-less-than
op:dayTimeDuration-less-than( $arg1  as xdt:dayTimeDuration,
$arg2  as xdt:dayTimeDuration) as xs:boolean
Summary: Returns true if and only if $arg1 is less than $arg2. Returns false otherwise.
This function backs up the "lt" and "ge" operators on xdt:dayTimeDuration values.

9.3.6 op:dayTimeDuration-greater-than
op:dayTimeDuration-greater-than( $arg1  as xdt:dayTimeDuration,
$arg2  as xdt:dayTimeDuration) as xs:boolean
Summary: Returns true if and only if $arg1 is greater than $arg2. Returns false otherwise.
This function backs up the "gt" and "le" operators on xdt:dayTimeDuration values.

9.3.7 op:dateTime-equal
op:dateTime-equal($arg1 as xs:dateTime
, $arg2 as xs:dateTime
) as xs:boolean
Summary: Returns true if and only if the normalized value of $arg1 is equal to the normalized value of $arg2. Returns false otherwise.
This function backs up the "eq" and "ne" operators on xs:dateTime values.

9.3.7.1 Examples
Assume that the evaluation context provides an implicit timezone value of -5:00.

									op:dateTime-equal(xs:dateTime("2002-04-02T12:00:00-01:00"), xs:dateTime("2002-04-02T17:00:00+04:00")) returns true.

									op:dateTime-equal(xs:dateTime("2002-04-02T12:00:00"), xs:dateTime("2002-04-02T23:00:00+06:00")) returns true.

									op:dateTime-equal(xs:dateTime("2002-04-02T12:00:00"), xs:dateTime("2002-04-02T17:00:00")) returns false.

									op:dateTime-equal(xs:dateTime("2002-04-02T12:00:00"), xs:dateTime("2002-04-02T12:00:00")) returns true.

9.3.8 op:dateTime-less-than
op:dateTime-less-than($arg1 as xs:dateTime
, $arg2 as xs:dateTime
) as xs:boolean
Summary: Returns true if and only if the normalized value of $arg1 is less than the normalized value of $arg2. Returns false otherwise.
This function backs up the "lt" and "ge" operators ond xs:dateTime values.

9.3.9 op:dateTime-greater-than
op:dateTime-greater-than( $arg1  as xs:dateTime,
$arg2  as xs:dateTime) as xs:boolean
Summary: Returns true if and only if the normalized value of $arg1 is greater than the normalized value of $arg2. Returns false otherwise.
This function backs up the "gt" and "le" operators on xs:dateTime values.

9.3.10 op:date-equal
op:date-equal($arg1 as xs:date
, $arg2 as xs:date
) as xs:boolean
Summary: Returns true if and only if the normalized value of $arg1 is equal to the normalized value of $arg2. Returns false otherwise.
This function backs up the "eq" and "ne" operators on xs:date values.

9.3.11 op:date-less-than
op:date-less-than($arg1 as xs:date
, $arg2 as xs:date
) as xs:boolean
Summary: Returns true if and only if the normalized value of $arg1 is less than the normalized value of $arg2. Returns false otherwise.
This function backs up the "lt" and "ge" operators on xs:date values.

9.3.12 op:date-greater-than
op:date-greater-than($arg1 as xs:date
, $arg2 as xs:date
) as xs:boolean
Summary: Returns true if and only if the normalized value of $arg1 is greater than the normalized value of $arg2. Returns false otherwise.
This function backs up the "gt" and "le" operators on xs:date values.

9.3.13 op:time-equal
op:time-equal($arg1 as xs:time
, $arg2 as xs:time
) as xs:boolean
Summary: Returns true if and only if the normalized value of $arg1 is equal to the normalized value of $arg2. Returns false otherwise.
This function backs up the "eq" and "ne" operators on xs:time values.

9.3.14 op:time-less-than
op:time-less-than($arg1 as xs:time
, $arg2 as xs:time
) as xs:boolean
Summary: Returns true if and only if the normalized value of $arg1 is less than the normalized value of $arg2. Returns false otherwise.
This function backs up the "lt" and "ge" operators on xs:time values.

9.3.14.1 Examples
Assume that the evaluation context provides an implicit timezone value of -5:00.

									op:time-less-than(xs:time("12:00:00"), xs:time("23:00:00+06:00")) returns false.

									op:time-less-than(xs:time("11:00:00"), xs:time("17:00:00")) returns true.

									op:time-less-than(xs:time("23:00:00"), xs:time("01:00:00-01:00")) returns false since it compares the normalized values 04:00:00Z (23:00:00 adjusted with the implicit timezone -05:00) and 02:00:00Z.

9.3.15 op:time-greater-than
op:time-greater-than($arg1 as xs:time
, $arg2 as xs:time
) as xs:boolean
Summary: Returns true if and only if the normalized value of $arg1 is greater than the normalized value of $arg2. Returns false otherwise.
This function backs up the "gt" and "le" operators on xs:time values.

9.3.16 op:gYearMonth-equal
op:gYearMonth-equal( $arg1  as xs:gYearMonth,
$arg2  as xs:gYearMonth) as xs:boolean
Summary: Returns true if and only if the normalized value of $arg1 is equal to the normalized value of $arg2. Returns false otherwise.
This function backs up the "eq" and "ne" operators on xs:gYearMonth values.

9.3.17 op:gYear-equal
op:gYear-equal($arg1 as xs:gYear
, $arg2 as xs:gYear
) as xs:boolean
Summary: Returns true if and only if the normalized value of $arg1 is equal to the normalized value of $arg2. Returns false otherwise.
This function backs up the "eq" and "ne" operators on xs:gYear values.

9.3.18 op:gMonthDay-equal
op:gMonthDay-equal($arg1 as xs:gMonthDay
, $arg2 as xs:gMonthDay
) as xs:boolean
Summary: Returns true if and only if the normalized value of $arg1 is equal to the normalized value of $arg2. Returns false otherwise.
This function backs up the "eq" and "ne" operators on xs:gMonthDay values.

9.3.19 op:gMonth-equal
op:gMonth-equal($arg1 as xs:gMonth
, $arg2 as xs:gMonth
) as xs:boolean
Summary: Returns true if and only if the normalized value of $arg1 is equal to the normalized value of $arg2. Returns false otherwise.
This function backs up the "eq" and "ne" operators on xs:gMonth values.

9.3.20 op:gDay-equal
op:gDay-equal($arg1 as xs:gDay
, $arg2 as xs:gDay
) as xs:boolean
Summary: Returns true if and only if the normalized value of $arg1 is equal to the normalized value of $arg2. Returns false otherwise.
This function backs up the "eq" and "ne" operators on xs:gDay values.

9.4 Component Extraction Functions on Duration, Date and Time Values
The duration, date and time datatypes may be
				considered to be composite datatypes in that they
				contain distinct components.  The extraction functions
				specified below extract a single component from a
				duration, date or time value. For
				xs:dateTime, xs:date and
				xs:time the localized value is used.
To get the value of a component from the normalized value, the xs:dateTime, xs:date or
				xs:time must first be adjusted to UTC or
				timezone Z.  This is illustrated in some
				of the examples in this section.

					
				
Function Meaning

								fn:get-years-from-yearMonthDuration
							 Returns the year component of an xdt:yearMonthDuration value. 

								fn:get-months-from-yearMonthDuration
							 Returns the months component of an xdt:yearMonthDuration value.

								fn:get-days-from-dayTimeDuration
							 Returns the days component of an xdt:dayTimeDuration value. 

								fn:get-hours-from-dayTimeDuration
							 Returns the hours component of an xdt:dayTimeDuration value. 

								fn:get-minutes-from-dayTimeDuration
							 Returns the minutes component of an xdt:dayTimeDuration value. 

								fn:get-seconds-from-dayTimeDuration
							 Returns the seconds component of an xdt:dayTimeDuration value. 

								fn:get-year-from-dateTime
							 Returns the year from an xs:dateTime value.

								fn:get-month-from-dateTime
							 Returns the month from an xs:dateTime value. 

								fn:get-day-from-dateTime
							 Returns the day from an xs:dateTime value. 

								fn:get-hours-from-dateTime
							 Returns the hours from an xs:dateTime value. 

								fn:get-minutes-from-dateTime
							 Returns the minutes from an xs:dateTime value.

								fn:get-seconds-from-dateTime
							 Returns the seconds from an xs:dateTime value.

								fn:get-timezone-from-dateTime
							 Returns the timezone from an xs:dateTime value. 

								fn:get-year-from-date
							 Returns the year from an xs:date value. 

								fn:get-month-from-date
							 Returns the month from an xs:date value. 

								fn:get-day-from-date
							 Returns the day from an xs:date value. 

								fn:get-timezone-from-date
							 Returns the timezone from an xs:date value. 

								fn:get-hours-from-time
							 Returns the hours from an xs:time value. 

								fn:get-minutes-from-time
							 Returns the minutes from an xs:time value. 

								fn:get-seconds-from-time
							 Returns the seconds from an xs:time value. 

								fn:get-timezone-from-time
							 Returns the timezone from an xs:time value. 

9.4.1 fn:get-years-from-yearMonthDuration
fn:get-years-from-yearMonthDuration( $arg  as xdt:yearMonthDuration?) as xs:integer?
Summary: Returns an xs:integer representing the years component in the canonical lexical representation of the value of $arg. The result may be negative.
 If $arg is the empty sequence, returns the empty sequence.

9.4.1.1 Examples

									fn:get-years-from-yearMonthDuration(xdt:yearMonthDuration("P20Y15M")) returns 21.

									fn:get-years-from-yearMonthDuration(xdt:yearMonthDuration("-P15M")) returns -1.

9.4.2 fn:get-months-from-yearMonthDuration
fn:get-months-from-yearMonthDuration( $arg  as xdt:yearMonthDuration?) as xs:integer?
Summary: Returns an xs:integer representing the months component in the canonical lexical representation of the value of $arg. The result may be negative. 
If $arg is the empty sequence, returns the empty sequence.

9.4.2.1 Examples

									fn:get-months-from-yearMonthDuration(xdt:yearMonthDuration("P20Y15M")) returns 3.

									fn:get-months-from-yearMonthDuration(xdt:yearMonthDuration("-P20Y18M")) returns -6.

9.4.3 fn:get-days-from-dayTimeDuration
fn:get-days-from-dayTimeDuration($arg as xdt:dayTimeDuration?
) as xs:integer?
Summary: Returns an xs:integer representing the days component in the canonical lexical representation of the value of $arg. The result may be negative.
 If $arg is the empty sequence, returns the empty sequence.

9.4.3.1 Examples

									fn:get-days-from-dayTimeDuration(xdt:dayTimeDuration("P3DT10H")) returns 3.

									fn:get-days-from-dayTimeDuration(xdt:dayTimeDuration("P3DT55H")) returns 5.

9.4.4 fn:get-hours-from-dayTimeDuration
fn:get-hours-from-dayTimeDuration($arg as xdt:dayTimeDuration?
) as xs:integer?
Summary: Returns an xs:integer representing the hours component in the canonical lexical representation of the value of $arg. The result may be negative.
 If $arg is the empty sequence, returns the empty sequence.

9.4.4.1 Examples

									fn:get-hours-from-dayTimeDuration(xdt:dayTimeDuration("P3DT10H")) returns 10.

									fn:get-hours-from-dayTimeDuration(xdt:dayTimeDuration("P3DT12H32M12S")) returns 12.

									fn:get-hours-from-dayTimeDuration(xdt:dayTimeDuration("PT123H")) returns 3.

									fn:get-hours-from-dayTimeDuration(xdt:dayTimeDuration("-P3DT10H")) returns -10.

9.4.5 fn:get-minutes-from-dayTimeDuration
fn:get-minutes-from-dayTimeDuration( $arg  as xdt:dayTimeDuration?) as xs:integer?
Summary: Returns an xs:integer representing the minutes component in the canonical lexical representation of the value of $arg. The result may be negative.
 If $arg is the empty sequence, returns the empty sequence.

9.4.5.1 Examples

									fn:get-minutes-from-dayTimeDuration(xdt:dayTimeDuration("P3DT10H")) returns 0.

									fn:get-minutes-from-dayTimeDuration(xdt:dayTimeDuration("-P5DT12H30M")) returns -30.

9.4.6 fn:get-seconds-from-dayTimeDuration
fn:get-seconds-from-dayTimeDuration( $arg  as xdt:dayTimeDuration?) as xs:decimal?
Summary: Returns an xs:decimal representing the seconds component in the canonical lexical representation of the value of $arg. The result may be negative.
 If $arg is the empty sequence, returns the empty sequence.

9.4.6.1 Examples

									fn:get-seconds-from-dayTimeDuration(xdt:dayTimeDuration("P3DT10H12.5S")) returns 12.5.

									fn:get-seconds-from-dayTimeDuration(xdt:dayTimeDuration("-P256S")) returns -16.0.

9.4.7 fn:get-year-from-dateTime
fn:get-year-from-dateTime($arg as xs:dateTime?
) as xs:integer?
Summary: Returns an xs:integer representing the year component in the localized value of $arg. The result may be negative.
 If $arg is the empty sequence, returns the empty sequence.

9.4.7.1 Examples

									fn:get-year-from-dateTime(xs:dateTime("1999-05-31T13:20:00-05:00")) returns 1999.

									fn:get-year-from-dateTime(xs:dateTime("1999-05-31T21:30:00-05:00")) returns 1999.

									fn:get-year-from-dateTime(xs:dateTime("1999-12-31T19:20:00")) returns 1999.

9.4.8 fn:get-month-from-dateTime
fn:get-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 value of $arg.
 If $arg is the empty sequence, returns the empty sequence.

9.4.8.1 Examples

									fn:get-month-from-dateTime(xs:dateTime("1999-05-31T13:20:00-05:00")) returns 5. 

									fn:get-month-from-dateTime(xs:dateTime("1999-12-31T19:20:00-05:00")) returns 12. 

									fn:get-month-from-dateTime(fn:adjust-dateTime-to-timezone(xs:dateTime("1999-12-31T19:20:00-05:00"),
									xdt:dayTimeDuration("PT0H"))) returns 1. 

9.4.9 fn:get-day-from-dateTime
fn:get-day-from-dateTime($arg as xs:dateTime?
) as xs:integer?
Summary: Returns an xs:integer between 1 and 31, both inclusive, representing the day component in the localized value of $arg.
 If $arg is the empty sequence, returns the empty sequence.

9.4.9.1 Examples

									fn:get-day-from-dateTime(xs:dateTime("1999-05-31T13:20:00-05:00")) returns 31. 

									fn:get-day-from-dateTime(xs:dateTime("1999-12-31T20:00:00-05:00")) returns 31. 

									fn:get-day-from-dateTime(fn:adjust-dateTime-to-timezone(xs:dateTime("1999-12-31T19:20:00-05:00"),
									xdt:dayTimeDuration("PT0H"))) returns 1. 

9.4.10 fn:get-hours-from-dateTime
fn:get-hours-from-dateTime($arg as xs:dateTime?
) as xs:integer?
Summary: Returns an xs:integer between 0 and 23, both inclusive, representing the hours component in the localized value of $arg.
 If $arg is the empty sequence, returns the empty sequence. 

9.4.10.1 Examples

									fn:get-hours-from-dateTime(xs:dateTime("1999-05-31T08:20:00-05:00"))returns 8.

									fn:get-hours-from-dateTime(xs:dateTime("1999-12-31T21:20:00-05:00")) returns 21. 

									fn:get-hours-from-dateTime(fn:adjust-dateTime-to-timezone(xs:dateTime("1999-12-31T21:20:00-05:00"), xdt:dayTimeDuration("PT0H"))) 
									) returns 2. 

									fn:get-hours-from-dateTime(xs:dateTime("1999-12-31T12:00:00"))
									returns 12. 

9.4.11 fn:get-minutes-from-dateTime
fn:get-minutes-from-dateTime($arg as xs:dateTime?
) as xs:integer?
Summary: Returns an xs:integer value between 0 and 59, both inclusive, representing the minute component in the localized value of $arg.
  If $arg is the empty sequence, returns the empty sequence. 

9.4.11.1 Examples

									fn:get-minutes-from-dateTime(xs:dateTime("1999-05-31T13:20:00-05:00")) returns 20 . 

									fn:get-minutes-from-dateTime(xs:dateTime("1999-05-31T13:30:00+05:30")) returns 0 . 

9.4.12 fn:get-seconds-from-dateTime
fn:get-seconds-from-dateTime($arg as xs:dateTime?
) as xs:decimal?
Summary: Returns an xs:decimal value between 0 and 60.999..., both inclusive representing the seconds and fractional seconds in the localized value of $arg.  Note that the value can be greater than 60 seconds to accomodate occasional leap seconds used to keep human time synchronized with the rotation of the planet.
  If $arg is the empty sequence, returns the empty sequence.

9.4.12.1 Examples

									fn:get-seconds-from-dateTime(xs:dateTime("1999-05-31T13:20:00-05:00")) returns 0. 

9.4.13 fn:get-timezone-from-dateTime
fn:get-timezone-from-dateTime($arg as xs:dateTime?
) as xdt:dayTimeDuration?
Summary: Returns the timezone component of $arg.  The result is an xdt:dayTimeDuration that indicates deviation from UTC; its value may range from +14:00 to -14:00 hours, both inclusive.
.If  $arg is the empty sequence, returns the empty sequence. 

						
					

						
					

9.4.13.1 Examples

									fn:get-timezone-from-dateTime(xs:dateTime("1999-05-31T13:20:00-05:00")) returns the xdt:dayTimeDuration whose value is -PT5H. 

									fn:get-timezone-from-dateTime(xs:dateTime("2000-06-12T13:20:00Z")) returns the xdt:dayTimeDuration whose value is -PT0H. 

									fn:get-timezone-from-dateTime(xs:dateTime("2004-08-27T00:00:00")) returns (). 

9.4.14 fn:get-year-from-date
fn:get-year-from-date($arg as xs:date?
) as xs:integer?
Summary: Returns an xs:integer representing the year in the localized value of $arg.  The value may be negative. 
If $arg is the empty sequence, returns the empty sequence.

9.4.14.1 Examples

									fn:get-year-from-date(xs:date("1999-05-31")) returns 1999. 

									fn:get-year-from-date(xs:date("2000-01-01+05:00")) returns 2000. 

9.4.15 fn:get-month-from-date
fn:get-month-from-date($arg as xs:date?
) as xs:integer?
Summary: Returns an xs:integer between 1 and 12, both inclusive, representing the month component in the localized value of $arg. 
If $arg is the empty sequence, returns the empty sequence.

9.4.15.1 Examples

									fn:get-month-from-date(xs:date("1999-05-31-05:00")) returns 5 . 

									fn:get-month-from-date(xs:date("2000-01-01+05:00")) returns 1 . 

9.4.16 fn:get-day-from-date
fn:get-day-from-date($arg as xs:date?
) as xs:integer?
Summary: Returns an xs:integer between 1 and 31, both inclusive, representing the day component in the localized value of $arg.
 If $arg is the empty sequence, returns the empty sequence.

9.4.16.1 Examples

									fn:get-day-from-date(xs:date("1999-05-31-05:00")) returns 31. 

									fn:get-day-from-date(xs:date("2000-01-01+05:00")) returns 01. 

9.4.17 fn:get-timezone-from-date
fn:get-timezone-from-date($arg as xs:date?
) as xdt:dayTimeDuration?
Summary: Returns the timezone component in the value of $arg.  The result is an xdt:dayTimeDuration that indicates deviation from UTC; its value may range from +14:00 to -14:00 hours, both inclusive.
  If $arg is the empty sequence, returns the empty sequence.

9.4.17.1 Examples

									fn:get-timezone-from-date(xs:date("1999-05-31-05:00")) returns the xdt:dayTimeDuration whose value is -PT5H. 

									fn:get-timezone-from-date(xs:date("2000-06-12Z")) returns the xdt:dayTimeDuration with value PT0H.

9.4.18 fn:get-hours-from-time
fn:get-hours-from-time($arg as xs:time?
) as xs:integer?
Summary: Returns an xs:integer between 0 and 23, both inclusive, representing the value of the hours component in the localized value of $arg.
  If $arg is the empty sequence, returns the empty sequence. 

9.4.18.1 Examples
Assume that the evaluation context provides an implicit timezone value of -05:00.

									fn:get-hours-from-time(xs:time("11:23:00")) returns 11. 

									fn:get-hours-from-time(xs:time("21:23:00")) returns 21. 

									fn:get-hours-from-time(xs:time("01:23:00+05:00")) returns 1. 

									fn:get-hours-from-time(fn:adjust-time-to-timezone(xs:time("01:23:00+05:00"),
									xdt:dayTimeDuration("PT0H"))) returns 16. 

9.4.19 fn:get-minutes-from-time
fn:get-minutes-from-time($arg as xs:time?
) as xs:integer?
Summary: Returns an xs:integer value between 0 to 59, both inclusive, representing the value of the minutes component in the localized value of $arg.
 If $arg is the empty sequence, returns the empty sequence.

9.4.19.1 Examples

									fn:get-minutes-from-time(xs:time("13:00:00Z")) returns 0 . 

9.4.20 fn:get-seconds-from-time
fn:get-seconds-from-time($arg as xs:time?
) as xs:decimal?
Summary: Returns an xs:decimal value between 0 and  60.999..., both inclusive, representing the seconds and fractional seconds in the localized value of $arg. Note that the value can be greater than 60 seconds to accomodate occassional leap seconds used to keep human time synchronized with the rotation of the planet.
  If $arg is the empty sequence, returns the empty sequence.

9.4.20.1 Examples

									fn:get-seconds-from-time(xs:time("13:20:10.5")) returns 10.5. 

9.4.21 fn:get-timezone-from-time
fn:get-timezone-from-time($arg as xs:time?
) as xdt:dayTimeDuration?
Summary: Returns an xdt:dayTimeDuration representing the timezone component of $arg.  The result is a xdt:dayTimeDuration that indicates deviation from UTC; its value may range from +14:00 to -14:00 hours, both inclusive.
 If $arg is the empty sequence, returns the empty sequence.

9.4.21.1 Examples

									fn:get-timezone-from-time(xs:time("13:20:00-05:00")) returns xdt:dayTimeDuration whose value is -PT5H.

									fn:get-timezone-from-time(xs:time("13:20:00")) returns ().

9.5 Arithmetic Functions on xdt:yearMonthDuration and xdt:dayTimeDuration
Function Meaning

								op:add-yearMonthDurations
							 Adds two xdt:yearMonthDurations.  Returns an xdt:yearMonthDuration.

								op:subtract-yearMonthDurations
							 Subtracts one xdt:yearMonthDuration from another.  Returns an xdt:yearMonthDuration.

								op:multiply-yearMonthDuration
							 Multiplies a xdt:yearMonthDuration by an xs:decimal.  Returns an xdt:yearMonthDuration.

								op:divide-yearMonthDuration
							 Divides an xdt:yearMonthDuration by an xs:decimal.  Returns an xdt:yearMonthDuration.

								op:add-dayTimeDurations
							 Adds two xdt:dayTimeDurations.  Returns an xdt:dayTimeDuration.

								op:subtract-dayTimeDurations
							 Subtracts one xdt:dayTimeDuration from another.  Returns an xdt:dayTimeDuration.

								op:multiply-dayTimeDuration
							 Multiplies an xdt:dayTimeDuration by a xs:decimal.  Returns an xdt:dayTimeDuration.

								op:divide-dayTimeDuration
							 Divides an xdt:dayTimeDuration by an xs:decimal.  Returns an xdt:dayTimeDuration.

9.5.1 op:add-yearMonthDurations
op:add-yearMonthDurations( $arg1  as xdt:yearMonthDuration,
$arg2  as xdt:yearMonthDuration) as xdt:yearMonthDuration
Summary: Returns the result of adding the value of $arg1 to the value of 
$arg2.  Backs up the "+" operator on xdt:yearMonthDuration values.

9.5.1.1 Examples

									op:add-yearMonthDurations(xdt:yearMonthDuration("P2Y11M"), xdt:yearMonthDuration("P3Y3M")) returns a xdt:yearMonthDuration value corresponding to 6 years and 2 months. 

9.5.2 op:subtract-yearMonthDurations
op:subtract-yearMonthDurations( $arg1  as xdt:yearMonthDuration,
$arg2  as xdt:yearMonthDuration) as xdt:yearMonthDuration
Summary: Returns the result of subtracting the value of 
$arg2 from the value of $arg2.  Backs up the "-" operator on xdt:yearMonthDuration values.

9.5.2.1 Examples

									op:subtract-yearMonthDurations(xdt:yearMonthDuration("P2Y11M"), xdt:yearMonthDuration("P3Y3M")) returns a xdt:yearMonthDuration value corresponding to negative 4 months. 

9.5.3 op:multiply-yearMonthDuration
op:multiply-yearMonthDuration( $arg1  as xdt:yearMonthDuration,
$arg2  as xs:double) as xdt:yearMonthDuration
Summary: Returns the result of multiplying the value of
					$arg1 by $arg2.  The
					result is rounded to the nearest month.  For a
					value v, 0 <= v <
					0.5  rounds to 0; 0.5 <= v <
					1.0 rounds to 1.
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
 andCONFORMANCE Precision.  If
					$arg2 is NaN an error is raised
					[NaN supplied as float/double value]
Backs up the "*" operator on xdt:yearMonthDuration values.

9.5.3.1 Examples

									op:multiply-yearMonthDuration(xdt:yearMonthDuration("P2Y11M"), 2.3) returns a xdt:yearMonthDuration value corresponding to 6 years and 9 months. 

9.5.4 op:divide-yearMonthDuration
op:divide-yearMonthDuration( $arg1  as xdt:yearMonthDuration,
$arg2  as xs:double) as xdt:yearMonthDuration
Summary: Returns the result of dividing the value of
					$arg1 by $arg2.  The
					result is rounded to the nearest month.  For a
					value v, 0 <= v <
					0.5  rounds to 0; 0.5 <= v <
					1.0 rounds to 1.
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
 andCONFORMANCE Precision.  If
					$arg2 is NaN an error is raised
					[NaN supplied as float/double value]
Backs up the "div" operator on xdt:yearMonthDuration values.

9.5.4.1 Examples

									op:divide-yearMonthDuration(xdt:yearMonthDuration("P2Y11M"), 1.5) returns a xdt:yearMonthDuration value corresponding to 1 year and 11 months. 

9.5.5 op:add-dayTimeDurations
op:add-dayTimeDurations( $arg1  as xdt:dayTimeDuration,
$arg2  as xdt:dayTimeDuration) as xdt:dayTimeDuration
Summary: Returns the result of adding the value of $arg1 to the value of $arg2.  Backs up the "+" operator on xdt:dayTimeDuration values.

9.5.5.1 Examples

									op:add-dayTimeDurations(xdt:dayTimeDuration("P2DT12H5M"), xdt:dayTimeDuration("P5DT12H")) returns a xdt:dayTimeDuration value corresponding to 8 days and 5 minutes. 

9.5.6 op:subtract-dayTimeDurations
op:subtract-dayTimeDurations( $arg1  as xdt:dayTimeDuration,
$arg2  as xdt:dayTimeDuration) as xdt:dayTimeDuration
Summary: Returns the result of subtracting the value of $arg2 from the value of $arg2.  Backs up the "-" operator on xdt:dayTimeDuration values.

9.5.6.1 Examples

									op:subtract-dayTimeDurations(xdt:dayTimeDuration("P2DT12H"), xdt:dayTimeDuration("P1DT10H30M")) returns a xdt:dayTimeDuration value corresponding to 1 day, 1 hour and 30 minutes. 

9.5.7 op:multiply-dayTimeDuration
op:multiply-dayTimeDuration( $arg1  as xdt:dayTimeDuration,
$arg2  as xs:double) as xdt:dayTimeDuration
Summary: Returns the result of multiplying the value of
					$arg1 by $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 9.1.1 Limits
 andCONFORMANCE Precision.  If
					$arg2 is NaN an error is raised
					[NaN supplied as float/double value]
Backs up the "*" operator on
					xdt:dayTimeDuration values.

9.5.7.1 Examples

									op:multiply-dayTimeDuration(xdt:dayTimeDuration("PT2H10M"), 2.1) returns a xdt:dayTimeDuration value corresponding to 4 hours and 33 minutes. 

9.5.8 op:divide-dayTimeDuration
op:divide-dayTimeDuration( $arg1  as xdt:dayTimeDuration,
$arg2  as xs:double) as xdt:dayTimeDuration
Summary: Returns the result of dividing the value of
					$arg1 by $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
 andCONFORMANCE Precision.  If
					$arg2 is NaN an error is raised
					[NaN supplied as float/double value]
Backs up the "div" operator on xdt:dayTimeDuration values.

9.5.8.1 Examples

									op:divide-dayTimeDuration(xdt:yearMonthDuration("P1DT2H30M10.5S"), 1.5) returns a xdt:dayTimeDuration value corresponding to 17 hours, 40 minutes and 7 seconds. 

9.6 Timezone Adjustment on dateTime, date and time Values
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 all.

								fn:adjust-time-to-timezone
							 Adjusts an xs:time value to a specific timezone, or to no timezone at all.
Thesefunctions adjust an xs:dateTime,
xs:date or xs:timevalue to thegiven or
implicittimezone.

9.6.1 fn:adjust-dateTime-to-timezone
fn:adjust-dateTime-to-timezone($arg as xs:dateTime?
) as xs:dateTime?
fn:adjust-dateTime-to-timezone( $arg  as xs:dateTime?,
$timezone  as xdt:dayTimeDuration?) as xs:dateTime?
Summary: Adjusts an xs:dateTime value to a specific timezone, or to no timezone at all. If $timezone is the empty sequence, returns an xs:dateTime
without a timezone. Otherwise, returns an xs:dateTime with a timezone.

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

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

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

If $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 the result is an xs:dateTime value with a timezone component of $timezone that is equal to $arg.

9.6.1.1 Examples

Assume the evaluation context provides an implicit timezone of -5:00
(-PT5H0M).
let $tz := xdt:dayTimeDuration("-PT10H")

   fn:adjust-dateTime-to-timezone(xs:dateTime("2002-03-07T10:00:00"))
   returns 2002-03-07T10:00:00-05:00

   fn:adjust-dateTime-to-timezone(xs:dateTime("2002-03-07T10:00:00-07:00"))
   returns 2002-03-07T12:00:00-05:00

   fn:adjust-dateTime-to-timezone(xs:dateTime("2002-03-07T10:00:00"),
   $tz)
   returns 2002-03-07T10:00:00-10:00

   fn:adjust-dateTime-to-timezone(xs:dateTime("2002-03-07T10:00:00-07:00"), $tz)
   returns 2002-03-07T07:00:00-10:00

   fn:adjust-dateTime-to-timezone(xs:dateTime("2002-03-07T10:00:00-07:00"), xdt:dayTimeDuration("PT10H"))
   returns 2002-03-08T03:00:00+10:00

   fn:adjust-dateTime-to-timezone(xs:dateTime("2002-03-07T00:00:00+01:00"), xdt:dayTimeDuration("-PT8H"))
   returns 2002-03-06T15:00:00-08:00

   fn:adjust-dateTime-to-timezone(xs:dateTime("2002-03-07T10:00:00"), ())
   returns 2002-03-07T10:00:00

   fn:adjust-dateTime-to-timezone(xs:dateTime("2002-03-07T10:00:00-07:00"), ())
   returns 2002-03-07T10:00:00

9.6.2 fn:adjust-date-to-timezone
fn:adjust-date-to-timezone($arg as xs:date?
) as xs:date?
fn:adjust-date-to-timezone( $arg  as xs:date?,
$timezone  as xdt:dayTimeDuration?) as xs:date?
Summary: Adjusts an xs:date value to a
					specific timezone, or to no timezone at all. If
					$timezone is the empty sequence,
					returns an xs:date without a
					timezone. Otherwise, returns an
					xs:date with a timezone. For purposes of timezone adjustment, an xs:date is treated as an xs:dateTime with time 00:00:00.

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

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

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

If $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 value of $arg without its timezone component.

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

9.6.2.1 Examples

Assume the evaluation context provides an implicit timezone of -5:00
(-PT5H0M).
let $tz := xdt:dayTimeDuration("-PT10H")
fn:adjust-date-to-timezone(xs:date("2002-03-07"))
   returns 2002-03-07-05:00.
fn:adjust-date-to-timezone(xs:date("2002-03-07-07:00"))
   returns 2002-03-07-05:00.$arg is
   converted to the
   xs:dateTime "2002-03-07T00:00:00-07:00".  This is
   adjusted to the implicit timezone, giving "2002-03-07T02:00:00-05:00".
fn:adjust-date-to-timezone(xs:date("2002-03-07"), $tz)
   returns 2002-03-07-10:00.
fn:adjust-date-to-timezone(xs:date("2002-03-07-07:00"), $tz)
   returns 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".
fn:adjust-date-to-timezone(xs:date("2002-03-07"), ())
   returns 2002-03-07.
fn:adjust-date-to-timezone(xs:date("2002-03-07-07:00"), ())
   returns 2002-03-07.

9.6.3 fn:adjust-time-to-timezone
fn:adjust-time-to-timezone($arg as xs:time?) as xs:time?
fn:adjust-time-to-timezone( $arg  as xs:time?,
$timezone  as xdt:dayTimeDuration?) as xs:time?

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

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

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

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

If $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 $srcdt be an xs:dateTime value, with an arbitrary date for the date component and time and timezone components that are the same as the time and timezone components of $arg.

Let $r be the result of evaluating
fn:adjust-dateTime-to-timezone($srcdt, $timezone)

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

9.6.3.1 Examples

Assume the evaluation context provides an implicit timezone of -5:00
(-PT5H0M).
let $tz := xdt:dayTimeDuration("-PT10H")
fn:adjust-time-to-timezone(xs:time("10:00:00"))
   returns 10:00:00-05:00
fn:adjust-time-to-timezone(xs:time("10:00:00-07:00"))
   returns 12:00:00-05:00
fn:adjust-time-to-timezone(xs:time("10:00:00"), $tz)
   returns 10:00:00-10:00
fn:adjust-time-to-timezone(xs:time("10:00:00-07:00"), $tz)
   returns 07:00:00-10:00
fn:adjust-time-to-timezone(xs:time("10:00:00"), ())
   returns 10:00:00
fn:adjust-time-to-timezone(xs:time("10:00:00-07:00"), ())
   returns 10:00:00
fn:adjust-time-to-timezone(xs:time("10:00:00-07:00"),
   xdt:dayTimeDuration("PT10H"))
   returns 03:00:00+10:00

9.7 Adding and Subtracting Durations From dateTime, date and time
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] describes an algorithm for performing such operations.
If any of the arguments to the functions below is an xs:dateTime, xs:date or xs:time that does not contain an explicit timezone then, for the purpose of the operation, an implicit timezone, provided by the evaluation context, is assumed to be present as part of the value.
Function Meaning

								fn:subtract-dateTimes-yielding-yearMonthDuration
							 Returns the difference between two xs:dateTimes as an xdt:yearMonthDuration.

								fn:subtract-dateTimes-yielding-dayTimeDuration
							 Returns the difference between two xs:dateTimes as an xdt:dayTimeDuration.

								op:subtract-dates
							 Returns the difference between two xs:dates as an xdt:dayTimeDuration.

								op:subtract-times
							 Returns the difference between two xs:times as an xdt:dayTimeDuration.

								op:add-yearMonthDuration-to-dateTime
							 Returns the end of a time period by adding an xdt:yearMonthDuration to the xs:dateTime that starts the period. 

								op:add-dayTimeDuration-to-dateTime
							 Returns the end of a time period by adding an xdt:dayTimeDuration to the xs:dateTime that starts the period. 

								op:subtract-yearMonthDuration-from-dateTime
							 Returns the beginning of a time period by subtracting an xdt:yearMonthDuration from the xs:dateTime that ends the period. 

								op:subtract-dayTimeDuration-from-dateTime
							 Returns the beginning of a time period by subtracting an xdt:dayTimeDuration from the xs:dateTime that ends the period. 

								op:add-yearMonthDuration-to-date
							 Returns the end of a time period by adding an xdt:yearMonthDuration to the xs:date that starts the period. 

								op:add-dayTimeDuration-to-date
							 Returns the end of a time period by adding an xdt:dayTimeDuration to the xs:date that starts the period. 

								op:subtract-yearMonthDuration-from-date
							 Returns the beginning of a time period by subtracting an xdt:yearMonthDuration from the xs:date that ends the period. 

								op:subtract-dayTimeDuration-from-date
							 Returns the beginning of a time period by subtracting an xdt:dayTimeDuration from the xs:date that ends the period. 

								op:add-dayTimeDuration-to-time
							 Adds the value of the hours, minutes and seconds components of an xdt:dayTimeDuration to an xs:time value.

								op:subtract-dayTimeDuration-from-time
							 Subtracts the value of the hours, minutes and seconds components of an xdt:dayTimeDuration to an xs:time value.

					
				

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

If
					either argument is the empty sequence, the empty
					sequence is returned.
If the normalized value of $arg1 precedes in time the normalized value of $arg2, the returned value is a negative duration.

9.7.1.1 Examples

									fn:subtract-dateTimes-yielding-yearMonthDuration(xs:dateTime("2000-10-30T11:12:00"), xs:dateTime("1999-11-28T09:00:00")) returns a xdt:yearMonthDuration value corresponding to 11 months. 

									fn:subtract-dateTimes-yielding-yearMonthDuration(xs:dateTime("2004-04-30T00:00:00"), xs:dateTime("2004-03-31TT09:00:00")) returns a xdt:yearMonthDuration value corresponding to 0 months. 

9.7.2 fn:subtract-dateTimes-yielding-dayTimeDuration
fn:subtract-dateTimes-yielding-dayTimeDuration( $arg1  as xs:dateTime?,
$arg2  as xs:dateTime?) as xdt:dayTimeDuration?
Summary: Returns the
	xdt:dayTimeDuration that corresponds to the
	difference between the normalized value of $arg1 and
	the normalized value of $arg2.
  If either
	argument is the empty sequence, the empty sequence is returned.
If the normalized value of $arg1 precedes in time the normalized value of $arg2, then the returned value is a negative duration.

9.7.2.1 Examples
Assume that the evaluation context provides an implicit timezone value of -5:00.

									fn:subtract-dateTimes-yielding-dayTimeDuration(xs:dateTime("2000-10-30T06:12:00"), xs:dateTime("1999-11-28T09:00:00Z")) returns an xdt:dayTimeDuration value corresponding to 337 days, 2 hours and 12 minutes.

9.7.3 op:subtract-dates
op:subtract-dates($arg1 as xs:date?, $arg2 as xs:date?) as xdt:dayTimeDuration?
Summary: Returns the
	xdt:dayTimeDuration that corresponds to the
	difference between the normalized value of $arg1 and
	the normalized value of $arg2.
  If either
	argument is the empty sequence, the empty sequence isreturned.
If the normalized value of $arg1 precedes in time the normalized value of $arg2, then the returned value is a negative duration.
Backs up the subtract, "-", operator on xs:date values.

9.7.3.1 Examples

									op:subtract-dates(xs:date("2000-10-30"), xs:date("1999-11-28")) returns an xdt:dayTimeDuration value corresponding to 337 days.

9.7.4 op:subtract-times
op:subtract-times($arg1 as xs:time?, $arg2 as xs:time?) as xdt:dayTimeDuration?
Summary: Returns the
					xdt:dayTimeDuration that corresponds
					to the difference between the normalized value of
					$arg1 and the normalized value of
					$arg2.
  If either argument is
					the empty sequence, the empty sequence isreturned.
If the normalized value of $arg1 precedes in time the normalized value of $arg2, then the returned value is a negative duration.
Backs up the subtract, "-", operator on xs:time values.

9.7.4.1 Examples
Assume that the evaluation context provides an implicit timezone value of -5:00.

									op:subtract-times(xs:time("11:12:00Z"), xs:time("04:00:00")) returns an xdt:dayTimeDuration value corresponding to 2 hours and 12 minutes. 

9.7.5 op:add-yearMonthDuration-to-dateTime
op:add-yearMonthDuration-to-dateTime( $arg1  as xs:dateTime,
$arg2  as xdt:yearMonthDuration) as xs:dateTime
Summary: Returns the xs:dateTime computed by adding $arg2 to the normalized value of $arg1 using the algorithm described in Appendix E of [XML Schema Part 2: Datatypes]. 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. 
This functions backs up the "+" operator on xs:dateTime and xdt:yearMonthDuration values. 

9.7.5.1 Examples

									op:add-yearMonthDuration-to-dateTime(xs:dateTime("2000-10-30T11:12:00"), xdt:yearMonthDuration("P1Y2M")) returns an xs:dateTime value corresponding to the lexical representation "2001-12-30T11:12:00".

9.7.6 op:add-dayTimeDuration-to-dateTime
op:add-dayTimeDuration-to-dateTime( $arg1  as xs:dateTime,
$arg2  as xdt:dayTimeDuration) as xs:dateTime
Summary: Returns the xs:dateTime computed by adding $arg2 to the normalized value of $arg1 using the algorithm described in Appendix E of [XML Schema Part 2: Datatypes]. 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.
This functions backs up the "+" operator on xs:dateTime and xdt:dayTimeDuration values. 

9.7.6.1 Examples

									op:add-dayTimeDuration-to-dateTime(xs:dateTime("2000-10-30T11:12:00"), xdt:dayTimeDuration("P3DT1H15M")) returns an xs:dateTime value corresponding to the lexical representation "2000-11-02T12:27:00". 

9.7.7 op:subtract-yearMonthDuration-from-dateTime
op:subtract-yearMonthDuration-from-dateTime( $arg1  as xs:dateTime,
$arg2  as xdt:yearMonthDuration) as xs:dateTime
Summary: Returns the xs:dateTime computed by negating $arg2 and adding the result to the normalized value of $arg1 using the algorithm described in Appendix E of [XML Schema Part 2: Datatypes]. If $arg2 is negative, then the xs:dateTime returned follows $arg1.
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:dateTime and xdt:yearMonthDuration values. 

9.7.7.1 Examples

									op:subtract-yearMonthDuration-from-dateTime(xs:dateTime("2000-10-30T11:12:00"), xdt:yearMonthDuration("P1Y2M")) returns an xs:dateTime value corresponding to the lexical representation "1999-08-30T11:12:00". 

9.7.8 op:subtract-dayTimeDuration-from-dateTime
op:subtract-dayTimeDuration-from-dateTime( $arg1  as xs:dateTime,
$arg2  as xdt:dayTimeDuration) as xs:dateTime
Summary: Returns the xs:dateTime computed by negating $arg2 and adding the result to the normalized value of $arg1 using the algorithm described in Appendix E of [XML Schema Part 2: Datatypes]. If $arg2 is negative, then the xs:dateTime returned follows $arg1.
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:dateTime and xdt:dayTimeDuration values.

9.7.8.1 Examples

									op:subtract-dayTimeDuration-from-dateTime(xs:dateTime("2000-10-30T11:12:00"), xdt:dayTimeDuration("P3DT1H15M")) returns an xs:dateTime value corresponding to the lexical representation "2000-10-27T09:57:00". 

9.7.9 op:add-yearMonthDuration-to-date
op:add-yearMonthDuration-to-date( $arg1  as xs:date,
$arg2  as xdt:yearMonthDuration) as xs:date
Summary: Returns the xs:date computed by adding $arg2 to the normalized value of $arg1 using the algorithm described in Appendix E of [XML Schema Part 2: Datatypes]. If $arg2 is negative, then the xs:date returned precedes $arg1.
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 xdt:yearMonthDuration values. 

9.7.9.1 Examples

									op:add-yearMonthDuration-to-date(xs:date("2000-10-30"), xdt:yearMonthDuration("P1Y2M")) returns the 
xs:date whose normalized value is December 30, 2001. 

9.7.10 op:add-dayTimeDuration-to-date
op:add-dayTimeDuration-to-date( $arg1  as xs:date,
$arg2  as xdt:dayTimeDuration) as xs:date
Summary: Returns the xs:date computed by adding $arg2 to the normalized value of $arg1 using the algorithm described in Appendix E of [XML Schema Part 2: Datatypes]. If $arg2 is negative, then the xs:date returned precedes $arg1.
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 xdt:dayTimeDuration values. 

9.7.10.1 Examples

									op:add-dayTimeDuration-to-date(xs:date("2004-10-30"), xdt:dayTimeDuration("P2DT2H30M0S")) returns the xs:date whose normalized value is November 1, 2004. 

9.7.11 op:subtract-yearMonthDuration-from-date
op:subtract-yearMonthDuration-from-date( $arg1  as xs:date,
$arg2  as xdt:yearMonthDuration) as xs:date
Summary: Returns the xs:date computed by negating $arg2 and adding the result to the normalized value of $arg1 using the algorithm described in Appendix E of [XML Schema Part 2: Datatypes]. If $arg2 is negative, then the xs:date returned precedes $arg1.
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 xdt:yearMonthDuration values. 

9.7.11.1 Examples

									op:subtract-yearMonthDuration-from-date(xs:date("2000-10-30"), xdt:yearMonthDuration("P1Y2M")) returns the xs:date whose normalized value is August 30, 1999. 

9.7.12 op:subtract-dayTimeDuration-from-date
op:subtract-dayTimeDuration-from-date( $arg1  as xs:date,
$arg2  as xdt:dayTimeDuration) as xs:date
Summary: Returns the xs:date computed by negating $arg2 and adding the result to the normalized value of $arg1 using the algorithm described in Appendix E of [XML Schema Part 2: Datatypes]. If $arg2 is negative, then the xs:date returned precedes $arg1.
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 xdt:dayTimeDuration values. 

9.7.12.1 Examples

									op:subtract-dayTimeDuration-from-date(xs:date("2000-10-30"), xdt:dayTimeDuration("P3DT1H15M")) returns a xs:date whose normalized value is October 26, 2000. 

9.7.13 op:add-dayTimeDuration-to-time
op:add-dayTimeDuration-to-time( $arg1  as xs:time,
$arg2  as xdt: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 xdt:dayTimeDuration is calculated. Alternatively, the value modulus 86,400 is used.  This value is added to the normalized value of $arg1 and the result 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 "+" operator on xs:time and xdt:dayTimeDuration values. 

9.7.13.1 Examples

									op:add-dayTimeDuration-to-time(xs:time("11:12:00"), xdt:dayTimeDuration("P3DT1H15M")) returns a normalized xs:time value corresponding to the lexical representation "12:27:00". 

									op:add-dayTimeDuration-to-time(xs:time("23:12:00"), xdt:dayTimeDuration("P1DT3H15M")) returns a normalized xs:time value corresponding to the lexical representation "02:27:00". 

9.7.14 op:subtract-dayTimeDuration-from-time
op:subtract-dayTimeDuration-from-time( $arg1  as xs:time,
$arg2  as xdt:dayTimeDuration) as xs:time
Summary: The result iscalculated by first
					setting the day component in the
					canonical lexical representation of
					$arg2 to zero (0) and calculating the
					value of the resulting
					xdt:dayTimeDuration. Alternatively,
					the value of $arg2 modulus 86,400 is
					used. This value is subtracted from the normalized
					value of $arg1 and the result is returned. Note that the xs:time returned may occur in a preceding or following day and may be greater 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 "-" operator on xs:time and xdt:dayTimeDuration values. 

9.7.14.1 Examples

									op:subtract-dayTimeDuration-from-time(xs:time("11:12:00"), xdt:dayTimeDuration("P3DT1H15M")) returns a normalized xs:time value corresponding to the lexical representation "09:57:00". 

									op:subtract-dayTimeDuration-from-time(xs:time("08:20:00"), xdt:dayTimeDuration("P23DT10H10M")) returns a normalized xs:time value corresponding to the lexical representation "22:10:00".

Operator	Meaning
`op:yearMonthDuration-equal`	Equality comparison on `xdt:yearMonthDuration` values
`op:yearMonthDuration-less-than`	Less-than comparison on `xdt:yearMonthDuration` values
`op:yearMonthDuration-greater-than`	Greater-than comparison on `xdt:yearMonthDuration` values
`op:dayTimeDuration-equal`	Equality comparison on `xdt:dayTimeDuration` values
`op:dayTimeDuration-less-than`	Less-than comparison on `xdt:dayTimeDuration` values
`op:dayTimeDuration-greater-than`	Greater-than comparison on `xdt:dayTimeDuration` values
`op:dateTime-equal`	Equality comparison on `xs:dateTime` values
`op:dateTime-less-than`	Less-than comparison on `xs:dateTime` values
`op:dateTime-greater-than`	Greater-than comparison on `xs:dateTime` values
`op:date-equal`	Equality comparison on `xs:date` values
`op:date-less-than`	Less-than comparison on `xs:date` values
`op:date-greater-than`	Greater-than comparison on `xs:date` values
`op:time-equal`	Equality comparison on `xs:time` values
`op:time-less-than`	Less-than comparison on `xs:time` values
`op:time-greater-than`	Greater-than comparison on `xs:time` values
`op:gYearMonth-equal`	Equality comparison on `xs:gYearMonth` values
`op:gYear-equal`	Equality comparison on `xs:gYear` values
`op:gMonthDay-equal`	Equality comparison on `xs:gMonthDay` values
`op:gMonth-equal`	Equality comparison on `xs:gMonth` values
`op:gDay-equal`	Equality comparison on `xs:gDay` values

Function	Meaning
`fn:get-years-from-yearMonthDuration`	Returns the year component of an `xdt:yearMonthDuration` value.
`fn:get-months-from-yearMonthDuration`	Returns the months component of an `xdt:yearMonthDuration` value.
`fn:get-days-from-dayTimeDuration`	Returns the days component of an `xdt:dayTimeDuration` value.
`fn:get-hours-from-dayTimeDuration`	Returns the hours component of an `xdt:dayTimeDuration` value.
`fn:get-minutes-from-dayTimeDuration`	Returns the minutes component of an `xdt:dayTimeDuration` value.
`fn:get-seconds-from-dayTimeDuration`	Returns the seconds component of an `xdt:dayTimeDuration` value.
`fn:get-year-from-dateTime`	Returns the year from an `xs:dateTime` value.
`fn:get-month-from-dateTime`	Returns the month from an `xs:dateTime` value.
`fn:get-day-from-dateTime`	Returns the day from an `xs:dateTime` value.
`fn:get-hours-from-dateTime`	Returns the hours from an `xs:dateTime` value.
`fn:get-minutes-from-dateTime`	Returns the minutes from an `xs:dateTime` value.
`fn:get-seconds-from-dateTime`	Returns the seconds from an `xs:dateTime` value.
`fn:get-timezone-from-dateTime`	Returns the timezone from an `xs:dateTime` value.
`fn:get-year-from-date`	Returns the year from an `xs:date` value.
`fn:get-month-from-date`	Returns the month from an `xs:date` value.
`fn:get-day-from-date`	Returns the day from an `xs:date` value.
`fn:get-timezone-from-date`	Returns the timezone from an `xs:date` value.
`fn:get-hours-from-time`	Returns the hours from an `xs:time` value.
`fn:get-minutes-from-time`	Returns the minutes from an `xs:time` value.
`fn:get-seconds-from-time`	Returns the seconds from an `xs:time` value.
`fn:get-timezone-from-time`	Returns the timezone from an `xs:time` value.

Function	Meaning
`op:add-yearMonthDurations`	Adds two `xdt:yearMonthDuration`s. Returns an `xdt:yearMonthDuration`.
`op:subtract-yearMonthDurations`	Subtracts one `xdt:yearMonthDuration` from another. Returns an `xdt:yearMonthDuration`.
`op:multiply-yearMonthDuration`	Multiplies a `xdt:yearMonthDuration` by an `xs:decimal`. Returns an `xdt:yearMonthDuration`.
`op:divide-yearMonthDuration`	Divides an `xdt:yearMonthDuration` by an `xs:decimal`. Returns an `xdt:yearMonthDuration`.
`op:add-dayTimeDurations`	Adds two `xdt:dayTimeDurations`. Returns an `xdt:dayTimeDuration`.
`op:subtract-dayTimeDurations`	Subtracts one `xdt:dayTimeDuration` from another. Returns an `xdt:dayTimeDuration`.
`op:multiply-dayTimeDuration`	Multiplies an `xdt:dayTimeDuration` by a `xs:decimal`. Returns an `xdt:dayTimeDuration`.
`op:divide-dayTimeDuration`	Divides an `xdt:dayTimeDuration` by an `xs:decimal`. Returns an `xdt:dayTimeDuration`.


10 Functions Related to QNames

10.1 Additional Constructor Functions for QNames





This section defines additional constructor functions for QName as defined in [XML Schema Part 2: Datatypes]. 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 with the lexical form given in the first argument.  The prefix is resolved using the in-scope namespaces for a given element. 

								fn:expanded-QName
							 Returns an xs:QName with the namespace URI given in the first argument and the local name in the second argument. 
							

					
				

10.1.1 fn:resolve-QName
fn:resolve-QName($qname as xs:string?, $element as element()?) as 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.
If $qname does not have the correct lexical form for
xs:QName an error is raised [invalid lexical value].
If $qname is the empty sequence, returns the empty
sequence.  If $element is the empty sequence, an error is
raised [invalid lexical value].

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

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

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

10.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)
        else fn:expanded-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.

						
					

10.1.1.2 Examples
Assume that the element bound to $element has a single namespace node 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 node corresponding to the prefix "eg" and whose local name is "myFunc".

10.1.2 fn:expanded-QName
fn:expanded-QName($paramURI as xs:string?, $paramLocal as xs:string) as xs:QName
Summary: Returns an xs:QName with the
					namespace URI given in $paramURI and
					the local name in $paramLocal. If
					$paramURI is the empty string or the
					empty sequence,it represents "no namespace". 
If $paramLocal does not have the correct lexical form for
xs:NCName an error is raised [invalid lexical value].

10.1.2.1 Examples

									fn:expanded-QName("http://www.example.com/example", "person") returns an xs:QName with namespace URI = "http://www.example.com/example" and local name = "person".

10.2 Operators and Functions Related to QNames
This section discusses functions on QNames as defined in [XML Schema Part 2: Datatypes].
Function Meaning

								op:QName-equal
							 Returns true if the local names and namespace URIs of the two arguments are equal.

								fn:get-local-name-from-QName
							 Returns an xs:string representing the local name of the xs:QName argument. 

								fn:get-namespace-uri-from-QName
							

								fn:get-namespace-uri-for-prefix
							 Returns the namespace URI of one of the in-scope namespaces for the given element, identified by its namespace prefix.
							

								fn:get-in-scope-prefixes
							 Returns the prefixes of the in-scope namespaces for the given element.
							

10.2.1 op:QName-equal
op:QName-equal($arg1 as xs:QName, $arg2 as xs:QName) as xs:boolean
Summary: Returns true if the namespace URIs of $arg1 and $arg2 are equal and the local names of $arg1 and $arg2 are identical on a codepoint-by-codepoint basis. Otherwise, returns false. Two namespace URIs are considered equal if they are either both absent or both present and identical on a codepoint-by-codepoint basis.  See also 11.2 op:anyURI-equal.
Backs up the "eq" and "ne" operators on values of type xs:QName. 

10.2.2 fn:get-local-name-from-QName
fn:get-local-name-from-QName($arg as xs:QName?) as xs:string?
Summary: Returns an xs:string representing the local part of $arg. If $arg is the empty sequence, returns the empty sequence.

10.2.2.1 Examples

									fn:get-local-name-from-QName(fn:expanded-QName("http://www.example.com/example", "person")) returns "person". 

10.2.3 fn:get-namespace-uri-from-QName
fn:get-namespace-uri-from-QName($arg as xs:QName?) as xs:string?
Summary: Returns the namespace URI for $arg
					as an xs:string. If $arg
					is the empty sequence, the empty sequence is
					returned.  If $arg is in no
					namespace, the zero-length string is returned.

10.2.3.1 Examples

									fn:get-namespace-uri-from-QName(fn:expanded-QName("http://www.example.com/example", "person")) returns the namespace URI corresponding to "http://www.example.com/example". 

10.2.4 fn:get-namespace-uri-for-prefix
fn:get-namespace-uri-for-prefix( $prefix  as xs:string,
$element  as element) as xs:string?
Summary: Returns the namespace URI of one of the in-scope namespaces for $element, identified by its namespace prefix.
	If $element has an in-scope namespace whose namespace prefix is equal to $prefix, it returns the namespace URI of that namespace. If $prefix is the zero-length string, it returns the namespace URI of the default (unnamed) namespace. Otherwise, it returns the empty sequence.
Prefixes are equal only if their Unicode code-points match exactly.

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


11 Functions and Operators for anyURI
This section specifies functions that take anyURI as arguments.
Function Meaning

								
								fn:resolve-uri
							 Returns an xs:string
  representing an absolute xs:anyURI given a base URI and a relative URI. 

								op:anyURI-equal
							 Returns true if the two arguments are equal. 

11.1 fn:resolve-uri
fn:resolve-uri($relative as xs:string?) as xs:string?
fn:resolve-uri($relative as xs:string?, $base as xs:string) as xs:string?
Summary:If$relative isa relative URI reference,the first
formof this functionresolves it against the valueof the base-uri
property from the static context. If $relative is an
absolute URI reference ,it is returned unchanged.  If thebase-uri
					property is not initialized in the static context
					anerror is raised [base uri not defined in the static context].
The secondform of this functionexpects
					$base tobe an absolute URI and
					$relative tobe an absolute or a
					relativeURI reference as
					definedin [RFC 2396].  If
					$relativeis a relative URI reference, it is
					resolvedagainst the base-uri, $base,
					andthe resultingabsolute URI reference is
					returned.  If $relative is an
					absolute URI reference,it is returned unchanged.  If $baseis not an absolute URI,an error is raised [base uri argument to   fn:resolve-uri is not an absolute uri].
If$relativeor $base is not a valid
					anyURIan error is raised [invalid argument to fn:resolve-uri()].
If $relative isthe empty sequence, the empty sequence
					isreturned.
Note:
If $relative is the zero-length string, returns
the value of the base-uri property from the static context in the
first form (if the base-uri property is not initialized in the static
context an error is raised [base uri not defined in the static context]) and $base in the second form.
Note:
Resolving a URI does not dereference it.  This is merely a syntactic operation on two character strings.

11.2 op:anyURI-equal
op:anyURI-equal($arg1 as xs:anyURI
, $arg2 as xs:anyURI
) as xs:boolean
Summary: Returns true if $arg1 and $arg2 compare equal on a codepoint-by-codepoint basis.  Otherwise, returns false. This function backs up the "eq" and "ne" operators on anyURI. 
For more details on comparing URIs see [Uniform Resource Identifiers (URI): Generic Syntax].

11.2.1 Examples

									op:anyURI-equal(xs:anyURI("http://www.example.com/spinaltap.micro.umn.edu/00/Weather/California/Los%20Angeles"), xs:anyURI("http://www.example.com/spinaltap.micro.umn.edu")) returns false


12 Functions and Operators on base64Binary and hexBinary

12.1 Comparisons of base64Binary and hexBinary Values
Thefollowing 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 may be compared with a value of type xs:base64Binary by casting one value to the other type.  See 17.12 Casting to xs:base64Binary and1
							, xs:hexBinary.
Function Meaning

								op:hexBinary-equal
							 Returns true if the two arguments are equal. 

								op:base64Binary-equal
							 Returns true if the two arguments are equal. 

					
				

12.1.1 op:hexBinary-equal
op:hexBinary-equal( $value1  as xs:hexBinary,
$value2  as xs:hexBinary) as xs:boolean
Summary: Returns true if
					$value1 and $value2 are
					of the same length, measured inbinary octets, and
					contain the same octets in the same order.Otherwise, returns false. 
This function backs up the "eq" and "ne" operators on xs:hexBinary values.

12.1.2 op:base64Binary-equal
op:base64Binary-equal( $value1  as xs:base64Binary,
$value2  as xs:base64Binary) as xs:boolean
Summary: Returns true if
					$value1 and $value2 are
					of the same length, measured inbinary octets, and
					contain the same octets in the same order.Otherwise, returns false.
This function backs up the "eq" and "ne" operators on xs:base64Binary values.


13 Functions and Operators on NOTATION

13.1 Operators on NOTATION
This section discusses functions that take NOTATION as arguments.
Function Meaning

								op:NOTATION-equal
							 Returns true if the two arguments are equal. 

13.1.1 op:NOTATION-equal
op:NOTATION-equal($arg1 as xs:NOTATION
, $arg2 as xs:NOTATION
) as xs:boolean
Summary: Returns true if $arg1 and $arg2 compare equal on a codepoint-by-codepoint basis.  Else returns false. This function backs up the "eq" and "ne" operators on xs:NOTATION values.


14 Functions and Operators on Nodes
This section discusses functions and operators on nodes.  Nodes are formally defined in Section 
6 Nodes^DM.

14.1 Functions and Operators on Nodes
Function Meaning

								fn:name
							 Returns the name of the context node or the specified node as an xs:string. 

								fn:local-name
							 Returns the local name of the context node or the specified node as an xs:NCName. 

								fn:namespace-uri
							 Returns the namespace URI as an xs:string for the xs:QName of the argument node or the context node if the argument is omitted. This may be the zero-length string if the xs:QName is in no namespace. 

								fn:number
							 Returns the value of the context node or the specified item converted to an xs:double.

								fn:lang
							 Returns true or false, depending on whether the language of the context node, as defined using the xml:lang attribute, is the same as, or a sublanguage of, the language specified by the argument.  

								op:is-same-node
							 Returns true if the two arguments have the same identity. 

								op:node-before
							 Indicates whether one node appears before another node in document order. 

								op:node-after
							 Indicates whether one node appears after another node in document order. 

								fn:root
							 Returns the root of the tree to which the node argument belongs.

					
				

					
				

					
				
For the illustrative examples below assume an
				XQuery operating on a PurchaseOrderdocument
				containing a number of line-item elements.  Each
				line-item has child elements called description, price,
				quantity, etc.  Quantity has simple content of type
				xs:decimal. Further assume that
				variables $item1, $item2,
				etc. are each bound to singleline-item element nodes
				in the document in sequenceand that the value of the
				quantity child of the first line-item is
				5.0.
<PurchaseOrder>
  <line-item>
    <description> ... </description>
    <price> ... </price>
    <quantity>5.0</quantity>
      ...
  </line-item>
  <line-item>
      ...
  </line-item>
      ...
</PurchaseOrder>

14.1.1 fn:name
fn:name() as xs:string
fn:name($arg as node()?) as xs:string
Summary: Returns the name of a node, as an xs:string that is either the zero-length string, or has the lexical form of an xs:QName. 
If the argument is omitted, it defaults to the context node. If there is no context node (that is, if there is no context item, or if the context item is not a node), the zero-length string is returned.
If the argument is supplied and is the empty sequence, the function returns the zero-length string.
If the target node has no name (that is, if it is a document node, a comment, a text node, or a namespace node having no name), the function returns the zero-length string.
Otherwise, the value returned is an xs:string whose lexical form is an xs:QName. 
If $arg is a processing
					instruction or a namespace 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.3 node-name Accessor^DM) is in
					no namespace, then the function returns the local
					part of the expanded-QName.
If $arg is an attribute node whose
					expanded-QName is in a namespace, then a prefix is
					determined using the following rule: if the attribute has a parent, in the same way that a prefix would beconstructed for that element, otherwise a non-empty prefix is chosen arbitrarily, and no attempt is made to associatethe prefix with the namespace URI.
If $arg is an element node whose
					expanded-QName is in a namespace, then a prefix is
					determinedusing the following rules: if the
					element has at least one namespace node whose
					namespace URI is the same as the namespace name of
					the xs:QName returned by the
					fn:node-name, it returns the local part
					of the name of that namespace node or the empty
					string if thenamespace node has no name. If there
					are several such namespace nodes, it chooses one
					of them arbitrarily. If there is no such namespace
					node, it generates an arbitrary prefix that is
					distinct from the fn:node-name of any of the
					element node's namespaces. The prefix is the empty
					stringif the element has an empty namespace name
					i.e. if it isin the nullnamespace.
This prefix is then combined with the local part of the node's expanded-QName to form a string which will take one of the forms "prefix:local-part" (if the prefix is a non-zero length string) or "local-part" (if the prefix is a zero-length string).
Note:
Some host languages, such as [XQuery 1.0: An XML Query Language], will
never provide a namespace node as an argument to this function.

14.1.2 fn:local-name
fn:local-name() as xs:string
fn:local-name($arg as node()?
) as xs:string
Summary: Returns the local part of the name of $arg as an xs:string that will either be the zero-length string or will have the lexical form of an xs:NCName.
If the argument is omitted, it defaults to the context node. If there is no context node (that is, if there is no context item, or if the context item is not a node), the zero-length string is returned.
If the argument is supplied and is the empty sequence, the function returns the zero-length string.
If the target node has no name (that is, if it is a document node, a comment, or a text node), the function returns the zero-length string.
Otherwise, the value returned will be the local
part of the expanded-QName of the target node (as determined by the
dm:node-name accessor in Section 
5.3 node-name Accessor^DM.This
will be an xs:string whose lexical form is an
xs:NCName.
Note:
Some host languages, such as [XQuery 1.0: An XML Query Language], will
never provide a namespace node as an argument to this function.

14.1.3 fn:namespace-uri
fn:namespace-uri() as xs:string
fn:namespace-uri($arg as node()?
) as xs:string
Summary: Returns the namespace URI of the QName of $arg as a xs:string.
 If the argument is omitted, it defaults to the context node. If there is no context node (that is, if there is no context item, or if the context item is not a node), the zero-length string is returned.
 If $arg is the empty sequence, the zero-length string is returned.
If $arg is neither an element nor an attribute node, or if it is an element or attribute node that has no QName or whose expanded-QName (as determined by the dm:node-name accessor in the Section 
5.3 node-name Accessor^DM) is in no namespace, then the function returns the zero-length string.

14.1.4 fn:number
fn:number() as xs:double
fn:number($arg as item()?
) as xs:double
Summary: Returns the value indicated by $arg or, if $arg is not specified, the context node, converted to an xs:double. If there is no context node (that is, if there is no context item, or if the context item is not a node), NaN is returned.
If $arg, or the context node, is the empty sequence,
 the xs:double value NaN is returned.
If $arg, or the context node, is atomic, the value
obtained by converting it to xs:double following the
rules of 17.8 Casting to numeric types is returned..
If $arg, or the context node, is a node with an atomic
type, itsvalue converted to xs:double following
the rules of 17.8 Casting to numeric types is returned..
Otherwise, $arg, or the context node, is convertedto
an xs:string as if by a call to the
fn:string() function and the result converted to an xs:double
following the rules of 17.8 Casting to numeric types.
If the conversion to xs:double fails because the
lexical representation is not a valid lexical representation of a
numeric simple type as defined in [XML Schema Part 2: Datatypes], the
xs:double value NaN is returned.

14.1.4.1 Examples

									fn:number($item1/quantity) returns 5. 

									fn:number($item2) returns NaN.

14.1.5 fn:lang
fn:lang($testlang as xs:string?
) as xs:boolean
Summary:Thisfunction tests whether the language of the
context node, as specifiedby xml:lang attributes is the
same as, or is a sublanguage of, the language specified by
$testlang. 
If there is no context node (that is, if there
is no context item, or if the context item is not a node), then
returns false.  The language of the context node is
determined by the value of the xml:lang attribute on the
context node, or, if the context node has no such attribute, by the
value of the xml:lang attribute on the nearest ancestor
of the context node that has an xml:lang attribute. If
there is no such ancestor, then returns false
If $lang 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 the string-value
					of the relevant xml:lang attribute is
					equal to $testlang ignoring case, or
					if the string-value of the relevant
					testlang attribute contains a hyphen,
					"-" (The character "-" isHYPHEN-MINUS, %x002D)
 such that the part of the string-value preceding that hyphen is equal to $testlang, ignoring case.

14.1.5.1 Examples
Theexpression 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"/>

							
						

14.1.6 op:is-same-node
op:is-same-node($parameter1 as node(), $parameter2 as node()) as xs:boolean
Summary: If the node identified by the value of $parameter1 is the same node as the node identified by the value of $parameter2 (that is, the two nodes have the same identity), then the function returns true; otherwise, the function returns false. This function backs up the "is" operatoron nodes.

14.1.6.1 Examples

									op:is-same-node($item1, $item1) returns true. 

									op:is-same-node($item1, $item2) returns false. 

14.1.7 op:node-before
op:node-before($parameter1 as node()
, $parameter2 as node()
) as xs:boolean
Summary: If the node identified by the value of $parameter1 occurs in document order before the node identified by the value of $parameter2, this 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.

14.1.7.1 Examples

									op:node-before($item1, $item2) returns true. 

									op:node-before($item1, $item1) returns false. 

14.1.8 op:node-after
op:node-after($parameter1 as node()
, $parameter2 as node()
) as xs:boolean
Summary: If the node identified by the value of $parameter1 occurs in document order after the node identified by the value of $parameter2, this 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.

14.1.8.1 Examples

									op:node-after($item1, $item2) returns false. 

									op:node-after($item1, $item1) returns false. 

									op:node-after($item2, $item1) returns true. 

14.1.9 fn:root
fn:root() as node()
fn:root($arg as node()?) as node()?
Summary: Returns the root of the tree to which
					$arg belongs. This will usually, but
					not necessarily, be a document node.

If $arg is the empty sequence, the empty sequence is returned.
If $arg is a document node, $argis returned.
If the function is called without an argument, the context item is used as the default argument.  If there is no context node (that is, if there is no context item, or if the context item is not a node), an error is raised [context item is not a node].

						
					

14.1.9.1 Examples
Theseexamples 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 [XSLT 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 $i
                            

							fn:root($o/quantity) returns $o
                            

							fn:root($odoc//quantity) returns $odoc
                            

							fn:root($newi) returns $o
                            
Note:
We could make the final three examples type-safe by wrapping their 
operands with fn:exactly-one().


15 Functions and Operators on Sequences
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 [XPath 2.0]. 

				
			

				
			

15.1 Functions and Operators on Sequences
The following functions are defined on sequences.
Function Meaning

					
				

					
				

					
				

					
				

					
				
Functions fn:zero-or-one, fn:one-or-more, and fn:exactly-one check
that the length 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] describing the output of a query may require a sequence of
length one-or-more in some position, but the static type system may
not be able to infer this; inserting a call to fn:one-or-more at the
appropriate place will provide a suitable static type at query
analysis time, and confirm that the length is correct with a dynamic
check at query execution time.
As in the previous section, for the illustrative examples below, assume an XQuery operating on a 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 individual line-item nodes in the sequence.

15.1.1 fn:zero-or-one
fn:zero-or-one($arg as item()*) as item()?
Summary: Returns $arg if it contains zero
					or one items.  Otherwise, raises an error
					[fn:zero-or-one called with a sequence containing more than one item]. The type of
					the result depends onthe type of $arg.

15.1.2 fn:one-or-more
fn:one-or-more($arg as item()*) as item()+
Summary: Returns $arg if it contains one or more items.  Otherwise, raises an error [fn:one-or-more called with a sequence containing no items].The type of the result depends onthe type of $arg.

15.1.3 fn:exactly-one
fn:exactly-one($arg as item()*) as item()
Summary: Returns $arg if it contains exactly one item.  Otherwise, raises an error [fn:exactly-one called with a sequence containing zero or more than one  item].The type of the result depends onthe type of $arg.

15.1.4 fn:boolean
fn:boolean($arg as item()*
) as xs:boolean
Summary: Computes the effective booleanvalue of the sequence $arg.
If $arg is the empty sequence, returns false.
If $arg contains a singleatomic value, then the function returns
 false if $arg is:
The singleton xs:boolean value
false.
The singleton value ""(zero-length string)of type
xs:string or xdt:untypedAtomic. 
A singleton numeric value that is numerically equal to zero.
The singleton xs:float or xs:double
value NaN.
In allother cases, returns true.
Note:
The result of this function is not neccesarily 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.5 op:concatenate
op:concatenate($seq1 as item()*, $seq2 as item()*) as item()*
Summary: Returns a sequence consisting of the items in $seq1 followed by the items in $seq2. This function backs up the infix operator ",".  If either sequence is the empty sequence, the other operand is returned.

15.1.5.1 Examples

									op:concatenate((1 2 3), (4 5)) returns (1 2 3 4 5). 

									op:concatenate((), ()) returns (). 

15.1.6 fn:index-of
fn:index-of( $seqParam  as xdt:anyAtomicType*,
$srchParam  as xdt:anyAtomicType) as xs:integer*
fn:index-of( $seqParam  as xdt:anyAtomicType*,
$srchParam  as xdt:anyAtomicType,
$collation  as xs:string) as xs:integer*
Summary: Returnsa sequence of positive integers giving the positions within the sequence $seqParam of items 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 items in the sequence $seqParam are compared with $srchParam under the rules for the eq operator, using the selected collation when comparing strings. If the type of the items in $seqParam is not xs:string and $collation is specified, the collation is ignored. If an item compares equal, then the position of that item in the sequence $srchParam is included in the result. If the items are not comparable, then an error is raised [items not comparable].

If the value of $seqParam is the empty sequence, or if no item in $seqParam matches $srchParam, then the empty sequence is returned.

The first item in a sequence is at position 1, not position 0.
The result sequence is in ascending numeric order.

15.1.6.1 Examples

fn:index-of ((10, 20, 30, 40), 35) returns ().

fn:index-of ((10, 20, 30, 30, 20, 10), 20) returns
			  (2, 5).

fn:index-of (("a","sport", "and", "a", "pastime"), "a") returns (1, 4).

If @a is anattribute of type xs:string* whose typed value is "redgreen blue",then: fn:index-of (@a, "blue") returns 3.

This is because the function calling mechanism atomizes the attribute node
to produce a sequence of three strings.

15.1.7 fn:empty
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. 

15.1.7.1 Examples

									fn:empty($seq) returns false. 

15.1.8 fn:exists
fn:exists($arg as item()*
) as xs:boolean
Summary: If the value of $arg is not the empty sequence, the function returns true; otherwise, the function returns false. 

15.1.8.1 Examples

									
									fn:exists($seq) returns true. 

15.1.9 fn:distinct-values
fn:distinct-values($arg as xdt:anyAtomicType*) as xdt:anyAtomicType*
fn:distinct-values( $arg  as xdt:anyAtomicType*,
$collation  as xs:string) as xdt:anyAtomicType*
Summary: Returns the sequence that results from removing from
$arg all but one of a set of values that are
eq to one other.  Values   that cannot be compared,
i.e.the eqoperator is not defined for their types, are
consideredto bedistinct.
 
The type returned is a sequence of values of the same type as
$arg. 

  The statictype of the result is asequence of prime types as
 definedin Section 
6.2.4 The fn:distinct-values function^FS.
Thecollation used by the invocation of this functionis determinedaccording to the rules in 7.3.1 Collations.

If $arg is the emptysequence, theempty sequence is
 returned. 
Values oftype xdt:untypedAtomicare compared as if
 theywere of type xs:string.
For xs:float and xs:double values,  
0.0 is equal to -0.0 and, although
NaN does not equal itself, if $arg contains
multipleNaN values a single NaN is returned.

If an xs:dateTime, xs:date or xs:time
value does not have a timezone, an implicit timezone is provided by
the evaluation context.  The normalized value is adjusted using this
implicit timezone if necessary.  The adjusted normalized value is used
to compute distinctness.  

Equality of string values is determined according to the collation
that is used.  If the type of the items in $argisnot
xs:stringand $collationis
specified,the collation is ignored.
Whichvalue of a set of values that compare equal is returned,
alongwithits original type annotation, is ·implementation dependent·.  Notethat xs:dateTime,
 xs:date or xs:time values can compare equal even if
their timezones are different.  The order in whichthe sequence of valuesis returned is ·implementation dependent·.

						
					

15.1.9.1 Examples

									fn:distinct-values(1, 2.0,
									3, 2) might return(1, 3, 2.0). 

15.1.10 fn:insert-before
fn:insert-before( $target  as item()*,
$position  as xs:integer,
$inserts  as item()*) as item()*
Summary: Returns a new sequence constructed from the value of $target with the value of $inserts inserted at the position specified by the value of $position.  (The value of $target is not affected by the sequence construction.) 
If $targetis the emptysequence, $insertsis returned. If $insertsis the emptysequence, $target isreturned.
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. 
If $position is less than one (1), the first position, the effectivevalue of $position is one (1).  If $position is greater than the number of items in $target, then theeffective valueof $position is equal to the number of items in $target plus 1. 

15.1.10.1 Examples
let $x := ("a", "b", "c")
fn:insert-before($x, 0, "z") returns ("z", "a", "b", "c")
fn:insert-before($x, 1, "z") returns ("z", "a", "b", "c")
fn:insert-before($x, 2, "z") returns ("a", "z", "b", "c")
fn:insert-before($x, 3, "z") returns ("a", "b", "z", "c")
fn:insert-before($x, 4, "z") returns ("a", "b", "c", "z")

15.1.11 fn:remove
fn:remove($target as item()*, $position as xs:integer) as item()*
Summary: Returns a new sequence constructed from the value of $target with the item at the position specified by the value of $position removed.
If $positionis less than 1 or greater than the number of items in $target, $targetis returned. Otherwise, the value returned by the function consists 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 
6.2.7 The fn:remove function^FS

						
					

15.1.12 fn:reverse
fn:reverse($arg as item()*) as item()*
Summary: Reverses the order of items in asequence.  If
					$arg is the empty sequence, the empty
					sequence is returned.
					
For detailed type semantics, see Section 
6.2.8 The fn:reverse function^FS

						
					

15.1.13 fn:subsequence
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()*
Summary: 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. More specifically, returns the items in $sourceString whose position $p obeys:

						fn:round($startingLoc) <= $p < fn:round($startingLoc) + fn:round($length)
					
In the above computation, the rules for
op:numeric-less-than() and
op:numeric-greater-than() apply.
If $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 
6.2.9 The fn:subsequence function^FS

15.1.13.1 Examples
Assume $seq = ($item1, $item2, $item3, $item4, ...) 

									fn:subsequence($seq, 4) returns ($item4, $item5, ...)
								

									fn:subsequence($seq, 4, 2) returns ($item4, $item5)
								

15.1.14 fn:unordered
fn:unordered($sourceSeq as item()*) as item()*
Summary: This function takes a sequence, or more typically, an expression,
that evaluates to a sequence, as input and returns an arbitrary
·implementation dependent· permutationof the input
sequence.  Query
optimizers may be able to do a better job if the orderof the output
sequence is not specified.  For example, if you want to retrieve all
the prices from a purchase order, and if there
is an index on prices, it may be possible to compute an unordered result more efficiently.

15.2 Equals, Union, Intersection and Except
Function Meaning

					
				

					
				

					
				
As in the previous sections, for the illustrative examples below, assume an XQuery 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.

15.2.1 fn: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 string) as xs:boolean
Summary: If the sequences that are the values of $parameter1 and $parameter2 have the same values (that is, they have the same number of items and items in corresponding positions in the two sequences compare equal), the function returns true; otherwise, the function returns false. Equality of corresponding items is determined based on the eq operator if they are atomic values and based on deep equality of nodes, as defined below, if they are nodes.

Returns true if both of its arguments are the empty sequence.
Returns false if one, but not both, of its arguments is the empty sequence.
If equality is not defined for the types of two corresponding values the function returns false.
String values are compared using a collation. If the type of the items in $parameter1 and $parameter2 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.

15.2.1.1 Deep Equality of Nodes
The following (recursive) tests are applied in
					order to determine whether two nodes are deep
					equal. This
					uses a function called
					is-namespace-node()which checks, by elimination,
					whethera nodeis anamespace
					
					node.  Notethat
					somehost languages may not support namespace nodes.
					
Ifthe two nodes are ofdifferent kinds,
					the result is false. 

if ($parameter1 instance of element() and not ($parameter2 instance of
element())) then fn:false() else

if ($parameter1 instance of attribute() and not ($parameter2 instance of
attribute())) then fn:false() else

if ($parameter1 instance of text() and not ($parameter2 instance of
text())) then fn:false() else

if ($parameter1 instance of comment() and not ($parameter2 instance of
comment())) then fn:false() else

(: if ($parameter1 instance of document-node() and not ($parameter2
instance of document-node())) then fn:false() else :)

if ($parameter1 instance of processing-instruction() and
 not ($parameter2 instance of processing-instruction())) then fn:false() else 

if (is-namespace-node($parameter1) and not is-namespace-node($parameter2)) 
   then fn:false()
   else 
                    
Returntrue if thethe two nodes
					have names that compare equal as
					xs:QNamesor if they do not have names.

if (not(fn:deep-equal(fn:node-name($parameter1), fn:node-name($parameter2)))) 
then fn:false()
else

                    
Nowperform specific tests based on the kind of
					nodes in hand.  First,test element nodes:
if ($parameter1 instance of element()) then      (: element nodes :)  
  if (some $a1 in $parameter1/@* satisfies       (: have attributes :)
      not (some $a2 in $parameter2/@* 
           satisfies fn:deep-equal($a1, $a2, $collation))
      or (some $a2 in $parameter2/@* satisfies
      not (some $a1 in $parameter1/@* 
           satisfies fn:deep-equal($a1, $a2, $collation))))
then fn:false() else
Checkif both element nodes have simple types.  ifso,
					
					compare
theirtyped values, else compare their children recursively.
Theresult is true if
					 and only if the childrenof bothnodes areall
					pairwisedeep-equal, ignoring comment and
					processinginstruction node childrenin both cases. 
  if ($parameter1 instance of element(*, xs:anySimpleType) and 
     ($parameter2 instance of element(*, xs:anySimpleType))
       return fn:deep-equal(fn:data($parameter1), fn:data($parameter2))
     else 
     if (not ($parameter1 instance of element(*, xs:anySimpleType)) and 
      not ($parameter2 instance of element(*, xs:anySimpleType))) then
                               (:compare children recursively :)
        return fn:deep-equal( $parameter1/(* | text()),  
                       $parameter2/(* | text()), $collation )
     else return fn:false()
else   
Testattribute nodes by comparing their typed values:

if ($parameter1 instance of attribute()) then    (: attribute nodes :)
   fn:deep-equal( fn:data($parameter1), fn:data($parameter2), $collation
)
else
Testtextnodes by comparing their string values:
if ($parameter1 instance of text()) then
   fn:compare
     (fn:string($parameter1), fn:string($parameter2), $collation) ne 0
else
Testcomment nodes bycomparing their string values:
if ($parameter1 instance of comment()) then
   fn:compare
     (fn:string($parameter1), fn:string($parameter2), $collation) ne 0
else
Testprocessing instruction nodes by comparingtheir string values:
if ($parameter1 instance of processing-instruction()) then
   fn:compare
        (fn:string($parameter1), fn:string($parameter2), $collation) ne 0
Finally,test namespace nodes by comparing their stringvalues:

else  (: Must be a namespace node by elimination :)
   fn:compare (fn:string($parameter1), fn:string($parameter2)) ne 0
 
Note:
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 their IDs. 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 are used directly as arguments to the function, not if they appear as children of the nodes supplied as arguments. 
Note:
The result of fn:deep-equal(1, current-dateTime()) is false; it does not raise an error. 
Here is the complete algorithm:
if ($parameter1 instance of element() and not ($parameter2 instance of
element())) then fn:false() else

if ($parameter1 instance of attribute() and not ($parameter2 instance of
attribute())) then fn:false() else

if ($parameter1 instance of text() and not ($parameter2 instance of
text())) then fn:false() else

if ($parameter1 instance of comment() and not ($parameter2 instance of
comment())) then fn:false() else

(: if ($parameter1 instance of document-node() and not ($parameter2
instance of document-node())) then fn:false() else :)

if ($parameter1 instance of processing-instruction() and
 not ($parameter2 instance of processing-instruction())) then fn:false() else 

if (is-namespace-node($parameter1) and not is-namespace-node($parameter2)) 
   then fn:false()
   else 
if (not(fn:deep-equal(fn:node-name($parameter1), fn:node-name($parameter2)))) 
then fn:false()
else

if ($parameter1 instance of element()) then      (: element nodes :)  
  if (some $a1 in $parameter1/@* satisfies       (: have attributes :)
      not (some $a2 in $parameter2/@* 
           satisfies fn:deep-equal($a1, $a2, $collation))
      or (some $a2 in $parameter2/@* satisfies
      not (some $a1 in $parameter1/@* 
           satisfies fn:deep-equal($a1, $a2, $collation))))
then fn:false() else

if ($parameter1 instance of element(*, xs:anySimpleType) and 
     ($parameter2 instance of element(*, xs:anySimpleType))
       return fn:deep-equal(fn:data($parameter1), fn:data($parameter2))
     else 
     if (not ($parameter1 instance of element(*, xs:anySimpleType)) and 
      not ($parameter2 instance of element(*, xs:anySimpleType))) then
                               (:compare children recursively :)
        return fn:deep-equal( $parameter1/(* | text()),  
                       $parameter2/(* | text()), $collation )
     else return fn:false()
else 
    
if ($parameter1 instance of attribute()) then    (: attribute nodes :)
   fn:deep-equal( fn:data($parameter1), fn:data($parameter2), $collation
)
else

if ($parameter1 instance of text()) then
   fn:compare
     (fn:string($parameter1), fn:string($parameter2), $collation) ne 0
else

if ($parameter1 instance of comment()) then
   fn:compare
     (fn:string($parameter1), fn:string($parameter2), $collation) ne 0
else

if ($parameter1 instance of processing-instruction()) then
   fn:compare
        (fn:string($parameter1), fn:string($parameter2), $collation) ne 0
else  (: Must be a namespace node by elimination :)
   fn:compare (fn:string($parameter1), fn:string($parameter2)) ne 0
             
						
						
					

15.2.1.2 Examples

									fn:deep-equal($item1, $item2) returns false. 

									fn:deep-equal($item1, $item1) returns true . 

									fn:deep-equal(($item1, $item2), 2.3E0) returns false.

15.2.2 op:union
op:union($parameter1 as node()*, $parameter2 as node()*) as node()*
Summary: Constructs a sequence containing every node
					that occurs in the values of either
					$parameter1 or
					$parameter2, eliminating duplicate
					nodes.  Nodes are returned in document order. Two
					nodes are equal if they are
					op:is-same-node().  
For detailed type semantics, see Section 
6.2.10 The op:union, op:intersect, and
      op:except operators^FS.
This function backs up the "union" or "|" operator. 

15.2.2.1 Examples
Assume $seq1 = ($item1, $item2), $seq2 = ($item1, $item2) and $seq3 = ($item2, $item3).

									op:union($seq1, $seq1) returns the sequence ($item1, $item2). 

									op:union($seq2, $seq3) returns the sequence consisting of ($item1, $item2, $item3).  

15.2.3 op:intersect
op:intersect($parameter1 as node()*, $parameter2 as node()*) as node()*
Summary: Constructs a sequence containing every node that occurs in the values of both $parameter1 and $parameter2, eliminating duplicate nodes.  Nodes are returned in document order. 
If either operand is the empty sequence, the empty sequence is returned.
Two nodes are equal if they are
					op:is-same-node(). 
For detailed type semantics, see Section 
6.2.10 The op:union, op:intersect, and
      op:except operators^FS.
This function backs up the "intersect" operator.

15.2.3.1 Examples
Assume $seq1 = ($item1, $item2), $seq2 = ($item1, $item2) and $seq3 = ($item2, $item3).

									op:intersect($seq1, $seq1) returns the sequence ($item1, $item2). 

									op:intersect($seq2, $seq3) returns the sequence ($item2). 

15.2.4 op:except
op:except($parameter1 as node()*, $parameter2 as node()*) as node()*
Summary: Constructs a sequence containing every node that occurs in the value of $parameter1, but not in the value of $parameter2, eliminating duplicate nodes.  Nodes are returned in document order.
If $parameter1 is the empty sequence, the empty sequence is returned.  If $parameter2 is the empty sequence, $parameter1 is returned.
Two nodes are equal if they are
					op:is-same-node(). 
For detailed type semantics, see Section 
6.2.10 The op:union, op:intersect, and
      op:except operators^FS.
This function backs up the "except" operator.

15.2.4.1 Examples
Assume $seq1 = ($item1, $item2), $seq2 = ($item1, $item2) and $seq3 = ($item2, $item3).

									op:except($seq1, $seq2) returns the empty sequence. 

									op:except($seq2, $seq3) returns the sequence ($item1). 

15.3 Aggregate Functions
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.
				xdt: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 a sequence of values. 

								fn:max
							 Returns the member with maximum value from a sequence of comparable values. 

								fn:min
							 Returns the member with minimum value from a sequence of comparable values. 

								fn:sum
							 Returns the sum of a sequence of values. 

				
			

15.3.1 fn:count
fn:count($arg as item()*) as xs:integer
Summary: Returns the number of items in the
value of $arg.
  Returns 0 if $arg is the empty sequence.

						
					

15.3.1.1 Examples
Assume $seq1 = ($item1, $item2) and $seq3 = (), the empty sequence.

									fn:count($seq1) returns 2. 

									fn:count($seq3) returns 0. 

15.3.2 fn:avg
fn:avg($arg as xdt:anyAtomicType*) as xdt:anyAtomicType?

Summary: Returns the average of the valuesin the inputsequence
$arg, that is, the sum of the values dividedbythe
numberofvalues.
If $arg is the empty sequence, the empty sequence is returned.
If $arg containsvalues of type
xdt:untypedAtomic they are cast to xs:double. 
Duration values must either all be
xdt:yearMonthDuration values or must all be
xdt:dayTimeDuration values. For numeric values, the
numeric promotion rules defined in 6.2 Operators on Numeric Values are
used to promote all values to a single common type.  Afterthese
operations,$arg mustcontain items of asingle type,
whichmust be one ofthe four numeric types,
xdt:yearMonthDuration orxdt:dayTimeDuration
orone if its subtypes.
If the above conditions are not met, then an error is raised [invalid argument to aggregate function].
If $arg contains xs:float or
xs:double values and includes aNaN value,
theresult is NaN.
Otherwise, returns the average of the values computed as sum($arg) div
count($arg). 
For detailed type semantics, see Section 
6.2.6 The fn:min, 
    fn:max, fn:avg, and fn:sum functions^FS.

15.3.2.1 Examples
Assume $d1 = xdt:yearMonthDuration("P20Y") and $d2 = xdt:yearMonthDuration("P10M") and $seq3 = (3, 4, 5).

									fn:avg($seq3) returns 4.0. 

									fn:avg(($d1, $d2)) returns a yearMonthDuration with value 125 months. 

									fn:avg(($d1, $seq3)) raises an error [invalid argument to aggregate function].

									fn:avg(())returns ().

15.3.3 fn:max
fn:max($arg as xdt:anyAtomicType*) as xdt:anyAtomicType?
fn:max($arg as xdt:anyAtomicType*, $collation as string) as xdt:anyAtomicType?
Summary:Selectsanitem from the input sequence $arg
whose value is greater than or equal to the value of every other item
in the input sequence. If there are two or more such items, then the specific item whose
value is returned is ·implementation dependent·. 
Any values of typexdt:untypedAtomic in the sequence $arg are cast to
xs:double.The items in the resulting sequencemay be reordered in an
arbitrary order. The resulting sequence is referred to below as theconverted sequence.

If the converted sequenceis empty, the empty sequence is returned.
Ifthe converted sequence contains thevalue NaN, the
valueNaNis returned.
$arg must contain only items of a single type or one if its subtypes for which the gt operator is defined. For numeric values, the numeric promotion rules defined in 
6.2 Operators on Numeric Values are used to promote all values to a single common type. In addition, the values in the sequence must have a total order. If date/time values do not have a timezone, the implicit timezone provided by the evaluation context is added and the adjusted normalized value is used in the calculation. Duration values must either all be xdt:yearMonthDuration values or must all be xdt:dayTimeDuration values.
If any of these conditions is not met, then an error is raised
[invalid argument to aggregate function]. 
If theitems inthe valueof $arg
 are oftypexs:string or typesderived by restriction from xs:string,then the determination of the greatest item is madeaccording to the collationthat is used. If the type of the items in $arg isnot xs:stringand $collationis 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.
Otherwise, the result of the function is theresult of theexpression:
   if (every $v in $c satisfies $c[1] ge $v)) 
   then $c[1] 
   else fn:max(fn:subsequence($c, 2))]
evaluatedwith$collation as the default collation if specified, and
with $c as the converted sequence.
For detailed type semantics, see Section 
6.2.6 The fn:min, 
    fn:max, fn:avg, and fn:sum functions^FS.
Note:

If the converted sequence contains exactly onevalue then that value is
returned.
Note:
The default type whenthe fn:max function is applied to
xdt:untypedAtomic values is xs:double.This differs from the default typeforoperators such as lt,and for sorting in XQuery and
XSLT, which is xs:string.

15.3.3.1 Examples
Assume $seq1 = (3, 4, 5).

									fn:max($seq1) returns 5. 

									fn:max(3,4,5) returns 5. 

									fn:max(5, 5.0e0) may
									return the  xs:integer
									5 or the xs:double
									5.0e0. 

									fn:max(3,4,"Zero")
									raises an error [invalid argument to aggregate function]. 

									fn:max(fn:current-date(),
									xs:date(2001-01-01)
									typically returns the current date. 

									fn:max("a", "b", "c")
									returns "c" under a typical
									default collation. 

15.3.4 fn:min
fn:min($arg as xdt:anyAtomicType*) as xdt:anyAtomicType?
fn:min($arg as xdt:anyAtomicType*, $collation as string) as xdt:anyAtomicType?
Summary:selectsan item from the input sequence $arg
whose value is less than or equal to the value of every other item
in the input sequence. If there are two or more such items, then the specific item whose
value is returned is ·implementation dependent·. 
Any values of typexdt:untypedAtomic in the sequence $arg are cast to
xs:double. The itemsin the resulting sequence may be reordered in an
arbitrary order. The resultingsequence is referred to below as theconverted sequence.

If the convertedsequence is empty, the empty sequenceis returned.
If the converted sequence contains the valueNaN, the
valueNaNis returned.
$arg must contain only items of a single type or one if its subtypes for which the gt operator is defined. For numeric values, the numeric promotion rules defined in 
6.2 Operators on Numeric Values are used to promote all values to a single common type. In addition, the values in the sequence must have a total order. If date/time values do not have a timezone, the implicit timezone provided by the evaluation context is added and the adjusted normalized value is used in the calculation. Duration values must either all be xdt:yearMonthDuration values or must all be xdt:dayTimeDuration values.
If any of these conditions is not met, then an error is raised
[invalid argument to aggregate function]. 
If theitems inthe valueof $arg
 are oftypexs:string or typesderived by restriction from xs:string,then the determination of the greatest item is madeaccording to the collationthat is used. If the type of the items in $arg isnot xs:stringand $collationis 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.
Otherwise, the result of the function is theresult of theexpression:
   if (every $v in $c satisfies $c[1] le $v)) 
   then $c[1] 
   else fn:min(fn:subsequence($c, 2))]
evaluatedwith$collation as the default collation if specified, and
with $c as the converted sequence.
For detailed type semantics, see Section 
6.2.6 The fn:min, 
    fn:max, fn:avg, and fn:sum functions^FS.
Note:

If the converted sequence contains exactly onevalue then that value is
returned.
Note:
The default type whenthe fn:max function is applied to
xdt:untypedAtomic values is xs:double.This differs from the default typefor		
operators such as lt,and for sorting in XQuery and
XSLT, which is xs:string.

15.3.4.1 Examples
Assume $seq1 = (3, 4, 5).

									fn:min($seq1) returns 3. 

									fn:min(3,4,5) returns 3. 

									fn:min(5, 5.0e0) may
									return the  xs:integer
									5 or the xs:double
									5.0e0. 

									fn:min(3,4,"Zero")
									raises an error [invalid argument to aggregate function]. 

									fn:min(fn:current-date(),
									xs:date(2001-01-01)
									typically returns the date "2001-01-01". 

									fn:min("a", "b", "c")
									returns "a" under a typical
									default collation. 

15.3.5 fn:sum
fn:sum($arg as xdt:anyAtomicType*) as xdt:anyAtomicType
fn:sum( $arg  as xdt:anyAtomicType*,
$zero  as xdt:anyAtomicType?) as xdt:anyAtomicType?
Summary: Returns a value obtainedby adding together the values in 
$arg. If the single-argument form of the functionis used, then
the value returned for an empty sequence isthe xs:doublevalue0.0e0. If
the two-argument form is used, then the value returned for an empty sequence
is the value of the $zero argument.
Any values of type xdt:untypedAtomic in$arg are cast to 
xs:double. Theitems in the resulting sequence may be reordered in an
arbitraryorder. The resulting sequence is referred to below asthe
convertedsequence.
Ifthe converted sequence is empty, then the single-argument formof the
function returns thexs:double value0.0e0;the two-argument form returns
the value of the argument$zero.
  If the converted sequence containsthe value NaN,NaN is returned.
The input sequence $arg must contain items of a single type orone of its subtypes. In addition, the type must support addition. Duration values must either all be xdt:yearMonthDuration values or must all be xdt:dayTimeDuration values.  For numeric values, the numeric promotion rules defined in 6.2 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, an error is raised [invalid argument to aggregate function].
Otherwise,the result of the
functionis theresult ofthe expression:
$c[1] + fn:sum(subsequence($c, 2))
where$c is the converted sequence.

						
					
For detailed type semantics, see Section 
6.2.6 The fn:min, 
    fn:max, fn:avg, and fn:sum functions^FS.
Note:
The second argument allows an appropriate value to be defined to
represent thesum 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".
Note:

If the converted sequence contains exactly one value then that value is
returned.

15.3.5.1 Examples
Assume $d1 = xdt:yearMonthDuration("P20Y") and $d2 = xdt:yearMonthDuration("P10M") and $seq3 = (3, 4, 5).

									fn:sum(($d1, $d2))
									returns a
									yearMonthDuration
									with a value of 250 months.

									fn:sum($seq3) returns 12. 

									fn:sum(()) returns
									0.0e0. 

									fn:sum((),()) returns
									().

									fn:sum((1 to 100)[.<0], 0)
									 returns 0.

									fn:sum(($d1, 9E1)) raises an error [invalid argument to aggregate function].

15.4 Functions and Operators that Generate Sequences
Function Meaning

					
				

					
				

15.4.1 op:to
op:to($firstval as xs:integer, $lastval as xs:integer) as xs:integer*
Summary: Returns the sequence containing every xs:integer whose
					value is between the value of
					$firstval (inclusive) and the value
					of $lastval (inclusive), in monotonic
					order. If the value of the first operand is greater
					than the value of the second, the emptysequence is returned.If the values of the two operands are equal, a sequence containing a single xs:integer equal to the value is returned.
This function backs up the "to" operator.

15.4.2 fn:id
fn:id($arg as xs:string*) as element()*
Summary: Returns the sequence of element nodes
with ID values matching the values of one or more of the IDREF values
supplied in $arg.
 Each string in $arg is parsed as if it were of type 
xs:IDREFS, that is, $arg is treated as a 
space-separated sequence of tokens, each acting as an IDREF. These tokens
are then included in the list of candidate IDREFs. After this process,
the list must consist entirely of IDREF values. If any of the tokens is
not a lexically-valid IDREF (that is, if it is not lexically an xs:NCName), it is ignored.

The result of the function is a sequence, in document order, of those
elements that are in the same document as the context node, and that have an
ID value equal to one or more of the IDREFs in the list of candidate IDREFs.
An element has an ID value of V if it has an attribute whose type is xs:ID and whose value is V, or if the element itself is of (simple) type xs:ID and has a value of V.

An ID value matches a candidate IDREF if they consist of the same sequence
of Unicode code-points. The default collation is not used in the comparison.
An
error is raised[no context document]if there is no context item, or if
the context item is not a node, or if thecontext item is a node in a tree
whose root is not a document node.

No error is raised in respect of an IDREF value that does not match the ID
of any element in the document. If no IDREF value matches any element, the
function returns the empty sequence.

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 attribute
that has a declared type of ID, but whose value does not conform to the lexical rules for an ID. Such an element will never be selected by this function.
 

						
					

15.4.3 fn:idref
fn:idref($arg as xs:string*) as node()*
Summary: Returns the nodes that have IDREF values that reference one or more of the ID values specified in $arg.
 
Each string in $arg is parsed as if it were of lexically of 
type xs:ID.These strings
are then included in the list of candidate IDs. After this process,
the list must consist entirely of ID values. If any of the strings in $argis
not a lexically-valid ID (that is, if it is not lexically an xs:NCName), it is ignored.
  
A node references an ID value if it is anelement or attribute nodewhose type is xs:IDREF or xs:IDREFS.  
If the node is of type xs:IDREF then its value must match
					one of the ID values in the list of candidate IDs.If it is of type xs:IDREFS then one of the values in the IDREFS sequence must match one of the values in the list of candidate IDs.

An IDREF value matches a candidate ID if they consist of the same sequence of Unicode code-points. The default collation is not used in the comparison. This function allows reverse navigation from IDs to IDREFs.
The resulting element or attribute nodes are returned in document order, without duplicates. The nodes that are returned all belong to the document containing the context node. 
An error is raised [no context document]if there is no context item, or if the context item is not a node, or if the contextitem is a node in a tree whose root is nota document node.

15.4.4 fn:doc
fn:doc($uri as xs:string?) as document?
Summary: Retrieves a document using anxs:anyURIsupplied as an xs:string. If $uri is not avalid xs:anyURI, an error is raised [invalid argument to fn:doc()].If it is a relative URI, it is resolved relative to the value of the base URI property from the static context.
$urimust not contain a fragment identifier.
If $uri is the empty sequence, the result is an empty
sequence.
Note:
If $uriis 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 this function.
This function is ·stable·. Two calls on this function return the same document node if the same URI (after resolution
to an absolute URI) 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")
If two calls on this function supply different absolute URIs, the same
document node may
be returned if the implementation can determine that the two URIs refer to
the same resource.
The default processing performed by this function is as follows.
The resource identified by the URI is retrieved. If the resource cannot be
retrieved, an error is raised 
("Error retrieving resource"). 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].  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
[error parsing contents of resource].Otherwise, the result of the
function is the document
node at the root of the resulting tree.
The following 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. 
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.
For detailed type semantics, see Section 
6.2.2 The fn:collection and fn:doc functions^FS.

15.4.5 fn:collection
fn:collection($arg as xs:string?) as node()*
Summary: Takes a
xs:string as argument and returns a sequence of nodes
obtained by interpreting $arg as anxs:anyURI and
resolving it.  If $arg is the empty sequence,the empty
sequenceis returned.
If $arg isnot a valid xs:anyURI, or cannot
be resolved, an error is raised [invalid argument to fn:collection()].
If the $arg is a relative URI, it is resolved against the
value of the base-URI property from the static context.  This function
is ·stable·.
For detailed type semantics, see Section 
6.2.2 The fn:collection and fn:doc functions^FS.


16 Context Functions
The following functions are defined to obtain information from the evaluation context.  The context is always defined but may be the empty sequence.
Function Meaning

				
			

16.1 fn:position
fn:position() as xs:integer
Summary: Returns an xs:integer indicating the position of the context item within the sequence of items currently being processed.  If the context item is undefined, an error is raised [undefined context item].

16.2 fn:last
fn:last() as xs:integer
Summary: Returns an xs:integer indicating the number of items in the sequence of items currently being processed.  If the context item is undefined, an error is raised [undefined context item].

16.3 fn:current-dateTime
fn:current-dateTime() as xs:dateTime
Summary: Returns the xs:dateTime (with timezone) that is current at some time during the evaluation of a query or transformation in which fn:current-dateTime() is executed.  This function is ·stable·. The precise instant during the query or transformation represented by the value of fn:current-dateTime() is ·implementation dependent·.
The timezone component of fn:current-dateTime() is the value of the implicit timezone property in the evaluation context.

16.3.1 Examples

								fn:current-dateTime() returns an xs:dateTime corresponding to the current date and time. For example, an invocation of fn:current-dateTime() might return 2004-05-12T18:17:15.125Z corresponding to the current time on May 12, 2004 with an implicit timezone of Z. 

16.4 fn:current-date
fn:current-date() as xs:date
Summary: Returns the xs:date (with timezone) that is current at some time during the evaluation of a query or transformation in which fn:current-date() is executed.  This function is ·stable·. The precise instant during the query or transformation represented by the value of fn:current-date() is ·implementation dependent·.
The timezone component of fn:current-date() is the value of the implicit timezone property in the evaluation context.

16.4.1 Examples

								fn:current-date() returns an xs:date corresponding to the current date and time. For example, an invocation of fn:current-date() might return 2004-05-12+01:00. 

16.5 fn:current-time
fn:current-time() as xs:time
Summary: Returns the xs:time (with timezone) that is current at some time during the evaluation of a query or transformation in which fn:current-time() is executed.  This function is ·stable·.  The precise instant during the query or transformation represented by the value of fn:current-time() is ·implementation dependent·.
The timezone component of fn:current-time() is the value of the implicit timezone property in the evaluation context.

16.5.1 Examples

								fn:current-time() returns an xs:time corresponding to the current date and time. For example, an invocation of fn:current-time() might return 23:17:00.000-05:00. 

16.6 fn:default-collation
fn:default-collation() as xs:string
Summary: Returns the value of the default collation property
				from the static context.
Note:
  The default collation
				propertycan
				neverbe undefined. If it is not explicitly defined, a
				system defineddefault can be invoked.  If this is not
				provided, the Unicode code point collation is used. 

16.7 fn:implicit-timezone
fn:implicit-timezone() as xdt:dayTimeDuration?
Summary: Returns the value of the implicit timezone property from the evaluation context.  Returns the empty sequence if the implicit timezone is undefined.


17 Casting 

Constructor functions and cast expressions accept an expression and
return a value of a given type. Theyboth convert a value to a given
type with identical semantics and different syntax.  The name of a constructor function is the same as the name of the [XML Schema Part 2: Datatypes] built-in type (see 5.1 Constructor Functions for XML Schema Built-in Types) or user-derived type (see 5.2 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 " . 
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. 
If the empty sequence is passed to a cast expression an error is raised [invalid value for cast] .

				
		

17.1 Casting from primitive types to primitive types
This section defines casting between the 19 primitive types defined in [XML Schema Part 2: Datatypes] as well as xdt:untypedAtomic and the two derived types xdt:yearMonthDuration and xdt:dayTimeDuration. 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 succeedfor some values in the value space and fails for others.
Casting is notsupported to or from xs:anySimpleType.  Thus, there is no row or column forthis 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 xdt:untypedAtomic.  There are no values with the type annotation xs:anySimpleType at runtime.
In the following table, the columns and rows are identified by short codes that identify simple types as follows:
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 dur yMD dTD dT tim dat gYM gYr gMD gDay gMon bool b64 hxB aURI QN NOT
QN N N N N N N N N N N N N N N N N N N N Y N
NOT Y N N N N N N N N N N N N N N N N N N N Y

17.2 Casting to derived types
Casting a value to a derived type can be separated into three cases:
When the supplied value is an instance of a type that is derived by restriction from the target type.  This is described in section 17.3 Casting from derived types to parent types. 
When the supplied value is of a type derived by restriction from the same primitive type as the target type.  This is described in 17.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 source type. This is described in 17.5 Casting across the type hierarchy.
When the supplied value is an instance of the target type, the cast always succeeds (Identity cast).

17.3 Casting from derived types to parent types
It is always possible to cast a value of any atomic type to an atomictype 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.

17.4 Casting within a branch of the type hierarchy
It is possible to cast a value to a target type if the type of the source value and the target 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. For example an instance of xs:byte can be cast to xs:unsignedShort, provided the value is not negative. This includes the case where the target type is derived from the type of the supplied value, as well as the case where both derive from a common supertype. 
If the value does not conform to the facets defined
				for the target type, then an error is raised [invalid value for cast].See [XML Schema Part 2: Datatypes].
				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
				data type (or the result of casting the value to a
				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 sourcetype. 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:integerto my:distance will always fail, because the canonical representation of an xs:integerdoes not conform to this pattern.
In some cases, casting from a parent type to a derived type requires special rules.  See 17.8 Casting to numeric types for rules regarding casting to xs:integer and 17.9 Casting to duration types for rules regarding casting to xdt:yearMonthDuration and xdt:dayTimeDuration.

17.5 Casting across the type hierarchy
When the source type and the target type 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 source value, up the hierarchy, to the primitive type of the source, as described in 17.3 Casting from derived types to parent types.
Cast the value to the primitive type of the target type, as described in 17.1 Casting from primitive types to primitive types. 
Cast the value down to the target type, as described in
 17.4 Casting within a branch of the type hierarchy

17.6 Casting from xs:stringand xdt:untypedAtomic
When the supplied value is an instance of xs:stringor an instance of xdt:untypedAtomic, it is treated as being a string value and validated as a lexical value of the target type. Casting is permitted from xs:stringand xdt:untypedAtomic to any primitive atomic type or any atomic type derived by restriction — except 
xs:NOTATION.  Casting to xs:QName involves special semantics.  See 17.14 Casting to xs:QName.
For example, cast as xs:unsignedInt("13") returns the xs:unsignedInt with value 13. This could also be written xs:unsignedInt("13"). 
 For xs:dateTime, xs:date and xs:time, the value returned is a tuple as explained in 1.6 xs:dateTime,of xs:date andargument(s).  These xs:time values.

17.7 Casting to xs:stringand xdt:untypedAtomic
Casting is permitted from any primitive type,
				except xs:QName,to the primitive types xs:stringand xdt:untypedAtomic.
When a value of any simple type is cast to xs:string, the derivation of the xs:string value TV depends on the source type ST and on the source value 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 performedwithout
							escaping any characters.
If ST is a numeric type, the following rules apply:
If ST is xs:integer, TV
				is the canonical lexical representation of
				SVas defined in [XML Schema Part 2: Datatypes].
 Thereis no
decimalpoint.
If ST is xs:decimal, then:
If SV is in the value space of xs:integer,that is, if
thereare no significant digits after the decimal point, then the value is
convertedfrom an xs:decimalto anxs:integerandthe resulting xs:integer
isconverted to an xs:stringusing the rule above.

   Otherwise,the canonical lexical representation of SV
isreturned, as defined in [XML Schema Part 2: Datatypes].

If STis xs:floator xs:double,then:
IfSVis NaN,the resulting value is "NaN".
IfSVhas an absolute value that is greater than orequal to 0.000001 (one millionth) and less than 1000000 (onemillion), then
the value is converted to an xs:decimaland the resulting
xs:decimalis converted to an xs:string
					usingthe rules above.
Otherwise, the canonical lexical representationof SV
value is returned, as
defined in [XML Schema Part 2: Datatypes].
If STis
                            xs:dateTime,
                            xs:date or
                            xs:time, TV is
                            the localized value.  Ifnecessary, the
                            localized value isrecovered from the
                            normalized value as follows:if an
                            explicit timezone was present, the
                            normalized value is adjusted using the
                            explicit timezone; if an explicit
                            timezone was not present, the
                            Z timezone is dropped from the normalized value.  The localized value and the explicit timezone, if present, are cast separately to xs:string and concatenated to yield TV.
                            
In all other cases,
                            TV is the [XML Schema Part 2: Datatypes] canonical representation
                            of SV.  For datatypes that do
                            not have a canonical lexical
                            representation definedan ·implementation dependent·canonical
                            representation maybe used.
To cast to xdt:untypedAtomic the value is cast to
	xs:string, as described above, and the type
	annotation changed to xdt:untypedAtomic.
Note:
The
			
			
				string representations ofnumeric valuesare backwards compatible with XPath 1.0 exceptforthe special
values positiveand negativeinfinity, and for values outside the range
1.0e-6 to 1.0e+6.

17.8 Casting to numeric types

17.8.1 Casting to xs:float
When a value of any simple type is cast to xs:float, the xs:float TV is derived from the source type ST and the source value SV as follows:
If ST is xs:float, then TV is SV and the conversion is complete.
If ST is xs:double and SV
can be represented in the value space of xs:float as
defined in [XML Schema Part 2: Datatypes], then TV is
xs:float(SV cast as xs:string)
	and the conversion is complete.
If ST is xs:double and SV cannot be represented in the value space of xs:float as defined in [XML Schema Part 2: Datatypes], then the following rules apply:
If SV is greater than the maximum xs:float value, TV is INF.
If SV is less than the minimum xs:float value, TV is -INF.
If converting SV to xs:float would result in underflow, TV is 0.
If ST is
 xs:decimal, or a type derived from xs:decimal, 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 
xdt:untypedAtomic, xs:anySimpleType or 
xs:string or a type derived from xs:string,
SV is converted to an intermediate value IV
of type xs:string and TV is xs:float(IV ).
Note:
Implementations ·may· return negative zero
for "-0.0E0" cast to xs:float.

17.8.2 Casting to xs:double
When a value of any simple type is cast to xs:double, the xs:double value TV is derived from the source type ST and the source value SV as follows:
If ST is xs:double, then TV is SV and the conversion is complete.
If ST is xs:float or xs:decimal, or types derived from them, 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.0E0y if SV is false and the conversion is complete.

									If ST is 
xdt:untypedAtomic, xs:anySimpleType or 
xs:string, or a type derived from xs:string,
SV is converted to an intermediate value IV
of type xs:string and TV is xs:double(IV ).
Note:
Implementations ·may· return negative zero
for "-0.0E0" cast to xs:double.

17.8.3 Casting to xs:decimal
When a value of any simple type is cast to xs:decimal, the xs:decimal value TV is derived from the source type ST and the source value SV as follows:						
If ST is xs:decimal, or a type derived from xs:decimal, 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 positive or negative infinity or NaN, or if it is higher than the highest decimal value that the implementation can represent, or lower than the lowest, then the cast raises an error [error in casting to decimal].
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 
xdt:untypedAtomic, xs:anySimpleType or 
xs:string, or a type derived from xs:string,
									SV is converted to an
intermediate value IV of type xs:stringandTV is xs:decimal(IV).

17.8.4 Casting to xs:integer
When a value of any simple type is cast to xs:integer, the xs:integer value TV is derived from the source type ST and the source value 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 accomodated as an integer, then an error is raised [input value too large for integer].If SV is one of the special xs:float or xs:double values NaN, INF, +INF or -INF, an error is raised [error in casting to integer].
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 
xdt:untypedAtomic, xs:anySimpleType or 
xs:string, or a type derived from xs:string,
SV is converted to an intermediate value IV
of type xs:stringandTV is xs:integer(IV).

17.9 Casting to duration types
When a value of any primitive type is cast to xs:duration, xdt:yearMonthDuration or xdt:dayTimeDuration, the target value TV is derived from the source type ST and the source value SV as follows:
If source type (ST) is the same as target type (TT), then TV is SV. 
If ST is 
xs:duration, or a type derived from xs:duration,
andTT isxdt:yearMonthDuration, then TV is derived from SV by removingthe day, hour, minute and second components from SV.
If ST is xs:duration, or a type derived from duration, and TT is xdt:dayTimeDuration, then TV is derived from SV by removing the year and month components from SV.
If ST is xdt:yearMonthDuration or xdt:dayTimeDuration, or a type derived from them,and TT is xs:duration, then TV is derived from SV by xs:duration(SV cast as xs:string).
If ST is xdt:untypedAtomic or 
xs:string, or a type derived from xs:string,
SVis converted to an intermediate value IV of typexs:stringand TV is derived from IV using therules of [XML Schema Part 2: Datatypes] validation.
Note that casting from xs:duration to xdt:yearMonthDuration or xdt:dayTimeDuration loses information.  To avoid this, users can cast the xs:duration value to both an xdt:yearMonthDuration and an xdt:dayTimeDuration and work with both values.

17.10 Casting to date and time types
In several situations, casting to date and time
types requires the extraction of a component from the source value 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 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 of efficiency.
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:string
   let $length := fn: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
   return 
     if (fn: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:string
   let $intLength := ($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 xdt:dayTimeDuration?) as xs:string
{
   if (empty($tz)) then ""
   else 
     let $tzh :=  fn:get-hours-from-dayTimeDuration($tz)
     let $tzm := fn:get-minutes-from-dayTimeDuration($tz)
     let $plusMinus := if ($tzh >= 0) then "+" else "-"
     let $tzhSimpleString := fn:abs($tzh) cast as xs:string
     let $tzhString := if (fn:length($tzhSimpleString) < 2)
                     then fn:concat("0", $tzhSimpleString)
                     else $tzhSimpleString
     let $tzmSimpleString := fn:abs($tzm) cast as xs:string
     let $tzmString := if (fn:length($tzmSimpleString) < 2)
                     then fn:concat("0", $tzmSimpleString)
                     else $tzmSimpleString
     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 to xs:dateTime, xs:time, xs:date, xs:gYearMonth, xs:gYear, 
xs:gMonthDay, xs:gDay, or
xs:gMonth,
 
 let CYR be eg:convertToYearCharString(
fn:get-year-from-dateTime( fn:current-dateTime())),
 
 let CMO be eg:convertTo2CharString(
fn:get-month-from-dateTime( fn:current-dateTime())), 

let CDA be eg:convertTo2CharString(
fn:get-day-from-dateTime( fn:current-dateTime() ))  and 

let CTZ be eg:convertTZtoString(fn:get-timezone-from-dateTime(fn:current-dateTime() ). 
When a value of any primitive type is cast to xs:dateTime, the xs:dateTime value TV is derived from the source type ST and the source value SV as follows:
If ST is xs:dateTime, then TV is SV. 
If ST is xs:time, then let SHR be eg:convertTo2CharString(fn:get-hours-from-time(
									SV	)) , let SMI be eg:convertTo2CharString(fn:get-minutes-from-time(
									SV
									)), let SSE be eg:convertSecondsToString(fn:get-seconds-from-time(
									SV
									)) and let STZ be eg:convertTZtoString( fn:get-timezone-from-time(SV)) 
; TV is xs:dateTime( fn:concat(
									CYR
									, '-', 
									CMO
									, '-', 
									CDA
									, 'T', 
									SHR
									, ':', 
									SMI
									, ':', 
									SSE,
									STZ
									) ). 
If ST is xs:date, then let SYR be eg:convertYearToString(fn:get-year-from-date(
									SV
									)), let SMO be eg:convertTo2CharString(fn:get-month-from-date(
									SV
									)), let SDA be eg:convertTo2CharString(fn:get-day-from-date(
									SV
									)) and let STZ be eg:convertTZtoString(fn:get-timezone-from-date(SV)) ; TV is xs:dateTime( fn:concat(
									SYR
									, '-', 
									SMO
									, '-', 
									SDA
									, 'T00:00:00 ',
									STZ
									) ). 

								If ST is 
												xdt:untypedAtomicor xs:string, or a type derived from xs:string,
SV is converted to an intermediate value IV
												of type
												 xs:string
												and TV is xs:dateTime(
									IV
									). 
When a value of any primitive type is cast to xs:time, the xs:time value TV is derived from the source type ST and the source value 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:get-hours-from-dateTime(
									SV
									)),':', eg:convertTo2CharString(fn:get-minutes-from-dateTime(
									SV
									)), ':', eg:convertSecondsToString(fn:get-seconds-from-dateTime(
									SV
									)),eg:convertTZtoString(fn:get-timezone-from-dateTime( 
                                    SV
                                    )))). 

						If ST is 
xdt:untypedAtomicor 
xs:string, or a type derived from xs:string,
SV is converted to an intermediate value IV
of type xs:string andTV is xs:time(
									IV
									). 
When a value of any primitive type is cast to xs:date, the xs:date value TV is derived from the source type ST and the source value SV as follows:
If ST is xs:date, then TV is SV. 
If ST is xs:dateTime, then let SYR be eg:convertYearToString(fn:get-year-from-dateTime(
									SV
									)), 
let SMO be eg:convertTo2CharString(fn:get-month-from-dateTime(
									SV
									)), 
let SDA be eg:convertTo2CharString( fn:get-day-from-dateTime(
									SV
									)) and let STZ be eg:convertTZtoString(fn:get-timezone-from-dateTime(
									SV
									)); TV is xs:date( fn:concat(
									SYR
									, '-', 
									SMO
									, '-', 
									SDA, 
									STZ
									) ). 

						If ST is 
xdt:untypedAtomicor 
xs:string, or a type derived from xs:string,
SV is converted to an intermediate value IV
of type xs:string andTV is xs:date(
									IV
									). 
When a value of any primitive type is cast to xs:gYearMonth, the xs:gYearMonth value TV is derived from the source type ST and the source value SV as follows:
If ST is xs:gYearMonth, then TV is SV. 
If ST is dateTime, then let SYR be eg:convertYearToString(fn:get-year-from-dateTime(
									SV
									)), let SMO be eg:convertTo2CharString(fn:get-month-from-dateTime(
									SV
									)) and let STZ be eg:convertTZtoString(fn:get-timezone-from-dateTime(
									SV
									)); TV is xs:gYearMonth( fn:concat(
									SYR
									, '-', 
									SMO,
									STZ
									) ). 
If ST is date, then let SYR be eg:convertYearToString(fn:get-year-from-date(
									SV
									)), let SMO be eg:convertTo2CharString( fn:get-month-from-date(
									SV
									)) and let STZ be eg:convertTZtoString(fn:get-timezone-from-date(
									SV
									)); TV is xs:gYearMonth( fn:concat(
									SYR
									, '-', 
									SMO,
									STZ
									) ). 

						If ST is 
xdt:untypedAtomicor 
xs:string, or a type derived from xs:string,
SV is converted to an intermediate value IV
of type xs:string andTV is xs:gYearMonth(
									IV
									). 
When a value of any primitive type is cast to xs:gYear, the xs:gYear value TV is derived from the source type ST and the source value SV as follows:
If ST is xs:gYear, then TV is SV. 
If ST is dateTime, let SYR be eg:convertYearToString(fn:get-year-from-dateTime( SV )) and let STZ be eg:convertTZtoString(fn:get-timezone-from-dateTime(
									SV
									)); TV is xs:gYear(
									SYR,
									STZ
									). 
If ST is date, let SYR be eg:convertYearToString(fn:get-year-from-date(
									SV
									)); and let STZ be eg:convertTZtoString( fn:get-timezone-from-date( 
SV ));
									TV is xs:gYear(
									SYR,
									STZ
									). 

						If ST is 
xdt:untypedAtomicor 
xs:string, or a type derived from xs:string,
SV is converted to an intermediate value IV
of type xs:string andTV is xs:gYear(
									IV
									). 
When a value of any primitive type is cast to xs:gMonthDay, the xs:gMonthDay value TV is derived from the source type ST and the source value SV as follows:
If ST is xs:gMonthDay, then TV is SV. 
If ST is dateTime, then let SMO be eg:convertTo2CharString(fn:get-month-from-dateTime(
									SV
									)), let SDA be eg:convertTo2CharString(fn:get-day-from-dateTime(
									SV
									)) and let STZ be eg:convertTZtoString(fn:get-timezone-from-dateTime(
									SV
									)); TV is xs:gYearMonth( fn:concat(
									'--', 
									SMO
									, '-', 
									SDA, STZ
									) ). 
If ST is date, then let SMO be eg:convertTo2CharString(fn:get-month-from-date(
									SV
									)), let SDA be eg:convertTo2CharString(fn:get-day-from-date(
									SV
									)) and let STZ be eg:convertTZtoString(fn:get-timezone-from-date(
									SV
									)); TV is xs:gYearMonth( fn:concat(
									, '--', 
									SMO
									, '-', 
									SDA, STZ
									) ). 

						If ST is 
xdt:untypedAtomicor 
xs:string, or a type derived from xs:string,
SV is converted to an intermediate value IV
of type xs:string andTV is xs:gMonthDay(
									IV
									). 
When a value of any primitive type is cast to xs:gDay, the xs:gDay value TV is derived from the source type ST and the source value SV as follows:
If ST is xs:gDay, then TV is SV. 
If ST is dateTime, then let SDA be eg:convertTo2CharString(fn:get-day-from-dateTime(
									SV
									)) and let STZ be eg:convertTZtoString( fn:get-timezone-from-dateTime(
									SV
									)); TV is xs:gDay( fn:concat( '---',
									SDA, STZ
									)). 
If ST is date, then let SDA be eg:convertTo2CharString(fn:get-day-from-date(
									SV
									)) and let STZ be eg:convertTZtoString(fn:get-timezone-from-date(
									SV
									)); TV is xs:gDay( fn:concat( '---',
									SDA, STZ
									)). 

						If ST is 
xdt:untypedAtomicor 
xs:string, or a type derived from xs:string,
SV is converted to an intermediate value IV
of type xs:string andTV is xs:gDay(
									IV
									). 
When a value of any primitive type is cast to xs:gMonth, the xs:gMonth value TV is derived from the source type ST and the source value SV as follows:
If ST is xs:gMonth, then TV is SV. 
If ST is dateTime, then let SMO be eg:convertTo2CharString(fn:get-month-from-dateTime(
									SV
									)) and let STZ be eg:convertTZtoString(fn:get-timezone-from-dateTime(
									SV
									)); TV is xs:gMonth( fn:concat( '--' ,
									SMO, STZ
									)). 
If ST is date, then let SMO be eg:convertTo2CharString(fn:get-month-from-date(
									SV
									)) and let STZ be eg:convertTZtoString(fn:get-timezone-from-date(
									SV
									)); TV is xs:gMonth( fn:concat( '--',
									SMO, STZ
									)). 

						If ST is 
xdt:untypedAtomicor 
xs:string, or a type derived from xs:string,
SV is converted to an intermediate value IV
of type xs:string andTV is xs:gMonth(
									IV
									). 

17.11 Casting to xs:boolean 
When a value of any primitive type is cast to xs:boolean, the xs:boolean value TV is derived from the source type ST and the source value 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.0E0or
			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 
xdt:untypedAtomicor 
xs:string, or a type derived from xs:string,
SV is converted to an intermediate value IV
of type xs:stringand 
TV is xs:boolean( IV ). 

17.12 Casting to xs:base64Binary andxs:hexBinary
Valuesoftype xs:base64Binarycan becast to 
								xs:hexBinary
							 and vice
								versa, sincethe twotypes
					 
				
			
			
				have the same value space.  Casting to xs:base64Binary and xs:hexBinary is also supported from the same type andfrom xdt:untypedAtomic, xs:stringandsubtypes ofxs:string using [XML Schema Part 2: Datatypes] semantics.

17.13 Casting to xs:anyURI
Casting to xs:anyURI is supported only from the same type,xdt:untypedAtomicor xs:stringandtypes derivedfrom xs:string.
When a value of any primitive type is cast to xs:anyURI, the xs:anyURI value TV is derived from the source type ST and the source value SV as follows:
If ST is xdt:untypedAtomic or xs:string, or a type derived from xs:string TVis xs:anyURI( SV).  The extent to whichan implementation validates thelexical formof SVis ·implementation dependent·.

17.14 Casting to xs:QName
It is possible to cast to xs:QName only from xdt:untypedAtomic, xs:string, or types derived from xs:stringIn each case the source value SV is treated like an xs:string.
The lexical form of SV must conform to the QName production of [Namespaces in XML].  If not, an error is raised [invalid value for constructor].
The effect of casting to xs:QName is context dependent.  The local part of the resulting xs:QName is taken from the local part of SV. The namespace URI of the resulting xs:QName is determined as follows:

If SV has a prefix, then the prefix is mapped to a namespace URI using the in-scope namespaces from the static context. A dynamic error is raised
("No namespace for prefix") if there is no in-scope namespace with the given prefix.

If SV has no prefix, then the resulting xs:QName has the namespace URI given by the default namespace for elements and types, as defined in the static context. If there is no default namespace for elements and types, then the resulting xs:QName has no namespace.

17.14.1 Usage Note

Sometimes the user may want to cast to an xs:QName without using the default namespace. This can be achieved by writing:
   if (fn:contains(SV, ":")) then xs:QName(SV)
        else fn:expanded-QName("", SV)

Note that the result of casting a string to an xs:QName depends on the static context in which the expression appears, in particular on the namespace declarations that are in scope. This means, for example, that it is not a
good idea to pass a string as an argument to a function and convert the
string to an xs:QName within the function; the conversion must be done in the place where the appropriate namespaces are declared.

17.15 Casting to xs:NOTATION
Casting to xs:NOTATIONand
				typesderived from it is permitted only from values of
				the sametype because the validity of
				values of thesetypes is context dependent and cannot, in general, be determined.  The target value TV is derived from the source value SV as follows: 
TV = SV.


A References

A.1 Normative
IEEE 754-1985

						IEEE. IEEE Standard for Binary Floating-Point Arithmetic.
						See http://standards.ieee.org/reading/ieee/std_public/description/busarch/754-1985_desc.html
					
RFC 2396

						IETF. RFC 2396: Uniform Resource Identifiers (URI): Generic Syntax. 
						See http://www.ietf.org/rfc/rfc2396.txt
					
RFC 2732

						IETF. RFC 2732: Format for Literal IPv6 Addresses in URL's.
						See http://www.ietf.org/rfc/rfc2732.txt
					
Character Model for the World Wide Web 1.0

						Character Model for the World Wide Web 1.0, Last Call Working Draft available at: http://www.w3.org/TR/2002/WD-charmod-20020430/
					
ISO 10967

						ISO (International Organization for Standardization).
						ISO/IEC 10967-1:1994, Information technology — Language Independent Arithmetic — Part 1: Integer and floating point arithmetic  
						[Geneva]: International Organization for Standardization, 1994.
						Available from: http://www.iso.ch/
					
The Unicode Standard

						The Unicode Consortium. The Unicode Standard, Version 2.0. Reading, Mass.: Addison-Wesley Developers Press, 1996.
					
The Unicode Standard

						The Unicode Consortium. The Unicode Standard, Version 4.0.00. Defined by: The Unicode Standard, Version 4.0 (Reading, MA, Addison-Wesley, 2003. ISBN 0-321-18578-1)
					
Unicode Case Mappings

						Unicode Technical Standard #21, Unicode Case Mappings.
						Available at: http://www.unicode.org/unicode/reports/tr21/
					
Unicode Collation Algorithm

						Unicode Technical Standard #10, Unicode Collation Algorithm
						Available at: http://www.unicode.org/unicode/reports/tr10/
					
XML 1.0 Recommendation (Second Edition)

						World Wide Web Consortium. Extensible Markup Language (XML) 1.0, Second Edition.
						Available at: http://www.w3.org/TR/REC-xml
					
XPath 2.0

						World Wide Web Consortium.  XML Path Language (XPath) Version 2.0.
						Available at: http://www.w3.org/TR/xpath20/
					
XSLT 2.0

						World Wide Web Consortium.  XSL Transformations Version 2.0.
						Available at: http://www.w3.org/TR/xslt20/
					
XQuery 1.0 and XPath 2.0 Data Model

						World Wide Web Consortium.  XQuery 1.0 and XPath 2.0 Data Model. 
						Available at: http://www.w3.org/TR/query-datamodel/
					
XQuery 1.0 and XPath 2.0 Formal Semantics

						World Wide Web Consortium.  XQuery 1.0 and XPath 2.0 Formal Semantics.
						Available at: http://www.w3.org/TR/query-semantics/
						
					
XQuery 1.0: An XML Query Language

						World Wide Web Consortium.  XQuery 1.0: An XML Query Language. 
						Available at: http://www.w3.org/TR/xquery/
					
XML Schema Part 1: Structures

						XML Schema Part 1: Structures. 
						Available at: http://www.w3.org/TR/xmlschema-1/
					
XML Schema Part 2: Datatypes

						XML Schema Part 2: Datatypes. 
						Available at: http://www.w3.org/TR/xmlschema-2/
					
Namespaces in XML

						Namespaces in XML. 
						Available at: http://www.w3.org/TR/1999/REC-xml-names-19990114/
					

A.2 Non-normative
ISO 8601

						ISO (International Organization for Standardization).
						Representations of dates and times, 2000-08-03.  
						Available from: http://www.iso.ch/
					
SQL

						ISO (International Organization for Standardization). 
						ISO/IEC 9075-2:1999, Information technology --- Database languages --- SQL --- Part 2: Foundation (SQL/Foundation).
						[Geneva]: International Organization for Standardization, 1999.
						See 	http://www.iso.ch/cate/d26197.html
					
XML Information Set
XPath 1.0
XSLT 1.0
Uniform Resource Identifiers (URI): Generic Syntax
"Uniform
						Resource Identifiers (URI):Generic
						Syntax"(T. Berners-Lee, R. Fielding,L. Masinter, Eds.) iscurrently being
						revised.The IETF InternetDraft http://www.apache.org/~fielding/uri/rev-2002/rfc2396bis.htmlis expected to obsolete[RFC 2396],which isthe currentURI standard. Section6"Normalization andComparison" contains information on comparison of URIs.


B Compatibility with XPath 1.0 (Non-Normative)
This appendix summarizes the relationship between
			certain functions defined in [XPath 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
			[XPath 1.0]. The third column discusses the
			differencesin the semantics of the corresponding functions.
The functions appear in the order they appear in [XPath 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 [XPath 2.0]. If the mode is on, the following
			conversions are applied before the argument value is passed to
			the function:

If the expected type is  
xs:string or
xs:string?,then the given value V is effectively
replacedby fn:string(fn:subsequence(V, 1, 1)).
If the expected type is xs:double or
xs:double?, then the given value V is effectively
replaced by fn:number(fn:subsequence(V, 1, 1)).

If the expected type is a (possibly optional) node or item
xs:string?, then the given value Vis effectively
replacedby fn:subsequence(V, 1, 1).
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
						

							fn:local-name() as xs:string
						 
							local-name(node-set?) => string
						

							fn:local-name($arg as node()?
) as xs:string
						

							fn:namespace-uri() as xs:string
						 
							namespace-uri(node-set?) => string
						 In 2.0, the required type for this function is node. If compatibilityfallback conversion is enabled and $srcval is a node sequence, the first node in the 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
						

							fn:string() as xs:string
						 
							string(object) => string
						 If compatibility mode is off,
						andouble error will occur if argument has more than
						oneare node. Representations of numeric values are backwards compatible except for the special
values positive and negativenode, infinity, and for values outside the range
1.0e-6 tocompatibility. 1.0e+6.

							fn:string($arg as item()?
) as xs:string
						

							fn:concat($arg1 as xs:string?
, $arg2 as xs:string?
, ...
) as xs:string
						 
							concat(string, string, string*) => string
						 If compatibility mode is off,
						anare error will occur if argument has more than
					
					
						
							
								
							
						one node or if argument is a number or a
					
					
						boolean. If compatibility mode on, implicit
							
								
								
								
							
						conversion is performed.

							fn:starts-with($arg1 as xs:string?
, $arg2 as xs:string?
) as xs:boolean?
						 
							starts-with(string, string) => boolean
						 In 1.0, returns false if the
						first argument is an empty node-set. In 2.0,
						returns (). If compatibility mode is off,
						an error will occur if argument has more than
						one node or if argument is a number or a
						boolean. If compatibility
						mode is on, implicit conversion is performed.

							fn:starts-with( $arg1  as xs:string?,
$arg2  as xs:string?,
$collation  as xs:string) as xs:boolean?
						

							fn:contains($arg1 as xs:string?
, $arg2 as xs:string?
) as xs:boolean?
						 
							contains(string, string) => boolean
						 In 1.0, returns false if the
						first argument is an empty node-set. In 2.0,
						returns (). If compatibility mode is off,
						an error will occur with more than one node
						and a non-string argument results in a type error.

							fn:contains( $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?
) as xs:string?
						 
							substring-before(string, string) => string 
						 In 1.0, returns
						"" if the first argument is an
						empty node-set. In 2.0, returns
						(). If backwards compatibility
						mode is off, numbers and booleans will give
						errors.  Multiple nodes and more than one
value will also give error.  

							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?
) as xs:string?
						 
							substring-after(string, string) => string 
						 In 1.0, returns
						"" if the first argument is an
						empty node-set. In 2.0, returns
						(). If backwards compatibility
						mode is off, numbers and booleans will give
						errors.  Multiple nodes and more than one
value will also give error.  

							fn:substring-after( $arg1  as xs:string?,
$arg2  as xs:string?,
$collation  as xs:string) as xs:string?
						

							fn:substring( $sourceString  as xs:string?,
$startingLoc  as xs:double) as xs:string?
						 
							substring(string, number, number?) => string 
						 In 1.0, returns "" if the first argument is an empty node-set. In 2.0, returns ().

							fn:substring( $sourceString  as xs:string?,
$startingLoc  as xs:double,
$length  as xs:double) as xs:string?
						

							fn:string-length($arg as xs:string?
) as xs:integer?
						 
							string-length(string?) => number 
						 If you apply fn:string-length(@a) == 0; In 1.0 returns true if @a oes not
exist.  In 2.0 returns false. 
						
						

							fn:string-length() as xs:integer?
						

							fn:normalize-space($arg as xs:string?
) as xs:string?
						 
							normalize-space(string?) => string 
						 In 1.0, returns
						"" if the first argument is an
						empty node-set. In 2.0, returns
						(). If backwards compatibility
						mode is off, numbers and booleans will give errors for first arg.  Also, multiple
nodes will give error. 
							
							

								fn:normalize-space() as xs:string?
						

							fn:translate( $arg  as xs:string?,
$mapString  as xs:string?,
$transString  as xs:string?) 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
						

							fn:number() as xs:double
						 
							number(object?) => number
						 Error if argument has more
						than one node when not in backwards compatibility node.

							fn:number($arg as item()?
) as xs:double
						

							fn:sum($arg as xdt:anyAtomicType*) as xdt: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.together. 1.0 returns NaN. In 2.0 NaN values are removed from sequences of xs:float or xs:double before addition is performed.

							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


C Illustrative User-written Functions (Non-Normative)

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.

C.1 eg:if-empty and eg:if-absent
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 signalled with an empty sequence.  This section includes examples of functions that
provide such defaults.  These functions return xdt:anyAtomicType*.
Users may want to write functions that return more specific types.

C.1.1 eg:if-empty
eg:if-empty( $node  as node?,
$value  as xdt:anyAtomicType) as xdt: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="xdt:anyAtomicType*">
  <xsl:param name="node()" type="node()?"/>
  <xsl:param name="value" type="xdt: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 xdt:anyAtomicType) as xdt:anyAtomicType* 
{
  if ($node and $node/child::node())
            then fn:data($node)
            else $value
}

C.1.2 eg:if-absent
eg:if-absent( $node  as node()?,
$value  as xdt:anyAtomicType) as xdt: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()" type="node()?"/>
  <xsl:param name="value" type="xdt: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 xdt:anyAtomicType) as xdt:anyAtomicType* 
{
  if ($node)
    then fn:data($node)
    else $value
}

C.2 union, intersect and except on sequences of values

C.2.1 eg:value-union
eg:value-union( $arg1  as xdt:anyAtomicType*,
$arg2  as xdt:anyAtomicType*) as xdt: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="xdt:anyAtomicType*">
  <xsl:param name="arg1" type="xdt:anyAtomicType*"/>
  <xsl:param name="arg2" type="xdt:anyAtomicType*"/>
  <xsl:sequence
     select="fn:distinct-values(($arg1, $arg2))"/> 
</xsl:function>
XQuery implementation
declare function eg:value-union (
  $arg1 as xdt:anyAtomicType*,
  $arg2 as xdt:anyAtomicType*) as xdt:anyAtomicType* 
{
  fn:distinct-values(($arg1, $arg2))
}

C.2.2 eg:value-intersect
eg:value-intersect( $arg1  as xdt:anyAtomicType*,
$arg2  as xdt:anyAtomicType*) as xdt: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="xdt:anyAtomicType*">
  <xsl:param name="arg1" type="xdt:anyAtomicType*"/>
  <xsl:param name="arg2" type="xdt:anyAtomicType*"/>
  <xsl:sequence 
     select="fn:distinct-values($arg1[.=$arg2])"/>
</xsl:function>
XQuery implementation
declare function eg:value-intersect (
  $arg1 as xdt:anyAtomicType*,
  $arg2 as xdt:anyAtomicType* ) as xdt:anyAtomicType* 
{
  fn:distinct-values($arg1[.=$arg2])
}

C.2.3 eg:value-except
eg:value-except( $arg1  as xdt:anyAtomicType*,
$arg2  as xdt:anyAtomicType*) as xdt: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="xdt:anyAtomicType*">
  <xsl:param name="arg1" type="xdt:anyAtomicType*"/>
  <xsl:param name="arg2" type="xdt:anyAtomicType*"/>
  <xsl:sequence
     select="fn:distinct-values($arg1[not(.=$arg2)])"/>
</xsl:function>
XQuery implementation
declare function eg:value-except (
  $arg1 as xdt:anyAtomicType*,
  $arg2 as xdt:anyAtomicType*) as xdt:anyAtomicType* 
{
  fn:distinct-values($arg1[not(.=$arg2)])
}

C.3 eg:index-of-node
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
}

C.4 eg:string-pad
eg:string-pad($padString as xs:string?, $padCount as xs:integer) as xs:string
XQuery implementation
declare function eg:string-pad (
  $padString as xs:string?,
  $padCount as xs:integer) as xs:string 
{
   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.

C.5 eg:distinct-nodes-stable
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, preserving the first occurrence of each node.
In XPath
$arg[empty(subsequence($arg, 1, position()-1) intersect .)]
XQuery implementation
declare function distinct-nodes-stable ($arg as node()*) as node()* 
{ 
   for $a at $apos in $arg 
   let $before_a := fn:subsequence($a, 1, $apos - 1) 
   where every $ba in $before_a satisfies $ba isnot $a 
   return $a 
}

C.6 Working With xs:duration Values
This document does not define equality on xs:duration values.
Nor does it define other comparison functions on such values.  Users wanting to
work with xs:duration values should cast them into 
xdt:yearMonthDuration and xdt:dayTimeDuration
values and use the functions defined for comparing them in
9.3 Comparisons of Duration, Date and Time Values to define appropriate semnatics.
One way of comparing two xs:duration values for equality is
to compare their yearMonth and dayTime components separately  and return equal
if both corresponding components are equal.  
This could be written as follows:
XSLT implementation
<xsl:function name="eg:duration-equal" as="xs:boolean">
  <xsl:param name="arg1" as="xs:duration"/>
  <xsl:param name="arg2" as="xs:duration"/>
  <xsl:sequence 
    select="(cast as xdt:yearMonthDuration (arg1) eq 
          cast as xdt:yearMonthDuration(arg2) and
        cast as xdt:dayTimeDuration(arg1) eq 
          cast as xdt:dayTimeDuration (arg2))
        )" />
</xsl:function>
XQuery implementation
declare function eg:duration-equal($arg1 as xs:duration, $arg2 as xs:duration)
    as xs:boolean 
{
  if (cast as xdt:yearMonthDuration ($arg1) eq
      cast as xdt:yearMonthDuration($arg2) 
   and
      cast as xdt:dayTimeDuration($arg1) eq 
      cast as xdt:dayTimeDuration ($arg2)) return fn:true()
  else return fn:false()
}


D Error Summary (Non-Normative)


err:FOAR0001, division by zero

This error is raised whenever an attempt is made to divide by zero.


err:FOAR0002, numeric operation overflow/underflow

This error is raised whenever numeric operations result in an overflow or underflow.




err:FOCA0001, error in casting to decimal

.


err:FOCA0002, invalid lexical value

.


err:FOCA0003, input value too large for integer

.


err:FOCA0004, error in casting to integer

.


err:FOCA0005, NaN supplied as float/double value

.


err:FOCH0001, codepoint not valid

.


err:FOCH0002, unsupported collation

.


err:FOCH0003, unsupported normalization form

.


err:FOCH0004, collation unsuitable for this function

.


err:FODC0001, no context document

.


err:FODC0002, invalid argument to fn:doc()

.


err:FODC0003, error parsing contents of resource

.


err:FODC0004, invalid argument to fn:collection()

.




err:FODT0001, overflow in date/time arithmetic

.


err:FODT0002, overflow in duration arithmetic

.




err:FONC0001, undefined context item

.


err:FONS0002, default namespace is defined

.


err:FONS0003, no prefix defined for namespace

.


err:FONS0004, no namespace found for prefix

.


err:FONS0005, base uri not defined in the static context

.




err:FORG0001, invalid value for constructor

.


err:FORG0002, invalid argument to fn:resolve-uri()

.


err:FORG0003, fn:zero-or-one called with a sequence containing more than one item

.


err:FORG0004, fn:one-or-more called with a sequence containing no items

.


err:FORG0005, fn:exactly-one called with a sequence containing zero or more than one  item

.


err:FORG0006, invalid position

.


err:FORG0007, invalid argument to aggregate function

.


err:FORG0008, invalid value for cast

.


err:FORG0009, base uri argument to   fn:resolve-uri is not an absolute uri

.




err:FORX0001, invalid regular expression flags

.


err:FORX0002, invalid regular expression

.


err:FORX0003, regular expression matches zero-length string

.


err:FORX0004, invalid replacement string

.




err:FOTY0001, type error

This error is raised whenever a static type error is encountered.


err:FOTY0011, context item is not a node

.


err:FOTY0012, items not comparable

.


err:FOTY0013, type does not have equality defined

.


err:FOTY0014, type exception

.


E Functions and Operators Issues List (Non-Normative)
This appendix contains the current issues related to the operators specification.


F ChangeLog since Last Call Version on 2003-05-02 (Non-Normative)
Changesto thisdocument are in detailed in the lastcall issues document.


G Function and Operator Quick Reference (Non-Normative)

G.1 Functions and Operators by Section
Accessors
fn:node-name
fn:node-name($arg as node()?
) as xs:QName?
fn:string
fn:string() as xs:string
fn:string($arg as item()?
) as xs:string
fn:data
fn:data($arg as item()*
) as xdt:anyAtomicType*
fn:base-uri
fn:base-uri($arg as node()?
) as xs:string?
fn:base-uri() as xs:string
fn:document-uri
fn:document-uri($arg as node()?
) as xs:string?
The Error Function
fn:error() as none
fn:error($arg as item()?
) as none
The Trace Function
fn:trace($value as item()*, $label as xs:string) as item()*
Functions and Operators on Numerics
Operators on Numeric Values
op:numeric-add($arg1 as numeric
, $arg2 as numeric
) as numeric
op:numeric-subtract($arg1 as numeric
, $arg2 as numeric
) as numeric
op:numeric-multiply($arg1 as numeric
, $arg2 as numeric
) as numeric
op:numeric-divide($arg1 as numeric
, $arg2 as numeric
) as numeric
op:numeric-integer-divide($arg1 as xs:integer
, $arg2 as xs:integer
) as xs:integer
op:numeric-mod($arg1 as numeric
, $arg2 as numeric
) as numeric
op:numeric-unary-plus($arg as numeric
) as numeric
op:numeric-unary-minus($arg as numeric
) as numeric
Comparison of Numeric Values
op:numeric-equal($arg1 as numeric
, $arg2 as numeric
) as xs:boolean
op:numeric-less-than($arg1 as numeric
, $arg2 as numeric
) as xs:boolean
op:numeric-greater-than($arg1 as numeric
, $arg2 as numeric
) as xs:boolean
Functions on Numeric Values
fn:abs($arg as numeric?) as numeric?
fn:ceiling($arg as numeric?
) as numeric?
fn:floor($arg as numeric?) as numeric?
fn:round($arg as numeric?) as numeric?
fn:round-half-to-even($arg as numeric?
) as numeric?
fn:round-half-to-even($arg as numeric?
, $precision as xs:integer
) as numeric?
Functions on Strings
Functions to Assemble and Disassemble Strings
fn:codepoints-to-string($arg as xs:integer*
) as xs:string
fn:string-to-codepoints($arg as xs:string?
) as xs:integer*
Equality and Comparison of Strings
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?
Functions on String Values
fn:concat($arg1 as xs:string?
, $arg2 as xs:string?
, ...) as xs:string
fn:string-join($arg1 as xs:string*
, $arg2 as xs:string
) as xs:string
fn:substring($sourceString as xs:string?, $startingLoc as xs:double) as xs:string
fn:substring($sourceString as xs:string?, $startingLoc as xs:double, $length as xs:double) as xs:string
fn:string-length() as xs:integer
fn:string-length($arg as xs:string) as xs:integer
fn:normalize-space() as xs:string
fn:normalize-space($arg as xs:string?) as xs:string
fn:normalize-unicode($arg as xs:string?) as xs:string
fn:normalize-unicode($arg as xs:string?, $normalizationForm as xs:string) as xs:string
fn:upper-case($arg as xs:string?) as xs:string
fn:lower-case($arg as xs:string?) as xs:string
fn:translate($arg as xs:string?, $mapString as xs:string, $transString as xs:string) as xs:string
fn:escape-uri($uri-part as xs:string?, $escape-reserved as xs:boolean) as xs:string
Functions Based on Substring Matchingfn:normalize-unicode
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
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
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
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
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
String Functions that Use Pattern Matching
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
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: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+
Functions and Operators on Boolean ValuesBooleans
Additional Boolean Constructor Functions
fn:true() as xs:boolean
fn:false() as xs:boolean
Operators on Boolean Values
op:boolean-equal($value1 as xs:boolean, $value2 as xs:boolean) as xs:boolean
op:boolean-less-than($arg1 as xs:boolean
, $arg2 as xs:boolean
) as xs:boolean
op:boolean-greater-than($arg1 as xs:boolean
, $arg2 as xs:boolean
) as xs:boolean
Functions on Boolean Values
fn:not($arg as item()*
) as xs:boolean
Functions and Operators on Durations, Dates and Times
Comparisons of Duration, Date and Time Values
op:yearMonthDuration-equal($arg1 as xdt:yearMonthDuration
, $arg2 as xdt:yearMonthDuration
) as xs:boolean
op:yearMonthDuration-less-than($arg1 as xdt:yearMonthDuration
, $arg2 as xdt:yearMonthDuration
) as xs:boolean
op:yearMonthDuration-greater-than($arg1 as xdt:yearMonthDuration
, $arg2 as xdt:yearMonthDuration
) as xs:boolean
op:dayTimeDuration-equal($arg1 as xdt:dayTimeDuration
, $arg2 as xdt:dayTimeDuration
) as xs:boolean
op:dayTimeDuration-less-than($arg1 as xdt:dayTimeDuration
, $arg2 as xdt:dayTimeDuration
) as xs:boolean
op:dayTimeDuration-greater-than($arg1 as xdt:dayTimeDuration
, $arg2 as xdt:dayTimeDuration
) as xs:boolean
op:dateTime-equal($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
op:dateTime-greater-than($arg1 as xs:dateTime
, $arg2 as xs:dateTime
) as xs:boolean
op:date-equal($arg1 as xs:date
, $arg2 as xs:date
) as xs:boolean
op:date-less-than($arg1 as xs:date
, $arg2 as xs:date
) as xs:boolean
op:date-greater-than($arg1 as xs:date
, $arg2 as xs:date
) as xs:boolean
op:time-equal($arg1 as xs:time
, $arg2 as xs:time
) as xs:boolean
op:time-less-than($arg1 as xs:time
, $arg2 as xs:time
) as xs:boolean
op:time-greater-than($arg1 as xs:time
, $arg2 as xs:time
) as xs:boolean
op:gYearMonth-equal($arg1 as xs:gYearMonth
, $arg2 as xs:gYearMonth
) as xs:boolean
op:gYear-equal($arg1 as xs:gYear
, $arg2 as xs:gYear
) as xs:boolean
op:gMonthDay-equal($arg1 as xs:gMonthDay
, $arg2 as xs:gMonthDay
) as xs:boolean
op:gMonth-equal($arg1 as xs:gMonth
, $arg2 as xs:gMonth
) as xs:boolean
op:gDay-equal($arg1 as xs:gDay
, $arg2 as xs:gDay
) as xs:boolean
Component Extraction Functions on Duration, Date and Time Values
fn:get-years-from-yearMonthDuration($arg as xdt:yearMonthDuration?
) as xs:integer?
fn:get-months-from-yearMonthDuration($arg as xdt:yearMonthDuration?
) as xs:integer?
fn:get-days-from-dayTimeDuration($arg as xdt:dayTimeDuration?
) as xs:integer?
fn:get-hours-from-dayTimeDuration($arg as xdt:dayTimeDuration?
) as xs:integer?
fn:get-minutes-from-dayTimeDuration($arg as xdt:dayTimeDuration?
) as xs:integer?
fn:get-seconds-from-dayTimeDuration($arg as xdt:dayTimeDuration?
) as xs:decimal?
fn:get-year-from-dateTime($arg as xs:dateTime?
) as xs:integer?
fn:get-month-from-dateTime($arg as xs:dateTime?
) as xs:integer?
fn:get-day-from-dateTime($arg as xs:dateTime?
) as xs:integer?
fn:get-hours-from-dateTime($arg as xs:dateTime?
) as xs:integer?
fn:get-minutes-from-dateTime($arg as xs:dateTime?
) as xs:integer?
fn:get-seconds-from-dateTime($arg as xs:dateTime?
) as xs:decimal?
fn:get-timezone-from-dateTime($arg as xs:dateTime?
) as xdt:dayTimeDuration?
fn:get-year-from-date($arg as xs:date?
) as xs:integer?
fn:get-month-from-date($arg as xs:date?
) as xs:integer?
fn:get-day-from-date($arg as xs:date?
) as xs:integer?
fn:get-timezone-from-date($arg as xs:date?
) as xdt:dayTimeDuration?
fn:get-hours-from-time($arg as xs:time?
) as xs:integer?
fn:get-minutes-from-time($arg as xs:time?
) as xs:integer?
fn:get-seconds-from-time($arg as xs:time?
) as xs:decimal?
fn:get-timezone-from-time($arg as xs:time?
) as xdt:dayTimeDuration?
Arithmetic Functions on xdt:yearMonthDuration and xdt:dayTimeDuration
op:add-yearMonthDurations($arg1 as xdt:yearMonthDuration
, $arg2 as xdt:yearMonthDuration
) as xdt:yearMonthDuration
op:subtract-yearMonthDurations($arg1 as xdt:yearMonthDuration
, $arg2 as xdt:yearMonthDuration
) as xdt:yearMonthDuration
op:multiply-yearMonthDuration($arg1 as xdt:yearMonthDuration
, $arg2 as xs:double
) as xdt:yearMonthDuration
op:divide-yearMonthDuration($arg1 as xdt:yearMonthDuration
, $arg2 as xs:double
) as xdt:yearMonthDuration
op:add-dayTimeDurations($arg1 as xdt:dayTimeDuration
, $arg2 as xdt:dayTimeDuration
) as xdt:dayTimeDuration
op:subtract-dayTimeDurations($arg1 as xdt:dayTimeDuration
, $arg2 as xdt:dayTimeDuration
) as xdt:dayTimeDuration
op:multiply-dayTimeDuration($arg1 as xdt:dayTimeDuration
, $arg2 as xs:double
) as xdt:dayTimeDuration
op:divide-dayTimeDuration($arg1 as xdt:dayTimeDuration
, $arg2 as xs:double
) as xdt:dayTimeDuration
Timezone Adjustment on dateTime, date and time Values
fn:adjust-dateTime-to-timezone($arg as xs:dateTime?
) as xs:dateTime?
fn:adjust-dateTime-to-timezone($arg as xs:dateTime?
, $timezone as xdt:dayTimeDuration?) as xs:dateTime?
fn:adjust-date-to-timezone($arg as xs:date?
) as xs:date?
fn:adjust-date-to-timezone($arg as xs:date?
, $timezone as xdt:dayTimeDuration?) as xs:date?
fn:adjust-time-to-timezone($arg as xs:time?) as xs:time?
fn:adjust-time-to-timezone($arg as xs:time?
, $timezone as xdt:dayTimeDuration?) as xs:time?
Adding and Subtracting Durations From dateTime, date and time
fn:subtract-dateTimes-yielding-yearMonthDuration($arg1 as xs:dateTime?, $arg2 as xs:dateTime?) as xdt:yearMonthDuration?
fn:subtract-dateTimes-yielding-dayTimeDuration($arg1 as xs:dateTime?, $arg2 as xs:dateTime?) as xdt:dayTimeDuration?
op:subtract-dates($arg1 as xs:date?, $arg2 as xs:date?) as xdt:dayTimeDuration?
op:subtract-times($arg1 as xs:time?, $arg2 as xs:time?) as xdt:dayTimeDuration?
op:add-yearMonthDuration-to-dateTime($arg1 as xs:dateTime
, $arg2 as xdt:yearMonthDuration
) as xs:dateTime
op:add-dayTimeDuration-to-dateTime($arg1 as xs:dateTime
, $arg2 as xdt:dayTimeDuration
) as xs:dateTime
op:subtract-yearMonthDuration-from-dateTime($arg1 as xs:dateTime
, $arg2 as xdt:yearMonthDuration
) as xs:dateTime
op:subtract-dayTimeDuration-from-dateTime($arg1 as xs:dateTime
, $arg2 as xdt:dayTimeDuration
) as xs:dateTime
op:add-yearMonthDuration-to-date($arg1 as xs:date
, $arg2 as xdt:yearMonthDuration
) as xs:date
op:add-dayTimeDuration-to-date($arg1 as xs:date
, $arg2 as xdt:dayTimeDuration
) as xs:date
op:subtract-yearMonthDuration-from-date($arg1 as xs:date
, $arg2 as xdt:yearMonthDuration
) as xs:date
op:subtract-dayTimeDuration-from-date($arg1 as xs:date
, $arg2 as xdt:dayTimeDuration
) as xs:date
op:add-dayTimeDuration-to-time($arg1 as xs:time
, $arg2 as xdt:dayTimeDuration
) as xs:time
op:subtract-dayTimeDuration-from-time($arg1 as xs:time
, $arg2 as xdt:dayTimeDuration
) as xs:time
Functions Related to QNames
Additional Constructor Functions for QNames
fn:resolve-QName($qname as xs:string?, $element as element()?) as xs:QName?
fn:expanded-QName($paramURI as xs:string?, $paramLocal as xs:string) as xs:QName
Operators and Functions Related to QNames
op:QName-equal($arg1 as xs:QName, $arg2 as xs:QName) as xs:boolean
fn:get-local-name-from-QName($arg as xs:QName?) as xs:string?
fn:get-namespace-uri-from-QName($arg as xs:QName?) as xs:string?
fn:get-namespace-uri-for-prefix($prefix as xs:string, $element as element
) as xs:string?
fn:get-in-scope-prefixes($element as element) as xs:string*
Functions and Operators for anyURI
fn:resolve-uri
fn:resolve-uri($relative as xs:string?) as xs:string?
fn:resolve-uri($relative as xs:string?, $base as xs:string) as xs:string?
op:anyURI-equal
op:anyURI-equal($arg1 as xs:anyURI
, $arg2 as xs:anyURI
) as xs:boolean
Functions and Operators on base64Binary and hexBinary
Comparisons of base64Binary and hexBinary Values
op:hexBinary-equal($value1 as xs:hexBinary, $value2 as xs:hexBinary) as xs:boolean
op:base64Binary-equal($value1 as xs:base64Binary, $value2 as xs:base64Binary) as xs:boolean
Functions and Operators on NOTATION
Operators on NOTATION
op:NOTATION-equal($arg1 as xs:NOTATION
, $arg2 as xs:NOTATION
) as xs:boolean
Functions and Operators on Nodes
Functions and Operators on Nodes
fn:name() as xs:string
fn:name($arg as node()?) as xs:string
fn:local-name() as xs:string
fn:local-name($arg as node()?
) as xs:string
fn:namespace-uri() as xs:string
fn:namespace-uri($arg as node()?
) as xs:string
fn:number() as xs:double
fn:number($arg as item()?
) as xs:double
fn:lang($testlang as xs:string?
) as xs:boolean
op:is-same-node($parameter1 as node(), $parameter2 as node()) as xs:boolean
op:node-before($parameter1 as node()
, $parameter2 as node()
) as xs:boolean
op:node-after($parameter1 as node()
, $parameter2 as node()
) as xs:boolean
fn:root() as node()
fn:root($arg as node()?) as node()?
Functions and Operators on Sequences
Functions and Operators on Sequences
fn:zero-or-one($arg as item()*) as item()?
fn:one-or-more($arg as item()*) as item()+
fn:exactly-one($arg as item()*) as item()
fn:boolean($arg as item()*
) as xs:boolean
op:concatenate($seq1 as item()*, $seq2 as item()*) as item()*
fn:index-of($seqParam as xdt:anyAtomicType*
, $srchParam as xdt:anyAtomicType
) as xs:integer*
fn:index-of($seqParam as xdt:anyAtomicType*
, $srchParam as xdt:anyAtomicType
, $collation as xs:string
) as xs:integer*
fn:empty($arg as item()*
) as xs:boolean
fn:exists($arg as item()*
) as xs:boolean
fn:distinct-values($arg as xdt:anyAtomicType*) as xdt:anyAtomicType*
fn:distinct-values($arg as xdt:anyAtomicType*, $collation as xs:string) as xdt:anyAtomicType*
fn:insert-before($target as item()*, $position as xs:integer, $inserts as item()*) as item()*
fn:remove($target as item()*, $position as xs:integer) as item()*
fn:reverse($arg as item()*) as item()*
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()*
fn:unordered($sourceSeq as item()*) as item()*
Equals, Union, Intersection and Except
fn:deep-equal($parameter1 as item()*
, $parameter2 as item()*
) as xs:boolean
fn:deep-equal($parameter1 as item()*
, $parameter2 as item()*
, $collation as string
) as xs:boolean
op:union($parameter1 as node()*, $parameter2 as node()*) as node()*
op:intersect($parameter1 as node()*, $parameter2 as node()*) as node()*
op:except($parameter1 as node()*, $parameter2 as node()*) as node()*
Aggregate Functions
fn:count($arg as item()*) as xs:integer
fn:avg($arg as xdt:anyAtomicType*) as xdt:anyAtomicType?
fn:max($arg as xdt:anyAtomicType*) as xdt:anyAtomicType?
fn:max($arg as xdt:anyAtomicType*, $collation as string) as xdt:anyAtomicType?
fn:min($arg as xdt:anyAtomicType*) as xdt:anyAtomicType?
fn:min($arg as xdt:anyAtomicType*, $collation as string) as xdt:anyAtomicType?
fn:sum($arg as xdt:anyAtomicType*) as xdt:anyAtomicType
fn:sum($arg as xdt:anyAtomicType*, $zero as xdt:anyAtomicType?) as xdt:anyAtomicType?
Functions and Operators that Generate Sequences
op:to($firstval as xs:integer, $lastval as xs:integer) as xs:integer*
fn:id($arg as xs:string*) as element()*
fn:idref($arg as xs:string*) as node()*
fn:doc($uri as xs:string?) as document?
fn:collection($arg as xs:string?) as node()*
Context Functions
fn:position
fn:position() as xs:integer
fn:last
fn:last() as xs:integer
fn:current-dateTime
fn:current-dateTime() as xs:dateTime
fn:current-date
fn:current-date() as xs:date
fn:current-time
fn:current-time() as xs:time
fn:default-collation
fn:default-collation() as xs:string
fn:implicit-timezone
fn:implicit-timezone() as xdt:dayTimeDuration?

G.2 Functions and Operators Alphabetically
fn:abs($arg as numeric?) as numeric?
op:add-dayTimeDuration-to-date($arg1 as xs:date
, $arg2 as xdt:dayTimeDuration
) as xs:date
op:add-dayTimeDuration-to-dateTime($arg1 as xs:dateTime
, $arg2 as xdt:dayTimeDuration
) as xs:dateTime
op:add-dayTimeDuration-to-time($arg1 as xs:time
, $arg2 as xdt:dayTimeDuration
) as xs:time
op:add-dayTimeDurations($arg1 as xdt:dayTimeDuration
, $arg2 as xdt:dayTimeDuration
) as xdt:dayTimeDuration
op:add-yearMonthDuration-to-date($arg1 as xs:date
, $arg2 as xdt:yearMonthDuration
) as xs:date
op:add-yearMonthDuration-to-dateTime($arg1 as xs:dateTime
, $arg2 as xdt:yearMonthDuration
) as xs:dateTime
op:add-yearMonthDurations($arg1 as xdt:yearMonthDuration
, $arg2 as xdt:yearMonthDuration
) as xdt:yearMonthDuration
fn:adjust-date-to-timezone($arg as xs:date?
) as xs:date?
fn:adjust-date-to-timezone($arg as xs:date?
, $timezone as xdt:dayTimeDuration?) as xs:date?
fn:adjust-dateTime-to-timezone($arg as xs:dateTime?
) as xs:dateTime?
fn:adjust-dateTime-to-timezone($arg as xs:dateTime?
, $timezone as xdt:dayTimeDuration?) as xs:dateTime?
fn:adjust-time-to-timezone($arg as xs:time?) as xs:time?
fn:adjust-time-to-timezone($arg as xs:time?
, $timezone as xdt:dayTimeDuration?) as xs:time?
op:anyURI-equal($arg1 as xs:anyURI
, $arg2 as xs:anyURI
) as xs:boolean
fn:avg($arg as xdt:anyAtomicType*) as xdt:anyAtomicType?
fn:base-uri($arg as node()?
) as xs:string?
fn:base-uri() as xs:string
op:base64Binary-equal($value1 as xs:base64Binary, $value2 as xs:base64Binary) as xs:boolean
fn:boolean($arg as item()*
) as xs:boolean
op:boolean-equal($value1 as xs:boolean, $value2 as xs:boolean) as xs:boolean
op:boolean-greater-than($arg1 as xs:boolean
, $arg2 as xs:boolean
) as xs:boolean
op:boolean-less-than($arg1 as xs:boolean
, $arg2 as xs:boolean
) as xs:boolean
fn:ceiling($arg as numeric?
) as numeric?
fn:codepoints-to-string($arg as xs:integer*
) as xs:string
fn:collection($arg as xs:string?) as node()*
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:string?
, $arg2 as xs:string?
, ...) as xs:string
op:concatenate($seq1 as item()*, $seq2 as item()*) as item()*
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
fn:count($arg as item()*) as xs:integer
fn:current-date() as xs:date
fn:current-dateTime() as xs:dateTime
fn:current-time() as xs:time
fn:data($arg as item()*
) as xdt:anyAtomicType*
op:date-equal($arg1 as xs:date
, $arg2 as xs:date
) as xs:boolean
op:date-greater-than($arg1 as xs:date
, $arg2 as xs:date
) as xs:boolean
op:date-less-than($arg1 as xs:date
, $arg2 as xs:date
) as xs:boolean
op:dateTime-equal($arg1 as xs:dateTime
, $arg2 as xs:dateTime
) 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
op:dayTimeDuration-equal($arg1 as xdt:dayTimeDuration
, $arg2 as xdt:dayTimeDuration
) as xs:boolean
op:dayTimeDuration-greater-than($arg1 as xdt:dayTimeDuration
, $arg2 as xdt:dayTimeDuration
) as xs:boolean
op:dayTimeDuration-less-than($arg1 as xdt:dayTimeDuration
, $arg2 as xdt:dayTimeDuration
) as xs:boolean
fn:deep-equal($parameter1 as item()*
, $parameter2 as item()*
) as xs:boolean
fn:deep-equal($parameter1 as item()*
, $parameter2 as item()*
, $collation as string
) as xs:boolean
fn:default-collation() as xs:string
fn:distinct-values($arg as xdt:anyAtomicType*) as xdt:anyAtomicType*
fn:distinct-values($arg as xdt:anyAtomicType*, $collation as xs:string) as xdt:anyAtomicType*
op:divide-dayTimeDuration($arg1 as xdt:dayTimeDuration
, $arg2 as xs:double
) as xdt:dayTimeDuration
op:divide-yearMonthDuration($arg1 as xdt:yearMonthDuration
, $arg2 as xs:double
) as xdt:yearMonthDuration
fn:doc($uri as xs:string?) as document?
fn:document-uri($arg as node()?
) as xs:string?
fn:empty($arg as item()*
) as xs:boolean
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
fn:error() as none
fn:error($arg as item()?
) as none
fn:escape-uri($uri-part as xs:string?, $escape-reserved as xs:boolean) as xs:string
fn:exactly-one($arg as item()*) as item()
op:except($parameter1 as node()*, $parameter2 as node()*) as node()*
fn:exists($arg as item()*
) as xs:boolean
fn:expanded-QName($paramURI as xs:string?, $paramLocal as xs:string) as xs:QName
fn:false() as xs:boolean
fn:floor($arg as numeric?) as numeric?
op:gDay-equal($arg1 as xs:gDay
, $arg2 as xs:gDay
) as xs:boolean
fn:get-day-from-date($arg as xs:date?
) as xs:integer?
fn:get-day-from-dateTime($arg as xs:dateTime?
) as xs:integer?
fn:get-days-from-dayTimeDuration($arg as xdt:dayTimeDuration?
) as xs:integer?
fn:get-hours-from-dateTime($arg as xs:dateTime?
) as xs:integer?
fn:get-hours-from-dayTimeDuration($arg as xdt:dayTimeDuration?
) as xs:integer?
fn:get-hours-from-time($arg as xs:time?
) as xs:integer?
fn:get-in-scope-prefixes($element as element) as xs:string*
fn:get-local-name-from-QName($arg as xs:QName?) as xs:string?
fn:get-minutes-from-dateTime($arg as xs:dateTime?
) as xs:integer?
fn:get-minutes-from-dayTimeDuration($arg as xdt:dayTimeDuration?
) as xs:integer?
fn:get-minutes-from-time($arg as xs:time?
) as xs:integer?
fn:get-month-from-date($arg as xs:date?
) as xs:integer?
fn:get-month-from-dateTime($arg as xs:dateTime?
) as xs:integer?
fn:get-months-from-yearMonthDuration($arg as xdt:yearMonthDuration?
) as xs:integer?
fn:get-namespace-uri-for-prefix($prefix as xs:string, $element as element
) as xs:string?
fn:get-namespace-uri-from-QName($arg as xs:QName?) as xs:string?
fn:get-seconds-from-dateTime($arg as xs:dateTime?
) as xs:decimal?
fn:get-seconds-from-dayTimeDuration($arg as xdt:dayTimeDuration?
) as xs:decimal?
fn:get-seconds-from-time($arg as xs:time?
) as xs:decimal?
fn:get-timezone-from-date($arg as xs:date?
) as xdt:dayTimeDuration?
fn:get-timezone-from-dateTime($arg as xs:dateTime?
) as xdt:dayTimeDuration?
fn:get-timezone-from-time($arg as xs:time?
) as xdt:dayTimeDuration?
fn:get-year-from-date($arg as xs:date?
) as xs:integer?
fn:get-year-from-dateTime($arg as xs:dateTime?
) as xs:integer?
fn:get-years-from-yearMonthDuration($arg as xdt:yearMonthDuration?
) as xs:integer?
op:gMonth-equal($arg1 as xs:gMonth
, $arg2 as xs:gMonth
) as xs:boolean
op:gMonthDay-equal($arg1 as xs:gMonthDay
, $arg2 as xs:gMonthDay
) as xs:boolean
op:gYear-equal($arg1 as xs:gYear
, $arg2 as xs:gYear
) 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:id($arg as xs:string*) as element()*
fn:idref($arg as xs:string*) as node()*
fn:implicit-timezone() as xdt:dayTimeDuration?
fn:index-of($seqParam as xdt:anyAtomicType*
, $srchParam as xdt:anyAtomicType
) as xs:integer*
fn:index-of($seqParam as xdt:anyAtomicType*
, $srchParam as xdt: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 as node()*, $parameter2 as node()*) as node()*
op:is-same-node($parameter1 as node(), $parameter2 as node()) as xs:boolean
fn:lang($testlang as xs:string?
) as xs:boolean
fn:last() as xs:integer
fn:local-name() as xs:string
fn:local-name($arg as node()?
) as xs:string
fn:lower-case($arg as xs:string?) as xs:string
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
fn:max($arg as xdt:anyAtomicType*) as xdt:anyAtomicType?
fn:max($arg as xdt:anyAtomicType*, $collation as string) as xdt:anyAtomicType?
fn:min($arg as xdt:anyAtomicType*) as xdt:anyAtomicType?
fn:min($arg as xdt:anyAtomicType*, $collation as string) as xdt:anyAtomicType?
op:multiply-dayTimeDuration($arg1 as xdt:dayTimeDuration
, $arg2 as xs:double
) as xdt:dayTimeDuration
op:multiply-yearMonthDuration($arg1 as xdt:yearMonthDuration
, $arg2 as xs:double
) as xdt:yearMonthDuration
fn:name() as xs:string
fn:name($arg as node()?) as xs:string
fn:namespace-uri() as xs:string
fn:namespace-uri($arg as node()?
) as xs:string
op:node-after($parameter1 as node()
, $parameter2 as node()
) as xs:boolean
op:node-before($parameter1 as node()
, $parameter2 as node()
) as xs:boolean
fn:node-name($arg as node()?
) as xs:QName?
fn:normalize-space() as xs:string
fn:normalize-space($arg as xs:string?) as xs:string
fn:normalize-unicode($arg as xs:string?) as xs:string
fn:normalize-unicode($arg as xs:string?, $normalizationForm as xs:string) as xs:string
fn:not($arg as item()*
) as xs:boolean
op:NOTATION-equal($arg1 as xs:NOTATION
, $arg2 as xs:NOTATION
) as xs:boolean
fn:number() as xs:double
fn:number($arg as item()?
) as xs:double
op:numeric-add($arg1 as numeric
, $arg2 as numeric
) as numeric
op:numeric-divide($arg1 as numeric
, $arg2 as numeric
) as numeric
op:numeric-equal($arg1 as numeric
, $arg2 as numeric
) as xs:boolean
op:numeric-greater-than($arg1 as numeric
, $arg2 as numeric
) as xs:boolean
op:numeric-integer-divide($arg1 as xs:integer
, $arg2 as xs:integer
) as xs:integer
op:numeric-less-than($arg1 as numeric
, $arg2 as numeric
) as xs:boolean
op:numeric-mod($arg1 as numeric
, $arg2 as numeric
) as numeric
op:numeric-multiply($arg1 as numeric
, $arg2 as numeric
) as numeric
op:numeric-subtract($arg1 as numeric
, $arg2 as numeric
) as numeric
op:numeric-unary-minus($arg as numeric
) as numeric
op:numeric-unary-plus($arg as numeric
) as numeric
fn:one-or-more($arg as item()*) as item()+
fn:position() as xs:integer
op:QName-equal($arg1 as xs:QName, $arg2 as xs:QName) as xs:boolean
fn:remove($target as item()*, $position as xs:integer) as item()*
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-QName($qname as xs:string?, $element as element()?) as xs:QName?
fn:resolve-uri($relative as xs:string?) as xs:string?
fn:resolve-uri($relative as xs:string?, $base as xs:string) as xs:string?
fn:reverse($arg as item()*) as item()*
fn:root() as node()
fn:root($arg as node()?) as node()?
fn:round($arg as numeric?) as numeric?
fn:round-half-to-even($arg as numeric?
) as numeric?
fn:round-half-to-even($arg as numeric?
, $precision as xs:integer
) as numeric?
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
fn:string() as xs:string
fn:string($arg as item()?
) as xs:string
fn:string-join($arg1 as xs:string*
, $arg2 as xs:string
) as xs:string
fn:string-length() as xs:integer
fn:string-length($arg as xs:string) as xs:integer
fn:string-to-codepoints($arg as xs:string?
) as xs:integer*
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()*
fn:substring($sourceString as xs:string?, $startingLoc as xs:double) as xs:string
fn:substring($sourceString as xs:string?, $startingLoc as xs:double, $length as xs:double) as xs:string
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
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
op:subtract-dates($arg1 as xs:date?, $arg2 as xs:date?) as xdt:dayTimeDuration?
fn:subtract-dateTimes-yielding-dayTimeDuration($arg1 as xs:dateTime?, $arg2 as xs:dateTime?) as xdt:dayTimeDuration?
fn:subtract-dateTimes-yielding-yearMonthDuration($arg1 as xs:dateTime?, $arg2 as xs:dateTime?) as xdt:yearMonthDuration?
op:subtract-dayTimeDuration-from-date($arg1 as xs:date
, $arg2 as xdt:dayTimeDuration
) as xs:date
op:subtract-dayTimeDuration-from-dateTime($arg1 as xs:dateTime
, $arg2 as xdt:dayTimeDuration
) as xs:dateTime
op:subtract-dayTimeDuration-from-time($arg1 as xs:time
, $arg2 as xdt:dayTimeDuration
) as xs:time
op:subtract-dayTimeDurations($arg1 as xdt:dayTimeDuration
, $arg2 as xdt:dayTimeDuration
) as xdt:dayTimeDuration
op:subtract-times($arg1 as xs:time?, $arg2 as xs:time?) as xdt:dayTimeDuration?
op:subtract-yearMonthDuration-from-date($arg1 as xs:date
, $arg2 as xdt:yearMonthDuration
) as xs:date
op:subtract-yearMonthDuration-from-dateTime($arg1 as xs:dateTime
, $arg2 as xdt:yearMonthDuration
) as xs:dateTime
op:subtract-yearMonthDurations($arg1 as xdt:yearMonthDuration
, $arg2 as xdt:yearMonthDuration
) as xdt:yearMonthDuration
fn:sum($arg as xdt:anyAtomicType*) as xdt:anyAtomicType
fn:sum($arg as xdt:anyAtomicType*, $zero as xdt:anyAtomicType?) as xdt:anyAtomicType?
op:time-equal($arg1 as xs:time
, $arg2 as xs:time
) as xs:boolean
op:time-greater-than($arg1 as xs:time
, $arg2 as xs:time
) as xs:boolean
op:time-less-than($arg1 as xs:time
, $arg2 as xs:time
) as xs:boolean
op:to($firstval as xs:integer, $lastval as xs:integer) as xs:integer*
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+
fn:trace($value as item()*, $label as xs:string) as item()*
fn:translate($arg as xs:string?, $mapString as xs:string, $transString as xs:string) as xs:string
fn:true() as xs:boolean
op:union($parameter1 as node()*, $parameter2 as node()*) as node()*
fn:unordered($sourceSeq as item()*) as item()*
fn:upper-case($arg as xs:string?) as xs:string
op:yearMonthDuration-equal($arg1 as xdt:yearMonthDuration
, $arg2 as xdt:yearMonthDuration
) as xs:boolean
op:yearMonthDuration-greater-than($arg1 as xdt:yearMonthDuration
, $arg2 as xdt:yearMonthDuration
) as xs:boolean
op:yearMonthDuration-less-than($arg1 as xdt:yearMonthDuration
, $arg2 as xdt:yearMonthDuration
) as xs:boolean
fn:zero-or-one($arg as item()*) as item()?

`fn:normalize-unicode`(	`$arg`	`as` `xs:string?`,
`fn:normalize-unicode`(	`$normalizationForm`	`as` `xs:string`) `as` `xs:string`

`fn:translate`(	`$arg`	`as` `xs:string?`,
	`$mapString`	`as` `xs:string`,
	`$transString`	`as` `xs:string`) `as` `xs:string`

`fn:escape-uri`(	`$uri-part`	`as` `xs:string?`,
`fn:escape-uri`(	`$escape-reserved`	`as` `xs:boolean`) `as` `xs:string`

`fn:matches`(	`$input`	`as` `xs:string?`,
	`$pattern`	`as` `xs:string`,
	`$flags`	`as` `xs:string`) `as` `xs:boolean`

`fn:replace`(	`$input`	`as` `xs:string?`,
	`$pattern`	`as` `xs:string`,
	`$replacement`	`as` `xs:string`) `as` `xs:string`

`fn:contains`(	`$arg1`	`as` `xs:string?`,
	`$arg2`	`as` `xs:string?`,
	`$collation`	`as` `xs:string`) `as` `xs:boolean`

`fn:starts-with`(	`$arg1`	`as` `xs:string?`,
	`$arg2`	`as` `xs:string?`,
	`$collation`	`as` `xs:string`) `as` `xs:boolean`

`fn:ends-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:tokenize`(	`$input`	`as` `xs:string?`,
	`$pattern`	`as` `xs:string`,
	`$flags`	`as` `xs:string`) `as` `xs:string+`

`op:yearMonthDuration-equal`(	`$arg1`	`as` `xdt:yearMonthDuration`,
`op:yearMonthDuration-equal`(	`$arg2`	`as` `xdt:yearMonthDuration`) `as` `xs:boolean`

`op:yearMonthDuration-less-than`(	`$arg1`	`as` `xdt:yearMonthDuration`,
`op:yearMonthDuration-less-than`(	`$arg2`	`as` `xdt:yearMonthDuration`) `as` `xs:boolean`

`op:yearMonthDuration-greater-than`(	`$arg1`	`as` `xdt:yearMonthDuration`,
`op:yearMonthDuration-greater-than`(	`$arg2`	`as` `xdt:yearMonthDuration`) `as` `xs:boolean`

`op:dayTimeDuration-equal`(	`$arg1`	`as` `xdt:dayTimeDuration`,
`op:dayTimeDuration-equal`(	`$arg2`	`as` `xdt:dayTimeDuration`) `as` `xs:boolean`

`op:dayTimeDuration-less-than`(	`$arg1`	`as` `xdt:dayTimeDuration`,
`op:dayTimeDuration-less-than`(	`$arg2`	`as` `xdt:dayTimeDuration`) `as` `xs:boolean`

`op:dayTimeDuration-greater-than`(	`$arg1`	`as` `xdt:dayTimeDuration`,
`op:dayTimeDuration-greater-than`(	`$arg2`	`as` `xdt:dayTimeDuration`) `as` `xs:boolean`

`op:dateTime-greater-than`(	`$arg1`	`as` `xs:dateTime`,
`op:dateTime-greater-than`(	`$arg2`	`as` `xs:dateTime`) `as` `xs:boolean`

`op:gYearMonth-equal`(	`$arg1`	`as` `xs:gYearMonth`,
`op:gYearMonth-equal`(	`$arg2`	`as` `xs:gYearMonth`) `as` `xs:boolean`

`op:add-yearMonthDurations`(	`$arg1`	`as` `xdt:yearMonthDuration`,
`op:add-yearMonthDurations`(	`$arg2`	`as` `xdt:yearMonthDuration`) `as` `xdt:yearMonthDuration`

`op:subtract-yearMonthDurations`(	`$arg1`	`as` `xdt:yearMonthDuration`,
`op:subtract-yearMonthDurations`(	`$arg2`	`as` `xdt:yearMonthDuration`) `as` `xdt:yearMonthDuration`

`op:multiply-yearMonthDuration`(	`$arg1`	`as` `xdt:yearMonthDuration`,
`op:multiply-yearMonthDuration`(	`$arg2`	`as` `xs:double`) `as` `xdt:yearMonthDuration`

`op:divide-yearMonthDuration`(	`$arg1`	`as` `xdt:yearMonthDuration`,
`op:divide-yearMonthDuration`(	`$arg2`	`as` `xs:double`) `as` `xdt:yearMonthDuration`

`op:add-dayTimeDurations`(	`$arg1`	`as` `xdt:dayTimeDuration`,
`op:add-dayTimeDurations`(	`$arg2`	`as` `xdt:dayTimeDuration`) `as` `xdt:dayTimeDuration`

`op:subtract-dayTimeDurations`(	`$arg1`	`as` `xdt:dayTimeDuration`,
`op:subtract-dayTimeDurations`(	`$arg2`	`as` `xdt:dayTimeDuration`) `as` `xdt:dayTimeDuration`

`op:multiply-dayTimeDuration`(	`$arg1`	`as` `xdt:dayTimeDuration`,
`op:multiply-dayTimeDuration`(	`$arg2`	`as` `xs:double`) `as` `xdt:dayTimeDuration`

`op:divide-dayTimeDuration`(	`$arg1`	`as` `xdt:dayTimeDuration`,
`op:divide-dayTimeDuration`(	`$arg2`	`as` `xs:double`) `as` `xdt:dayTimeDuration`

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 all.
`fn:adjust-time-to-timezone`	Adjusts an `xs:time` value to a specific timezone, or to no timezone at all.

`fn:adjust-dateTime-to-timezone`(	`$arg`	`as` `xs:dateTime?`,
`fn:adjust-dateTime-to-timezone`(	`$timezone`	`as` `xdt:dayTimeDuration?`) `as` `xs:dateTime?`

`fn:adjust-date-to-timezone`(	`$arg`	`as` `xs:date?`,
`fn:adjust-date-to-timezone`(	`$timezone`	`as` `xdt:dayTimeDuration?`) `as` `xs:date?`

`fn:adjust-time-to-timezone`(	`$arg`	`as` `xs:time?`,
`fn:adjust-time-to-timezone`(	`$timezone`	`as` `xdt:dayTimeDuration?`) `as` `xs:time?`

Function	Meaning
`fn:subtract-dateTimes-yielding-yearMonthDuration`	Returns the difference between two `xs:dateTime`s as an `xdt:yearMonthDuration`.
`fn:subtract-dateTimes-yielding-dayTimeDuration`	Returns the difference between two `xs:dateTimes` as an `xdt:dayTimeDuration`.
`op:subtract-dates`	Returns the difference between two `xs:date`s as an `xdt:dayTimeDuration`.
`op:subtract-times`	Returns the difference between two `xs:time`s as an `xdt:dayTimeDuration`.
`op:add-yearMonthDuration-to-dateTime`	Returns the end of a time period by adding an `xdt:yearMonthDuration` to the `xs:dateTime` that starts the period.
`op:add-dayTimeDuration-to-dateTime`	Returns the end of a time period by adding an `xdt:dayTimeDuration` to the `xs:dateTime` that starts the period.
`op:subtract-yearMonthDuration-from-dateTime`	Returns the beginning of a time period by subtracting an `xdt:yearMonthDuration` from the `xs:dateTime` that ends the period.
`op:subtract-dayTimeDuration-from-dateTime`	Returns the beginning of a time period by subtracting an `xdt:dayTimeDuration` from the `xs:dateTime` that ends the period.
`op:add-yearMonthDuration-to-date`	Returns the end of a time period by adding an `xdt:yearMonthDuration` to the `xs:date` that starts the period.
`op:add-dayTimeDuration-to-date`	Returns the end of a time period by adding an `xdt:dayTimeDuration` to the `xs:date` that starts the period.
`op:subtract-yearMonthDuration-from-date`	Returns the beginning of a time period by subtracting an `xdt:yearMonthDuration` from the `xs:date` that ends the period.
`op:subtract-dayTimeDuration-from-date`	Returns the beginning of a time period by subtracting an `xdt:dayTimeDuration` from the `xs:date` that ends the period.
`op:add-dayTimeDuration-to-time`	Adds the value of the hours, minutes and seconds components of an `xdt:dayTimeDuration` to an `xs:time` value.
`op:subtract-dayTimeDuration-from-time`	Subtracts the value of the hours, minutes and seconds components of an `xdt:dayTimeDuration` to an `xs:time` value.

`op:add-yearMonthDuration-to-dateTime`(	`$arg1`	`as` `xs:dateTime`,
`op:add-yearMonthDuration-to-dateTime`(	`$arg2`	`as` `xdt:yearMonthDuration`) `as` `xs:dateTime`

`op:add-dayTimeDuration-to-dateTime`(	`$arg1`	`as` `xs:dateTime`,
`op:add-dayTimeDuration-to-dateTime`(	`$arg2`	`as` `xdt:dayTimeDuration`) `as` `xs:dateTime`

`op:add-yearMonthDuration-to-date`(	`$arg1`	`as` `xs:date`,
`op:add-yearMonthDuration-to-date`(	`$arg2`	`as` `xdt:yearMonthDuration`) `as` `xs:date`