http://www.functx.com

View as XML or JSON.

-------------------------------- The FunctX XQuery Function Library -------------------------------- Copyright (C) 2007 Datypic This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA For more information on the FunctX XQuery library, contact contrib@functx.com.

Function Summary

add-attributes ($elements as element(*)*, $attrNames as xs:QName*, $attrValues as xs:anyAtomicType*) as element(*)?

Adds attributes to XML elements

add-months ($date as xs:anyAtomicType?, $months as xs:integer) as xs:date?

Adds months to a date

add-or-update-attributes ($elements as element(*)*, $attrNames as xs:QName*, $attrValues as xs:anyAtomicType*) as element(*)?

Adds attributes to XML elements

all-whitespace ($arg as xs:string?) as xs:boolean

Whether a value is all whitespace or a zero-length string

are-distinct-values ($seq as xs:anyAtomicType*) as xs:boolean

Whether all the values in a sequence are distinct

atomic-type ($values as xs:anyAtomicType*) as xs:string*

The built-in type of an atomic value

avg-empty-is-zero ($values as xs:anyAtomicType*, $allNodes as node()*) as xs:double

The average, counting "empty" values as zero

between-exclusive ($value as xs:anyAtomicType?, $minValue as xs:anyAtomicType, $maxValue as xs:anyAtomicType) as xs:boolean

Whether a value is between two provided values

between-inclusive ($value as xs:anyAtomicType?, $minValue as xs:anyAtomicType, $maxValue as xs:anyAtomicType) as xs:boolean

Whether a value is between two provided values, or equal to one of them

camel-case-to-words ($arg as xs:string?, $delim as xs:string) as xs:string

Turns a camelCase string into space-separated words

capitalize-first ($arg as xs:string?) as xs:string?

Capitalizes the first character of a string

change-element-names-deep ($nodes as node()*, $oldNames as xs:QName*, $newNames as xs:QName*) as node()*

Changes the names of elements in an XML fragment

change-element-ns-deep ($nodes as node()*, $newns as xs:string, $prefix as xs:string) as node()*

Changes the namespace of XML elements and its descendants

change-element-ns ($elements as element(*)*, $newns as xs:string, $prefix as xs:string) as element(*)?

Changes the namespace of XML elements

chars ($arg as xs:string?) as xs:string*

Converts a string to a sequence of characters

contains-any-of ($arg as xs:string?, $searchStrings as xs:string*) as xs:boolean

Whether a string contains any of a sequence of strings

contains-case-insensitive ($arg as xs:string?, $substring as xs:string) as xs:boolean?

Whether one string contains another, without regard to case

contains-word ($arg as xs:string?, $word as xs:string) as xs:boolean

Whether one string contains another, as a separate word

copy-attributes ($copyTo as element(*), $copyFrom as element(*)) as element(*)

Copies attributes from one element to another

date ($year as xs:anyAtomicType, $month as xs:anyAtomicType, $day as xs:anyAtomicType) as xs:date

Construct a date from a year, month and day

dateTime ($year as xs:anyAtomicType, $month as xs:anyAtomicType, $day as xs:anyAtomicType, $hour as xs:anyAtomicType, $minute as xs:anyAtomicType, $second as xs:anyAtomicType) as xs:dateTime

Construct a date/time from individual components

day-in-year ($date as xs:anyAtomicType?) as xs:integer?

The day of the year (a number between 1 and 366)

day-of-week-abbrev-en ($date as xs:anyAtomicType?) as xs:string?

The abbreviated day of the week, from a date, in English

day-of-week-name-en ($date as xs:anyAtomicType?) as xs:string?

The name of the day of the week, from a date, in English

day-of-week ($date as xs:anyAtomicType?) as xs:integer?

The day of the week, from a date

dayTimeDuration ($days as xs:decimal?, $hours as xs:decimal?, $minutes as xs:decimal?, $seconds as xs:decimal?) as xs:dayTimeDuration

Construct a dayTimeDuration from a number of days, hours, etc.

days-in-month ($date as xs:anyAtomicType?) as xs:integer?

Number of days in the month

depth-of-node ($node as node()?) as xs:integer

The depth (level) of a node in an XML tree

distinct-attribute-names ($nodes as node()*) as xs:string*

The distinct names of all attributes in an XML fragment

distinct-deep ($nodes as node()*) as node()*

The XML nodes with distinct values, taking into account attributes and descendants

distinct-element-names ($nodes as node()*) as xs:string*

The distinct names of all elements in an XML fragment

distinct-element-paths ($nodes as node()*) as xs:string*

The distinct paths of all descendant elements in an XML fragment

distinct-nodes ($nodes as node()*) as node()*

The distinct XML nodes in a sequence (by node identity)

duration-from-timezone ($timezone as xs:string) as xs:dayTimeDuration

Converts a timezone like "-05:00" or "Z" into xs:dayTimeDuration

dynamic-path ($parent as node(), $path as xs:string) as item()*

Dynamically evaluates a simple XPath path

escape-for-regex ($arg as xs:string?) as xs:string

Escapes regex special characters

exclusive-or ($arg1 as xs:boolean?, $arg2 as xs:boolean?) as xs:boolean?

Whether one (and only one) of two boolean values is true

first-day-of-month ($date as xs:anyAtomicType?) as xs:date?

The first day of the month of a date

first-day-of-year ($date as xs:anyAtomicType?) as xs:date?

The first day of the year of a date

first-node ($nodes as node()*) as node()?

The XML node in a sequence that appears first in document order

follows-not-descendant ($a as node()?, $b as node()?) as xs:boolean

Whether an XML node follows another without being its descendant

format-as-title-en ($titles as xs:string*) as xs:string*

Moves title words like "the" and "a" to the end of strings

fragment-from-uri ($uri as xs:string?) as xs:string?

Returns the fragment from a URI

get-matches-and-non-matches ($string as xs:string?, $regex as xs:string) as element(*)*

Splits a string into matching and non-matching regions

get-matches ($string as xs:string?, $regex as xs:string) as xs:string*

Return the matching regions of a string

has-element-only-content ($element as element(*)) as xs:boolean

Whether an element has element-only content

has-empty-content ($element as element(*)) as xs:boolean

Whether an element has empty content

has-mixed-content ($element as element(*)) as xs:boolean

Whether an element has mixed content

has-simple-content ($element as element(*)) as xs:boolean

Whether an element has simple content

id-from-element ($element as element(*)?) as xs:string?

Gets the ID of an XML element

id-untyped ($node as node()*, $id as xs:anyAtomicType) as element(*)*

Gets XML element(s) that have an attribute with a particular value

if-absent ($arg as item()*, $value as item()*) as item()*

The first argument if it is not empty, otherwise the second argument

if-empty ($arg as item()?, $value as item()*) as item()*

The first argument if it is not blank, otherwise the second argument

index-of-deep-equal-node ($nodes as node()*, $nodeToFind as node()) as xs:integer*

The position of a node in a sequence, based on contents and attributes

index-of-match-first ($arg as xs:string?, $pattern as xs:string) as xs:integer?

The first position of a matching substring

index-of-node ($nodes as node()*, $nodeToFind as node()) as xs:integer*

The position of a node in a sequence, based on node identity

index-of-string-first ($arg as xs:string?, $substring as xs:string) as xs:integer?

The first position of a substring

index-of-string-last ($arg as xs:string?, $substring as xs:string) as xs:integer?

The last position of a substring

index-of-string ($arg as xs:string?, $substring as xs:string) as xs:integer*

The position(s) of a substring

insert-string ($originalString as xs:string?, $stringToInsert as xs:string?, $pos as xs:integer) as xs:string

Inserts a string at a specified position

is-a-number ($value as xs:anyAtomicType?) as xs:boolean

Whether a value is numeric

is-absolute-uri ($uri as xs:string?) as xs:boolean

Whether a URI is absolute

is-ancestor ($node1 as node(), $node2 as node()) as xs:boolean

Whether an XML node is an ancestor of another node

is-descendant ($node1 as node(), $node2 as node()) as xs:boolean

Whether an XML node is a descendant of another node

is-leap-year ($date as xs:anyAtomicType?) as xs:boolean

Whether a date falls in a leap year

is-node-among-descendants-deep-equal ($node as node()?, $seq as node()*) as xs:boolean

Whether an XML node is among the descendants of a sequence, based on contents and attributes

is-node-among-descendants ($node as node()?, $seq as node()*) as xs:boolean

Whether an XML node is among the descendants of a sequence, based on node identity

is-node-in-sequence-deep-equal ($node as node()?, $seq as node()*) as xs:boolean

Whether an XML node is in a sequence, based on contents and attributes

is-node-in-sequence ($node as node()?, $seq as node()*) as xs:boolean

Whether an XML node is in a sequence, based on node identity

is-value-in-sequence ($value as xs:anyAtomicType?, $seq as xs:anyAtomicType*) as xs:boolean

Whether an atomic value appears in a sequence

last-day-of-month ($date as xs:anyAtomicType?) as xs:date?

The last day of the month of a date

last-day-of-year ($date as xs:anyAtomicType?) as xs:date?

The last day of the month of a date

last-node ($nodes as node()*) as node()?

The XML node in a sequence that is last in document order

leaf-elements ($root as node()?) as element(*)*

All XML elements that don't have any child elements

left-trim ($arg as xs:string?) as xs:string

Trims leading whitespace

line-count ($arg as xs:string?) as xs:integer

The number of lines

lines ($arg as xs:string?) as xs:string*

Split a string into separate lines

max-depth ($root as node()?) as xs:integer?

The maximum depth of elements in an XML tree

max-determine-type ($seq as xs:anyAtomicType*) as xs:anyAtomicType?

The maximum value in a sequence, figuring out its type (numeric or string)

max-line-length ($arg as xs:string?) as xs:integer

The maximum line length

max-node ($nodes as node()*) as node()*

The XML node whose typed value is the maximum

max-string ($strings as xs:anyAtomicType*) as xs:string?

The maximum of a sequence of values, treating them like strings

min-determine-type ($seq as xs:anyAtomicType*) as xs:anyAtomicType?

The minimum value in a sequence, figuring out its type (numeric or string)

min-node ($nodes as node()*) as node()*

The XML node whose typed value is the minimum

min-non-empty-string ($strings as xs:string*) as xs:string?

The minimum of a sequence of strings, ignoring "empty" values

min-string ($strings as xs:anyAtomicType*) as xs:string?

The minimum of a sequence of values, treating them like strings

mmddyyyy-to-date ($dateString as xs:string?) as xs:date?

Converts a string with format MMDDYYYY (with any delimiters) to a date

month-abbrev-en ($date as xs:anyAtomicType?) as xs:string?

The month of a date as an abbreviated word (Jan, Feb, etc.

month-name-en ($date as xs:anyAtomicType?) as xs:string?

The month of a date as a word (January, February, etc.

name-test ($testname as xs:string?, $names as xs:string*) as xs:boolean

Whether a name matches a list of names or name wildcards

namespaces-in-use ($root as node()?) as xs:anyURI*

A list of namespaces used in element/attribute names in an XML fragment

next-day ($date as xs:anyAtomicType?) as xs:date?

The next day

node-kind ($nodes as node()*) as xs:string*

The XML node kind (element, attribute, text, etc.

non-distinct-values ($seq as xs:anyAtomicType*) as xs:anyAtomicType*

Returns any values that appear more than once in a sequence

number-of-matches ($arg as xs:string?, $pattern as xs:string) as xs:integer

The number of regions that match a pattern

open-ref-document ($refNode as node()) as document()

Resolves a relative URI and references it, returning an XML document

ordinal-number-en ($num as xs:integer?) as xs:string

Reformats a number as an ordinal number, e.

pad-integer-to-length ($integerToPad as xs:anyAtomicType?, $length as xs:integer) as xs:string

Pads an integer to a desired length by adding leading zeros

pad-string-to-length ($stringToPad as xs:string?, $padChar as xs:string, $length as xs:integer) as xs:string

Pads a string to a desired length

path-to-node-with-pos ($node as node()?) as xs:string

A unique path to an XML node (or sequence of nodes)

path-to-node ($nodes as node()*) as xs:string*

A path to an XML node (or sequence of nodes)

precedes-not-ancestor ($a as node()?, $b as node()?) as xs:boolean

Whether an XML node precedes another without being its ancestor

previous-day ($date as xs:anyAtomicType?) as xs:date?

The previous day

remove-attributes-deep ($nodes as node()*, $names as xs:string*) as node()*

Removes attributes from an XML fragment, based on name

remove-attributes ($elements as element(*)*, $names as xs:string*) as element(*)

Removes attributes from an XML element, based on name

remove-elements-deep ($nodes as node()*, $names as xs:string*) as node()*

Removes descendant elements from an XML node, based on name

remove-elements-not-contents ($nodes as node()*, $names as xs:string*) as node()*

Removes descendant XML elements but keeps their content

remove-elements ($elements as element(*)*, $names as xs:string*) as element(*)*

Removes child elements from an XML node, based on name

repeat-string ($stringToRepeat as xs:string?, $count as xs:integer) as xs:string

Repeats a string a given number of times

replace-beginning ($arg as xs:string?, $pattern as xs:string, $replacement as xs:string) as xs:string

Replaces the beginning of a string, up to a matched pattern

replace-element-values ($elements as element(*)*, $values as xs:anyAtomicType*) as element(*)*

Updates the content of one or more elements

replace-first ($arg as xs:string?, $pattern as xs:string, $replacement as xs:string) as xs:string

Replaces the first match of a pattern

replace-multi ($arg as xs:string?, $changeFrom as xs:string*, $changeTo as xs:string*) as xs:string?

Performs multiple replacements, using pairs of replace parameters

reverse-string ($arg as xs:string?) as xs:string

Reverses the order of characters

right-trim ($arg as xs:string?) as xs:string

Trims trailing whitespace

scheme-from-uri ($uri as xs:string?) as xs:string?

Returns the scheme from a URI

sequence-deep-equal ($seq1 as item()*, $seq2 as item()*) as xs:boolean

Whether two sequences have the same XML node content and/or values

sequence-node-equal-any-order ($seq1 as node()*, $seq2 as node()*) as xs:boolean

Whether two sequences contain the same XML nodes, regardless of order

sequence-node-equal ($seq1 as node()*, $seq2 as node()*) as xs:boolean

Whether two sequences contain the same XML nodes, in the same order

sequence-type ($items as item()*) as xs:string

The sequence type that represents a sequence of nodes or values

siblings-same-name ($element as element(*)?) as element(*)*

The siblings of an XML element that have the same name

siblings ($node as node()?) as node()*

The siblings of an XML node

sort-as-numeric ($seq as item()*) as item()*

Sorts a sequence of numeric values or nodes

sort-case-insensitive ($seq as item()*) as item()*

Sorts a sequence of values or nodes regardless of capitalization

sort-document-order ($seq as node()*) as node()*

Sorts a sequence of nodes in document order

sort ($seq as item()*) as item()*

Sorts a sequence of values or nodes

substring-after-if-contains ($arg as xs:string?, $delim as xs:string) as xs:string?

Performs substring-after, returning the entire string if it does not contain the delimiter

substring-after-last-match ($arg as xs:string?, $regex as xs:string) as xs:string

The substring after the last text that matches a regex

substring-after-last ($arg as xs:string?, $delim as xs:string) as xs:string

The substring after the last occurrence of a delimiter

substring-after-match ($arg as xs:string?, $regex as xs:string) as xs:string?

The substring after the first text that matches a regex

substring-before-if-contains ($arg as xs:string?, $delim as xs:string) as xs:string?

Performs substring-before, returning the entire string if it does not contain the delimiter

substring-before-last-match ($arg as xs:string?, $regex as xs:string) as xs:string?

The substring after the first text that matches a regex

substring-before-last ($arg as xs:string?, $delim as xs:string) as xs:string

The substring before the last occurrence of a delimiter

substring-before-match ($arg as xs:string?, $regex as xs:string) as xs:string

The substring before the last text that matches a regex

time ($hour as xs:anyAtomicType, $minute as xs:anyAtomicType, $second as xs:anyAtomicType) as xs:time

Construct a time from an hour, minute and second

timezone-from-duration ($duration as xs:dayTimeDuration) as xs:string

Converts an xs:dayTimeDuration into a timezone like "-05:00" or "Z"

total-days-from-duration ($duration as xs:dayTimeDuration?) as xs:decimal?

The total number of days in a dayTimeDuration

total-hours-from-duration ($duration as xs:dayTimeDuration?) as xs:decimal?

The total number of hours in a dayTimeDuration

total-minutes-from-duration ($duration as xs:dayTimeDuration?) as xs:decimal?

The total number of minutes in a dayTimeDuration

total-months-from-duration ($duration as xs:yearMonthDuration?) as xs:decimal?

The total number of months in a yearMonthDuration

total-seconds-from-duration ($duration as xs:dayTimeDuration?) as xs:decimal?

The total number of seconds in a dayTimeDuration

total-years-from-duration ($duration as xs:yearMonthDuration?) as xs:decimal?

The total number of years in a yearMonthDuration

trim ($arg as xs:string?) as xs:string

Trims leading and trailing whitespace

update-attributes ($elements as element(*)*, $attrNames as xs:QName*, $attrValues as xs:anyAtomicType*) as element(*)?

Updates the attribute value of an XML element

value-except ($arg1 as xs:anyAtomicType*, $arg2 as xs:anyAtomicType*) as xs:anyAtomicType*

The values in one sequence that aren't in another sequence

value-intersect ($arg1 as xs:anyAtomicType*, $arg2 as xs:anyAtomicType*) as xs:anyAtomicType*

The intersection of two sequences of values

value-union ($arg1 as xs:anyAtomicType*, $arg2 as xs:anyAtomicType*) as xs:anyAtomicType*

The union of two sequences of values

word-count ($arg as xs:string?) as xs:integer

The number of words

words-to-camel-case ($arg as xs:string?) as xs:string

Turns a string of words into camelCase

wrap-values-in-elements ($values as xs:anyAtomicType*, $elementName as xs:QName) as element(*)*

Wraps a sequence of atomic values in XML elements

yearMonthDuration ($years as xs:decimal?, $months as xs:integer?) as xs:yearMonthDuration

Construct a yearMonthDuration from a number of years and months

Functions

add-attributes#3

declare  function functx:add-attributes($elements as element(*)*, $attrNames as xs:QName*, $attrValues as xs:anyAtomicType*) as element(*)?
Adds attributes to XML elements

Parameters

elements as element(*)
the element(s) to which you wish to add the attribute
attrNames as xs:QName
the name(s) of the attribute(s) to add
attrValues as xs:anyAtomicType
the value(s) of the attribute(s) to add

Returns

element(*)?

add-months#2

declare  function functx:add-months($date as xs:anyAtomicType?, $months as xs:integer) as xs:date?
Adds months to a date

Parameters

date as xs:anyAtomicType
the date
months as xs:integer
the number of months to add

Returns

xs:date?

add-or-update-attributes#3

declare  function functx:add-or-update-attributes($elements as element(*)*, $attrNames as xs:QName*, $attrValues as xs:anyAtomicType*) as element(*)?
Adds attributes to XML elements

Parameters

elements as element(*)
the element(s) to which you wish to add the attribute
attrNames as xs:QName
the name(s) of the attribute(s) to add
attrValues as xs:anyAtomicType
the value(s) of the attribute(s) to add

Returns

element(*)?

all-whitespace#1

declare  function functx:all-whitespace($arg as xs:string?) as xs:boolean
Whether a value is all whitespace or a zero-length string

Parameters

arg as xs:string
the string (or node) to test

Returns

xs:boolean

are-distinct-values#1

declare  function functx:are-distinct-values($seq as xs:anyAtomicType*) as xs:boolean
Whether all the values in a sequence are distinct

Parameters

seq as xs:anyAtomicType
the sequence of values

Returns

xs:boolean

atomic-type#1

declare  function functx:atomic-type($values as xs:anyAtomicType*) as xs:string*
The built-in type of an atomic value

Parameters

values as xs:anyAtomicType
the value(s) whose type you want to determine

Returns

xs:string*

avg-empty-is-zero#2

declare  function functx:avg-empty-is-zero($values as xs:anyAtomicType*, $allNodes as node()*) as xs:double
The average, counting "empty" values as zero

Parameters

values as xs:anyAtomicType
the values to be averaged
allNodes as node()
the sequence of all nodes to find the average over

Returns

xs:double

between-exclusive#3

declare  function functx:between-exclusive($value as xs:anyAtomicType?, $minValue as xs:anyAtomicType, $maxValue as xs:anyAtomicType) as xs:boolean
Whether a value is between two provided values

Parameters

value as xs:anyAtomicType
the value to be tested
minValue as xs:anyAtomicType
the minimum value
maxValue as xs:anyAtomicType
the maximum value

Returns

xs:boolean

between-inclusive#3

declare  function functx:between-inclusive($value as xs:anyAtomicType?, $minValue as xs:anyAtomicType, $maxValue as xs:anyAtomicType) as xs:boolean
Whether a value is between two provided values, or equal to one of them

Parameters

value as xs:anyAtomicType
the value to be tested
minValue as xs:anyAtomicType
the minimum value
maxValue as xs:anyAtomicType
the maximum value

Returns

xs:boolean

camel-case-to-words#2

declare  function functx:camel-case-to-words($arg as xs:string?, $delim as xs:string) as xs:string
Turns a camelCase string into space-separated words

Parameters

arg as xs:string
the string to modify
delim as xs:string
the delimiter for the words (e.g. a space)

Returns

xs:string

capitalize-first#1

declare  function functx:capitalize-first($arg as xs:string?) as xs:string?
Capitalizes the first character of a string

Parameters

arg as xs:string
the word or phrase to capitalize

Returns

xs:string?

change-element-names-deep#3

declare  function functx:change-element-names-deep($nodes as node()*, $oldNames as xs:QName*, $newNames as xs:QName*) as node()*
Changes the names of elements in an XML fragment

Parameters

nodes as node()
the element(s) to change
oldNames as xs:QName
the sequence of names to change from
newNames as xs:QName
the sequence of names to change to

Returns

node()*

change-element-ns-deep#3

declare  function functx:change-element-ns-deep($nodes as node()*, $newns as xs:string, $prefix as xs:string) as node()*
Changes the namespace of XML elements and its descendants

Parameters

nodes as node()
the nodes to change
newns as xs:string
the new namespace
prefix as xs:string
the prefix to use for the new namespace

Returns

node()*

change-element-ns#3

declare  function functx:change-element-ns($elements as element(*)*, $newns as xs:string, $prefix as xs:string) as element(*)?
Changes the namespace of XML elements

Parameters

elements as element(*)
the elements to change
newns as xs:string
the new namespace
prefix as xs:string
the prefix to use for the new namespace

Returns

element(*)?

chars#1

declare  function functx:chars($arg as xs:string?) as xs:string*
Converts a string to a sequence of characters

Parameters

arg as xs:string
the string to split

Returns

xs:string*

contains-any-of#2

declare  function functx:contains-any-of($arg as xs:string?, $searchStrings as xs:string*) as xs:boolean
Whether a string contains any of a sequence of strings

Parameters

arg as xs:string
the string to test
searchStrings as xs:string
the strings to look for

Returns

xs:boolean

contains-case-insensitive#2

declare  function functx:contains-case-insensitive($arg as xs:string?, $substring as xs:string) as xs:boolean?
Whether one string contains another, without regard to case

Parameters

arg as xs:string
the string to search
substring as xs:string
the substring to find

Returns

xs:boolean?

contains-word#2

declare  function functx:contains-word($arg as xs:string?, $word as xs:string) as xs:boolean
Whether one string contains another, as a separate word

Parameters

arg as xs:string
the string to search
word as xs:string
the word to find

Returns

xs:boolean

copy-attributes#2

declare  function functx:copy-attributes($copyTo as element(*), $copyFrom as element(*)) as element(*)
Copies attributes from one element to another

Parameters

copyTo as element(*)
the element to copy attributes to
copyFrom as element(*)
the element to copy attributes from

Returns

element(*)

date#3

declare  function functx:date($year as xs:anyAtomicType, $month as xs:anyAtomicType, $day as xs:anyAtomicType) as xs:date
Construct a date from a year, month and day

Parameters

year as xs:anyAtomicType
the year
month as xs:anyAtomicType
the month
day as xs:anyAtomicType
the day

Returns

xs:date

dateTime#6

declare  function functx:dateTime($year as xs:anyAtomicType, $month as xs:anyAtomicType, $day as xs:anyAtomicType, $hour as xs:anyAtomicType, $minute as xs:anyAtomicType, $second as xs:anyAtomicType) as xs:dateTime
Construct a date/time from individual components

Parameters

year as xs:anyAtomicType
the year
month as xs:anyAtomicType
the month
day as xs:anyAtomicType
the day
hour as xs:anyAtomicType
the hour
minute as xs:anyAtomicType
the minute
second as xs:anyAtomicType
the second

Returns

xs:dateTime

day-in-year#1

declare  function functx:day-in-year($date as xs:anyAtomicType?) as xs:integer?
The day of the year (a number between 1 and 366)

Parameters

date as xs:anyAtomicType
the date

Returns

xs:integer?

day-of-week-abbrev-en#1

declare  function functx:day-of-week-abbrev-en($date as xs:anyAtomicType?) as xs:string?
The abbreviated day of the week, from a date, in English

Parameters

date as xs:anyAtomicType
the date

Returns

xs:string?

day-of-week-name-en#1

declare  function functx:day-of-week-name-en($date as xs:anyAtomicType?) as xs:string?
The name of the day of the week, from a date, in English

Parameters

date as xs:anyAtomicType
the date

Returns

xs:string?

day-of-week#1

declare  function functx:day-of-week($date as xs:anyAtomicType?) as xs:integer?
The day of the week, from a date

Parameters

date as xs:anyAtomicType
the date

Returns

xs:integer?

dayTimeDuration#4

declare  function functx:dayTimeDuration($days as xs:decimal?, $hours as xs:decimal?, $minutes as xs:decimal?, $seconds as xs:decimal?) as xs:dayTimeDuration
Construct a dayTimeDuration from a number of days, hours, etc.

Parameters

days as xs:decimal
the number of days
hours as xs:decimal
the number of hours
minutes as xs:decimal
the number of minutes
seconds as xs:decimal
the number of seconds

Returns

xs:dayTimeDuration

days-in-month#1

declare  function functx:days-in-month($date as xs:anyAtomicType?) as xs:integer?
Number of days in the month

Parameters

date as xs:anyAtomicType
the date

Returns

xs:integer?

depth-of-node#1

declare  function functx:depth-of-node($node as node()?) as xs:integer
The depth (level) of a node in an XML tree

Parameters

node as node()
the node to check

Returns

xs:integer

distinct-attribute-names#1

declare  function functx:distinct-attribute-names($nodes as node()*) as xs:string*
The distinct names of all attributes in an XML fragment

Parameters

nodes as node()
the root to start from

Returns

xs:string*

distinct-deep#1

declare  function functx:distinct-deep($nodes as node()*) as node()*
The XML nodes with distinct values, taking into account attributes and descendants

Parameters

nodes as node()
the sequence of nodes to test

Returns

node()*

distinct-element-names#1

declare  function functx:distinct-element-names($nodes as node()*) as xs:string*
The distinct names of all elements in an XML fragment

Parameters

nodes as node()
the root(s) to start from

Returns

xs:string*

distinct-element-paths#1

declare  function functx:distinct-element-paths($nodes as node()*) as xs:string*
The distinct paths of all descendant elements in an XML fragment

Parameters

nodes as node()
the root(s) to start from

Returns

xs:string*

distinct-nodes#1

declare  function functx:distinct-nodes($nodes as node()*) as node()*
The distinct XML nodes in a sequence (by node identity)

Parameters

nodes as node()
the node sequence

Returns

node()*

duration-from-timezone#1

declare  function functx:duration-from-timezone($timezone as xs:string) as xs:dayTimeDuration
Converts a timezone like "-05:00" or "Z" into xs:dayTimeDuration

Parameters

timezone as xs:string
the time zone, in (+|-)HH:MM format

Returns

xs:dayTimeDuration

dynamic-path#2

declare  function functx:dynamic-path($parent as node(), $path as xs:string) as item()*
Dynamically evaluates a simple XPath path

Parameters

parent as node()
the root to start from
path as xs:string
the path expression

Returns

item()*

escape-for-regex#1

declare  function functx:escape-for-regex($arg as xs:string?) as xs:string
Escapes regex special characters

Parameters

arg as xs:string
the string to escape

Returns

xs:string

exclusive-or#2

declare  function functx:exclusive-or($arg1 as xs:boolean?, $arg2 as xs:boolean?) as xs:boolean?
Whether one (and only one) of two boolean values is true

Parameters

arg1 as xs:boolean
the first boolean value
arg2 as xs:boolean
the second boolean value

Returns

xs:boolean?

first-day-of-month#1

declare  function functx:first-day-of-month($date as xs:anyAtomicType?) as xs:date?
The first day of the month of a date

Parameters

date as xs:anyAtomicType
the date

Returns

xs:date?

first-day-of-year#1

declare  function functx:first-day-of-year($date as xs:anyAtomicType?) as xs:date?
The first day of the year of a date

Parameters

date as xs:anyAtomicType
the date

Returns

xs:date?

first-node#1

declare  function functx:first-node($nodes as node()*) as node()?
The XML node in a sequence that appears first in document order

Parameters

nodes as node()
the sequence of nodes

Returns

node()?

follows-not-descendant#2

declare  function functx:follows-not-descendant($a as node()?, $b as node()?) as xs:boolean
Whether an XML node follows another without being its descendant

Parameters

a as node()
the first node
b as node()
the second node

Returns

xs:boolean

format-as-title-en#1

declare  function functx:format-as-title-en($titles as xs:string*) as xs:string*
Moves title words like "the" and "a" to the end of strings

Parameters

titles as xs:string
the titles to format

Returns

xs:string*

fragment-from-uri#1

declare  function functx:fragment-from-uri($uri as xs:string?) as xs:string?
Returns the fragment from a URI

Parameters

uri as xs:string
the URI

Returns

xs:string?

get-matches-and-non-matches#2

declare  function functx:get-matches-and-non-matches($string as xs:string?, $regex as xs:string) as element(*)*
Splits a string into matching and non-matching regions

Parameters

string as xs:string
the string to split
regex as xs:string
the pattern

Returns

element(*)*

get-matches#2

declare  function functx:get-matches($string as xs:string?, $regex as xs:string) as xs:string*
Return the matching regions of a string

Parameters

string as xs:string
the string to split
regex as xs:string
the pattern

Returns

xs:string*

has-element-only-content#1

declare  function functx:has-element-only-content($element as element(*)) as xs:boolean
Whether an element has element-only content

Parameters

element as element(*)
the XML element to test

Returns

xs:boolean

has-empty-content#1

declare  function functx:has-empty-content($element as element(*)) as xs:boolean
Whether an element has empty content

Parameters

element as element(*)
the XML element to test

Returns

xs:boolean

has-mixed-content#1

declare  function functx:has-mixed-content($element as element(*)) as xs:boolean
Whether an element has mixed content

Parameters

element as element(*)
the XML element to test

Returns

xs:boolean

has-simple-content#1

declare  function functx:has-simple-content($element as element(*)) as xs:boolean
Whether an element has simple content

Parameters

element as element(*)
the XML element to test

Returns

xs:boolean

id-from-element#1

declare  function functx:id-from-element($element as element(*)?) as xs:string?
Gets the ID of an XML element

Parameters

element as element(*)
the element

Returns

xs:string?

id-untyped#2

declare  function functx:id-untyped($node as node()*, $id as xs:anyAtomicType) as element(*)*
Gets XML element(s) that have an attribute with a particular value

Parameters

node as node()
the root node(s) to start from
id as xs:anyAtomicType
the "id" to find

Returns

element(*)*

if-absent#2

declare  function functx:if-absent($arg as item()*, $value as item()*) as item()*
The first argument if it is not empty, otherwise the second argument

Parameters

arg as item()
the item(s) that may be absent
value as item()
the item(s) to use if the item is absent

Returns

item()*

if-empty#2

declare  function functx:if-empty($arg as item()?, $value as item()*) as item()*
The first argument if it is not blank, otherwise the second argument

Parameters

arg as item()
the node that may be empty
value as item()
the item(s) to use if the node is empty

Returns

item()*

index-of-deep-equal-node#2

declare  function functx:index-of-deep-equal-node($nodes as node()*, $nodeToFind as node()) as xs:integer*
The position of a node in a sequence, based on contents and attributes

Parameters

nodes as node()
the node sequence
nodeToFind as node()
the node to find in the sequence

Returns

xs:integer*

index-of-match-first#2

declare  function functx:index-of-match-first($arg as xs:string?, $pattern as xs:string) as xs:integer?
The first position of a matching substring

Parameters

arg as xs:string
the string
pattern as xs:string
the pattern to match

Returns

xs:integer?

index-of-node#2

declare  function functx:index-of-node($nodes as node()*, $nodeToFind as node()) as xs:integer*
The position of a node in a sequence, based on node identity

Parameters

nodes as node()
the node sequence
nodeToFind as node()
the node to find in the sequence

Returns

xs:integer*

index-of-string-first#2

declare  function functx:index-of-string-first($arg as xs:string?, $substring as xs:string) as xs:integer?
The first position of a substring

Parameters

arg as xs:string
the string
substring as xs:string
the substring to find

Returns

xs:integer?

index-of-string-last#2

declare  function functx:index-of-string-last($arg as xs:string?, $substring as xs:string) as xs:integer?
The last position of a substring

Parameters

arg as xs:string
the string
substring as xs:string
the substring to find

Returns

xs:integer?

index-of-string#2

declare  function functx:index-of-string($arg as xs:string?, $substring as xs:string) as xs:integer*
The position(s) of a substring

Parameters

arg as xs:string
the string
substring as xs:string
the substring to find

Returns

xs:integer*

insert-string#3

declare  function functx:insert-string($originalString as xs:string?, $stringToInsert as xs:string?, $pos as xs:integer) as xs:string
Inserts a string at a specified position

Parameters

originalString as xs:string
the original string to insert into
stringToInsert as xs:string
the string to insert
pos as xs:integer
the position

Returns

xs:string

is-a-number#1

declare  function functx:is-a-number($value as xs:anyAtomicType?) as xs:boolean
Whether a value is numeric

Parameters

value as xs:anyAtomicType
the value to test

Returns

xs:boolean

is-absolute-uri#1

declare  function functx:is-absolute-uri($uri as xs:string?) as xs:boolean
Whether a URI is absolute

Parameters

uri as xs:string
the URI to test

Returns

xs:boolean

is-ancestor#2

declare  function functx:is-ancestor($node1 as node(), $node2 as node()) as xs:boolean
Whether an XML node is an ancestor of another node

Parameters

node1 as node()
the first node
node2 as node()
the second node

Returns

xs:boolean

is-descendant#2

declare  function functx:is-descendant($node1 as node(), $node2 as node()) as xs:boolean
Whether an XML node is a descendant of another node

Parameters

node1 as node()
the first node
node2 as node()
the second node

Returns

xs:boolean

is-leap-year#1

declare  function functx:is-leap-year($date as xs:anyAtomicType?) as xs:boolean
Whether a date falls in a leap year

Parameters

date as xs:anyAtomicType
the date or year

Returns

xs:boolean

is-node-among-descendants-deep-equal#2

declare  function functx:is-node-among-descendants-deep-equal($node as node()?, $seq as node()*) as xs:boolean
Whether an XML node is among the descendants of a sequence, based on contents and attributes

Parameters

node as node()
the node to test
seq as node()
the sequence of nodes to search

Returns

xs:boolean

is-node-among-descendants#2

declare  function functx:is-node-among-descendants($node as node()?, $seq as node()*) as xs:boolean
Whether an XML node is among the descendants of a sequence, based on node identity

Parameters

node as node()
the node to test
seq as node()
the sequence of nodes to search

Returns

xs:boolean

is-node-in-sequence-deep-equal#2

declare  function functx:is-node-in-sequence-deep-equal($node as node()?, $seq as node()*) as xs:boolean
Whether an XML node is in a sequence, based on contents and attributes

Parameters

node as node()
the node to test
seq as node()
the sequence of nodes to search

Returns

xs:boolean

is-node-in-sequence#2

declare  function functx:is-node-in-sequence($node as node()?, $seq as node()*) as xs:boolean
Whether an XML node is in a sequence, based on node identity

Parameters

node as node()
the node to test
seq as node()
the sequence of nodes to search

Returns

xs:boolean

is-value-in-sequence#2

declare  function functx:is-value-in-sequence($value as xs:anyAtomicType?, $seq as xs:anyAtomicType*) as xs:boolean
Whether an atomic value appears in a sequence

Parameters

value as xs:anyAtomicType
the atomic value to test
seq as xs:anyAtomicType
the sequence of values to search

Returns

xs:boolean

last-day-of-month#1

declare  function functx:last-day-of-month($date as xs:anyAtomicType?) as xs:date?
The last day of the month of a date

Parameters

date as xs:anyAtomicType
the date

Returns

xs:date?

last-day-of-year#1

declare  function functx:last-day-of-year($date as xs:anyAtomicType?) as xs:date?
The last day of the month of a date

Parameters

date as xs:anyAtomicType
the date

Returns

xs:date?

last-node#1

declare  function functx:last-node($nodes as node()*) as node()?
The XML node in a sequence that is last in document order

Parameters

nodes as node()
the sequence of nodes

Returns

node()?

leaf-elements#1

declare  function functx:leaf-elements($root as node()?) as element(*)*
All XML elements that don't have any child elements

Parameters

root as node()
the root

Returns

element(*)*

left-trim#1

declare  function functx:left-trim($arg as xs:string?) as xs:string
Trims leading whitespace

Parameters

arg as xs:string
the string to trim

Returns

xs:string

line-count#1

declare  function functx:line-count($arg as xs:string?) as xs:integer
The number of lines

Parameters

arg as xs:string
the string to test

Returns

xs:integer

lines#1

declare  function functx:lines($arg as xs:string?) as xs:string*
Split a string into separate lines

Parameters

arg as xs:string
the string to split

Returns

xs:string*

max-depth#1

declare  function functx:max-depth($root as node()?) as xs:integer?
The maximum depth of elements in an XML tree

Parameters

root as node()
the root to start from

Returns

xs:integer?

max-determine-type#1

declare  function functx:max-determine-type($seq as xs:anyAtomicType*) as xs:anyAtomicType?
The maximum value in a sequence, figuring out its type (numeric or string)

Parameters

seq as xs:anyAtomicType
the sequence of values to test

Returns

xs:anyAtomicType?

max-line-length#1

declare  function functx:max-line-length($arg as xs:string?) as xs:integer
The maximum line length

Parameters

arg as xs:string
the string to test

Returns

xs:integer

max-node#1

declare  function functx:max-node($nodes as node()*) as node()*
The XML node whose typed value is the maximum

Parameters

nodes as node()
the sequence of nodes to test

Returns

node()*

max-string#1

declare  function functx:max-string($strings as xs:anyAtomicType*) as xs:string?
The maximum of a sequence of values, treating them like strings

Parameters

strings as xs:anyAtomicType
the sequence of values

Returns

xs:string?

min-determine-type#1

declare  function functx:min-determine-type($seq as xs:anyAtomicType*) as xs:anyAtomicType?
The minimum value in a sequence, figuring out its type (numeric or string)

Parameters

seq as xs:anyAtomicType
the sequence of values to test

Returns

xs:anyAtomicType?

min-node#1

declare  function functx:min-node($nodes as node()*) as node()*
The XML node whose typed value is the minimum

Parameters

nodes as node()
the sequence of nodes to test

Returns

node()*

min-non-empty-string#1

declare  function functx:min-non-empty-string($strings as xs:string*) as xs:string?
The minimum of a sequence of strings, ignoring "empty" values

Parameters

strings as xs:string
the sequence of strings to search

Returns

xs:string?

min-string#1

declare  function functx:min-string($strings as xs:anyAtomicType*) as xs:string?
The minimum of a sequence of values, treating them like strings

Parameters

strings as xs:anyAtomicType
the sequence of strings

Returns

xs:string?

mmddyyyy-to-date#1

declare  function functx:mmddyyyy-to-date($dateString as xs:string?) as xs:date?
Converts a string with format MMDDYYYY (with any delimiters) to a date

Parameters

dateString as xs:string
the MMDDYYYY string

Returns

xs:date?

month-abbrev-en#1

declare  function functx:month-abbrev-en($date as xs:anyAtomicType?) as xs:string?
The month of a date as an abbreviated word (Jan, Feb, etc.)

Parameters

date as xs:anyAtomicType
the date

Returns

xs:string?

month-name-en#1

declare  function functx:month-name-en($date as xs:anyAtomicType?) as xs:string?
The month of a date as a word (January, February, etc.)

Parameters

date as xs:anyAtomicType
the date

Returns

xs:string?

name-test#2

declare  function functx:name-test($testname as xs:string?, $names as xs:string*) as xs:boolean
Whether a name matches a list of names or name wildcards

Parameters

testname as xs:string
the name to test
names as xs:string
the list of names or name wildcards

Returns

xs:boolean

namespaces-in-use#1

declare  function functx:namespaces-in-use($root as node()?) as xs:anyURI*
A list of namespaces used in element/attribute names in an XML fragment

Parameters

root as node()
the root node to start from

Returns

xs:anyURI*

next-day#1

declare  function functx:next-day($date as xs:anyAtomicType?) as xs:date?
The next day

Parameters

date as xs:anyAtomicType
the date

Returns

xs:date?

node-kind#1

declare  function functx:node-kind($nodes as node()*) as xs:string*
The XML node kind (element, attribute, text, etc.)

Parameters

nodes as node()
the node(s) whose kind you want to determine

Returns

xs:string*

non-distinct-values#1

declare  function functx:non-distinct-values($seq as xs:anyAtomicType*) as xs:anyAtomicType*
Returns any values that appear more than once in a sequence

Parameters

seq as xs:anyAtomicType
the sequence of values

Returns

xs:anyAtomicType*

number-of-matches#2

declare  function functx:number-of-matches($arg as xs:string?, $pattern as xs:string) as xs:integer
The number of regions that match a pattern

Parameters

arg as xs:string
the string to test
pattern as xs:string
the regular expression

Returns

xs:integer

open-ref-document#1

declare  function functx:open-ref-document($refNode as node()) as document()
Resolves a relative URI and references it, returning an XML document

Parameters

refNode as node()
a node whose value is a relative URI reference

Returns

document()

ordinal-number-en#1

declare  function functx:ordinal-number-en($num as xs:integer?) as xs:string
Reformats a number as an ordinal number, e.g. 1st, 2nd, 3rd.

Parameters

num as xs:integer
the number

Returns

xs:string

pad-integer-to-length#2

declare  function functx:pad-integer-to-length($integerToPad as xs:anyAtomicType?, $length as xs:integer) as xs:string
Pads an integer to a desired length by adding leading zeros

Parameters

integerToPad as xs:anyAtomicType
the integer to pad
length as xs:integer
the desired length

Returns

xs:string

pad-string-to-length#3

declare  function functx:pad-string-to-length($stringToPad as xs:string?, $padChar as xs:string, $length as xs:integer) as xs:string
Pads a string to a desired length

Parameters

stringToPad as xs:string
the string to pad
padChar as xs:string
the character(s) to use as padding
length as xs:integer
the desired length

Returns

xs:string

path-to-node-with-pos#1

declare  function functx:path-to-node-with-pos($node as node()?) as xs:string
A unique path to an XML node (or sequence of nodes)

Parameters

node as node()
the node sequence

Returns

xs:string

path-to-node#1

declare  function functx:path-to-node($nodes as node()*) as xs:string*
A path to an XML node (or sequence of nodes)

Parameters

nodes as node()
the node sequence

Returns

xs:string*

precedes-not-ancestor#2

declare  function functx:precedes-not-ancestor($a as node()?, $b as node()?) as xs:boolean
Whether an XML node precedes another without being its ancestor

Parameters

a as node()
the first node
b as node()
the second node

Returns

xs:boolean

previous-day#1

declare  function functx:previous-day($date as xs:anyAtomicType?) as xs:date?
The previous day

Parameters

date as xs:anyAtomicType
the date

Returns

xs:date?

remove-attributes-deep#2

declare  function functx:remove-attributes-deep($nodes as node()*, $names as xs:string*) as node()*
Removes attributes from an XML fragment, based on name

Parameters

nodes as node()
the root(s) to start from
names as xs:string
the names of the attributes to remove, or * for all attributes

Returns

node()*

remove-attributes#2

declare  function functx:remove-attributes($elements as element(*)*, $names as xs:string*) as element(*)
Removes attributes from an XML element, based on name

Parameters

elements as element(*)
the element(s) from which to remove the attributes
names as xs:string
the names of the attributes to remove, or * for all attributes

Returns

element(*)

remove-elements-deep#2

declare  function functx:remove-elements-deep($nodes as node()*, $names as xs:string*) as node()*
Removes descendant elements from an XML node, based on name

Parameters

nodes as node()
root(s) to start from
names as xs:string
the names of the elements to remove

Returns

node()*

remove-elements-not-contents#2

declare  function functx:remove-elements-not-contents($nodes as node()*, $names as xs:string*) as node()*
Removes descendant XML elements but keeps their content

Parameters

nodes as node()
the root(s) to start from
names as xs:string
the names of the elements to remove

Returns

node()*

remove-elements#2

declare  function functx:remove-elements($elements as element(*)*, $names as xs:string*) as element(*)*
Removes child elements from an XML node, based on name

Parameters

elements as element(*)
the element(s) from which you wish to remove the children
names as xs:string
the names of the child elements to remove

Returns

element(*)*

repeat-string#2

declare  function functx:repeat-string($stringToRepeat as xs:string?, $count as xs:integer) as xs:string
Repeats a string a given number of times

Parameters

stringToRepeat as xs:string
the string to repeat
count as xs:integer
the desired number of copies

Returns

xs:string

replace-beginning#3

declare  function functx:replace-beginning($arg as xs:string?, $pattern as xs:string, $replacement as xs:string) as xs:string
Replaces the beginning of a string, up to a matched pattern

Parameters

arg as xs:string
the entire string to change
pattern as xs:string
the pattern of characters to replace up to
replacement as xs:string
the replacement string

Returns

xs:string

replace-element-values#2

declare  function functx:replace-element-values($elements as element(*)*, $values as xs:anyAtomicType*) as element(*)*
Updates the content of one or more elements

Parameters

elements as element(*)
the elements whose content you wish to replace
values as xs:anyAtomicType
the replacement values

Returns

element(*)*

replace-first#3

declare  function functx:replace-first($arg as xs:string?, $pattern as xs:string, $replacement as xs:string) as xs:string
Replaces the first match of a pattern

Parameters

arg as xs:string
the entire string to change
pattern as xs:string
the pattern of characters to replace
replacement as xs:string
the replacement string

Returns

xs:string

replace-multi#3

declare  function functx:replace-multi($arg as xs:string?, $changeFrom as xs:string*, $changeTo as xs:string*) as xs:string?
Performs multiple replacements, using pairs of replace parameters

Parameters

arg as xs:string
the string to manipulate
changeFrom as xs:string
the sequence of strings or patterns to change from
changeTo as xs:string
the sequence of strings to change to

Returns

xs:string?

reverse-string#1

declare  function functx:reverse-string($arg as xs:string?) as xs:string
Reverses the order of characters

Parameters

arg as xs:string
the string to reverse

Returns

xs:string

right-trim#1

declare  function functx:right-trim($arg as xs:string?) as xs:string
Trims trailing whitespace

Parameters

arg as xs:string
the string to trim

Returns

xs:string

scheme-from-uri#1

declare  function functx:scheme-from-uri($uri as xs:string?) as xs:string?
Returns the scheme from a URI

Parameters

uri as xs:string
the URI

Returns

xs:string?

sequence-deep-equal#2

declare  function functx:sequence-deep-equal($seq1 as item()*, $seq2 as item()*) as xs:boolean
Whether two sequences have the same XML node content and/or values

Parameters

seq1 as item()
the first sequence
seq2 as item()
the second sequence

Returns

xs:boolean

sequence-node-equal-any-order#2

declare  function functx:sequence-node-equal-any-order($seq1 as node()*, $seq2 as node()*) as xs:boolean
Whether two sequences contain the same XML nodes, regardless of order

Parameters

seq1 as node()
the first sequence of nodes
seq2 as node()
the second sequence of nodes

Returns

xs:boolean

sequence-node-equal#2

declare  function functx:sequence-node-equal($seq1 as node()*, $seq2 as node()*) as xs:boolean
Whether two sequences contain the same XML nodes, in the same order

Parameters

seq1 as node()
the first sequence of nodes
seq2 as node()
the second sequence of nodes

Returns

xs:boolean

sequence-type#1

declare  function functx:sequence-type($items as item()*) as xs:string
The sequence type that represents a sequence of nodes or values

Parameters

items as item()
the items whose sequence type you want to determine

Returns

xs:string

siblings-same-name#1

declare  function functx:siblings-same-name($element as element(*)?) as element(*)*
The siblings of an XML element that have the same name

Parameters

element as element(*)
the node

Returns

element(*)*

siblings#1

declare  function functx:siblings($node as node()?) as node()*
The siblings of an XML node

Parameters

node as node()
the node

Returns

node()*

sort-as-numeric#1

declare  function functx:sort-as-numeric($seq as item()*) as item()*
Sorts a sequence of numeric values or nodes

Parameters

seq as item()
the sequence to sort

Returns

item()*

sort-case-insensitive#1

declare  function functx:sort-case-insensitive($seq as item()*) as item()*
Sorts a sequence of values or nodes regardless of capitalization

Parameters

seq as item()
the sequence to sort

Returns

item()*

sort-document-order#1

declare  function functx:sort-document-order($seq as node()*) as node()*
Sorts a sequence of nodes in document order

Parameters

seq as node()
the sequence to sort

Returns

node()*

sort#1

declare  function functx:sort($seq as item()*) as item()*
Sorts a sequence of values or nodes

Parameters

seq as item()
the sequence to sort

Returns

item()*

substring-after-if-contains#2

declare  function functx:substring-after-if-contains($arg as xs:string?, $delim as xs:string) as xs:string?
Performs substring-after, returning the entire string if it does not contain the delimiter

Parameters

arg as xs:string
the string to substring
delim as xs:string
the delimiter

Returns

xs:string?

substring-after-last-match#2

declare  function functx:substring-after-last-match($arg as xs:string?, $regex as xs:string) as xs:string
The substring after the last text that matches a regex

Parameters

arg as xs:string
the string to substring
regex as xs:string
the regular expression

Returns

xs:string

substring-after-last#2

declare  function functx:substring-after-last($arg as xs:string?, $delim as xs:string) as xs:string
The substring after the last occurrence of a delimiter

Parameters

arg as xs:string
the string to substring
delim as xs:string
the delimiter

Returns

xs:string

substring-after-match#2

declare  function functx:substring-after-match($arg as xs:string?, $regex as xs:string) as xs:string?
The substring after the first text that matches a regex

Parameters

arg as xs:string
the string to substring
regex as xs:string
the regular expression

Returns

xs:string?

substring-before-if-contains#2

declare  function functx:substring-before-if-contains($arg as xs:string?, $delim as xs:string) as xs:string?
Performs substring-before, returning the entire string if it does not contain the delimiter

Parameters

arg as xs:string
the string to substring
delim as xs:string
the delimiter

Returns

xs:string?

substring-before-last-match#2

declare  function functx:substring-before-last-match($arg as xs:string?, $regex as xs:string) as xs:string?
The substring after the first text that matches a regex

Parameters

arg as xs:string
the string to substring
regex as xs:string
the regular expression

Returns

xs:string?

substring-before-last#2

declare  function functx:substring-before-last($arg as xs:string?, $delim as xs:string) as xs:string
The substring before the last occurrence of a delimiter

Parameters

arg as xs:string
the string to substring
delim as xs:string
the delimiter

Returns

xs:string

substring-before-match#2

declare  function functx:substring-before-match($arg as xs:string?, $regex as xs:string) as xs:string
The substring before the last text that matches a regex

Parameters

arg as xs:string
the string to substring
regex as xs:string
the regular expression

Returns

xs:string

time#3

declare  function functx:time($hour as xs:anyAtomicType, $minute as xs:anyAtomicType, $second as xs:anyAtomicType) as xs:time
Construct a time from an hour, minute and second

Parameters

hour as xs:anyAtomicType
the hour
minute as xs:anyAtomicType
the minute
second as xs:anyAtomicType
the second

Returns

xs:time

timezone-from-duration#1

declare  function functx:timezone-from-duration($duration as xs:dayTimeDuration) as xs:string
Converts an xs:dayTimeDuration into a timezone like "-05:00" or "Z"

Parameters

duration as xs:dayTimeDuration
the duration

Returns

xs:string

total-days-from-duration#1

declare  function functx:total-days-from-duration($duration as xs:dayTimeDuration?) as xs:decimal?
The total number of days in a dayTimeDuration

Parameters

duration as xs:dayTimeDuration
the duration

Returns

xs:decimal?

total-hours-from-duration#1

declare  function functx:total-hours-from-duration($duration as xs:dayTimeDuration?) as xs:decimal?
The total number of hours in a dayTimeDuration

Parameters

duration as xs:dayTimeDuration
the duration

Returns

xs:decimal?

total-minutes-from-duration#1

declare  function functx:total-minutes-from-duration($duration as xs:dayTimeDuration?) as xs:decimal?
The total number of minutes in a dayTimeDuration

Parameters

duration as xs:dayTimeDuration
the duration

Returns

xs:decimal?

total-months-from-duration#1

declare  function functx:total-months-from-duration($duration as xs:yearMonthDuration?) as xs:decimal?
The total number of months in a yearMonthDuration

Parameters

duration as xs:yearMonthDuration
the duration

Returns

xs:decimal?

total-seconds-from-duration#1

declare  function functx:total-seconds-from-duration($duration as xs:dayTimeDuration?) as xs:decimal?
The total number of seconds in a dayTimeDuration

Parameters

duration as xs:dayTimeDuration
the duration

Returns

xs:decimal?

total-years-from-duration#1

declare  function functx:total-years-from-duration($duration as xs:yearMonthDuration?) as xs:decimal?
The total number of years in a yearMonthDuration

Parameters

duration as xs:yearMonthDuration
the duration

Returns

xs:decimal?

trim#1

declare  function functx:trim($arg as xs:string?) as xs:string
Trims leading and trailing whitespace

Parameters

arg as xs:string
the string to trim

Returns

xs:string

update-attributes#3

declare  function functx:update-attributes($elements as element(*)*, $attrNames as xs:QName*, $attrValues as xs:anyAtomicType*) as element(*)?
Updates the attribute value of an XML element

Parameters

elements as element(*)
the element(s) for which you wish to update the attribute
attrNames as xs:QName
the name(s) of the attribute(s) to add
attrValues as xs:anyAtomicType
the value(s) of the attribute(s) to add

Returns

element(*)?

value-except#2

declare  function functx:value-except($arg1 as xs:anyAtomicType*, $arg2 as xs:anyAtomicType*) as xs:anyAtomicType*
The values in one sequence that aren't in another sequence

Parameters

arg1 as xs:anyAtomicType
the first sequence
arg2 as xs:anyAtomicType
the second sequence

Returns

xs:anyAtomicType*

value-intersect#2

declare  function functx:value-intersect($arg1 as xs:anyAtomicType*, $arg2 as xs:anyAtomicType*) as xs:anyAtomicType*
The intersection of two sequences of values

Parameters

arg1 as xs:anyAtomicType
the first sequence
arg2 as xs:anyAtomicType
the second sequence

Returns

xs:anyAtomicType*

value-union#2

declare  function functx:value-union($arg1 as xs:anyAtomicType*, $arg2 as xs:anyAtomicType*) as xs:anyAtomicType*
The union of two sequences of values

Parameters

arg1 as xs:anyAtomicType
the first sequence
arg2 as xs:anyAtomicType
the second sequence

Returns

xs:anyAtomicType*

word-count#1

declare  function functx:word-count($arg as xs:string?) as xs:integer
The number of words

Parameters

arg as xs:string
the string to measure

Returns

xs:integer

words-to-camel-case#1

declare  function functx:words-to-camel-case($arg as xs:string?) as xs:string
Turns a string of words into camelCase

Parameters

arg as xs:string
the string to modify

Returns

xs:string

wrap-values-in-elements#2

declare  function functx:wrap-values-in-elements($values as xs:anyAtomicType*, $elementName as xs:QName) as element(*)*
Wraps a sequence of atomic values in XML elements

Parameters

values as xs:anyAtomicType
the values to wrap in elements
elementName as xs:QName
the name of the elements to construct

Returns

element(*)*

yearMonthDuration#2

declare  function functx:yearMonthDuration($years as xs:decimal?, $months as xs:integer?) as xs:yearMonthDuration
Construct a yearMonthDuration from a number of years and months

Parameters

years as xs:decimal
the number of years
months as xs:integer
the number of months

Returns

xs:yearMonthDuration