XQuery Function Documentation

Search and Browse

http://www.functx.com

/db/system/repo/functx-1.0.1/functx/functx.xq

-------------------------------- The FunctX XQuery Function Library --------------------------------
Copyright (C) 2019 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

version 1.0.1

functx:add-attributes

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

Adds attributes to XML elements

Parameters:
$elements* the element(s) to which you wish to add the attribute
$attrNames* the name(s) of the attribute(s) to add
$attrValues* the value(s) of the attribute(s) to add
Returns:
element()*

functx:add-months

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

Adds months to a date

Parameters:
$date? the date
$months the number of months to add
Returns:
xs:date?

functx:add-or-update-attributes

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* the element(s) to which you wish to add the attribute
$attrNames* the name(s) of the attribute(s) to add
$attrValues* the value(s) of the attribute(s) to add
Returns:
element()*

functx:all-whitespace

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

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

Parameters:
$arg? the string (or node) to test
Returns:
xs:boolean

functx:are-distinct-values

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

Whether all the values in a sequence are distinct

Parameters:
$seq* the sequence of values
Returns:
xs:boolean

functx:atomic-type

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

The built-in type of an atomic value

Parameters:
$values* the value(s) whose type you want to determine
Returns:
xs:string*

functx:avg-empty-is-zero

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

The average, counting "empty" values as zero

Parameters:
$values* the values to be averaged
$allNodes* the sequence of all nodes to find the average over
Returns:
xs:double

functx:between-exclusive

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? the value to be tested
$minValue the minimum value
$maxValue the maximum value
Returns:
xs:boolean

functx:between-inclusive

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? the value to be tested
$minValue the minimum value
$maxValue the maximum value
Returns:
xs:boolean

functx:camel-case-to-words

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? the string to modify
$delim the delimiter for the words (e.g. a space)
Returns:
xs:string

functx:capitalize-first

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

Capitalizes the first character of a string

Parameters:
$arg? the word or phrase to capitalize
Returns:
xs:string?

functx:change-element-names-deep

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* the element(s) to change
$oldNames* the sequence of names to change from
$newNames* the sequence of names to change to
Returns:
node()*

functx:change-element-ns

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* the elements to change
$newns the new namespace
$prefix the prefix to use for the new namespace
Returns:
element()*

functx:change-element-ns-deep

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* the nodes to change
$newns the new namespace
$prefix the prefix to use for the new namespace
Returns:
node()*

functx:chars

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

Converts a string to a sequence of characters

Parameters:
$arg? the string to split
Returns:
xs:string*

functx:contains-any-of

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? the string to test
$searchStrings* the strings to look for
Returns:
xs:boolean

functx:contains-case-insensitive

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? the string to search
$substring the substring to find
Returns:
xs:boolean

functx:contains-word

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? the string to search
$word the word to find
Returns:
xs:boolean

functx:copy-attributes

functx:copy-attributes($copyTo as element(), $copyFrom as element()) as element()

Copies attributes from one element to another

Parameters:
$copyTo the element to copy attributes to
$copyFrom the element to copy attributes from
Returns:
element()

functx:date

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 the year
$month the month
$day the day
Returns:
xs:date

functx:dateTime

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 the year
$month the month
$day the day
$hour the hour
$minute the minute
$second the second
Returns:
xs:dateTime

functx:day-in-year

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

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

Parameters:
$date? the date
Returns:
xs:integer?

functx:day-of-week

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

The day of the week, from a date

Parameters:
$date? the date
Returns:
xs:integer?

functx:day-of-week-abbrev-en

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? the date
Returns:
xs:string?

functx:day-of-week-name-en

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? the date
Returns:
xs:string?

functx:dayTimeDuration

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? the number of days
$hours? the number of hours
$minutes? the number of minutes
$seconds? the number of seconds
Returns:
xs:dayTimeDuration

functx:days-in-month

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

Number of days in the month

Parameters:
$date? the date
Returns:
xs:integer?

functx:depth-of-node

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

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

Parameters:
$node? the node to check
Returns:
xs:integer

functx:distinct-attribute-names

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

The distinct names of all attributes in an XML fragment

Parameters:
$nodes* the root to start from
Returns:
xs:string*

functx:distinct-deep

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

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

Parameters:
$nodes* the sequence of nodes to test
Returns:
node()*

functx:distinct-element-names

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

The distinct names of all elements in an XML fragment

Parameters:
$nodes* the root(s) to start from
Returns:
xs:string*

functx:distinct-element-paths

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

The distinct paths of all descendant elements in an XML fragment

Parameters:
$nodes* the root(s) to start from
Returns:
xs:string*

functx:distinct-nodes

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

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

Parameters:
$nodes* the node sequence
Returns:
node()*

functx:duration-from-timezone

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

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

Parameters:
$timezone the time zone, in (+|-)HH:MM format
Returns:
xs:dayTimeDuration

functx:dynamic-path

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

Dynamically evaluates a simple XPath path

Parameters:
$parent the root to start from
$path the path expression
Returns:
item()*

functx:escape-for-regex

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

Escapes regex special characters

Parameters:
$arg? the string to escape
Returns:
xs:string

functx:exclusive-or

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? the first boolean value
$arg2? the second boolean value
Returns:
xs:boolean?

functx:first-day-of-month

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

The first day of the month of a date

Parameters:
$date? the date
Returns:
xs:date?

functx:first-day-of-year

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

The first day of the year of a date

Parameters:
$date? the date
Returns:
xs:date?

functx:first-node

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

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

Parameters:
$nodes* the sequence of nodes
Returns:
node()?

functx:follows-not-descendant

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? the first node
$b? the second node
Returns:
xs:boolean

functx:format-as-title-en

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* the titles to format
Returns:
xs:string*

functx:fragment-from-uri

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

Returns the fragment from a URI

Parameters:
$uri? the URI
Returns:
xs:string?

functx:get-matches

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

Return the matching regions of a string

Parameters:
$string? the string to split
$regex the pattern
Returns:
xs:string*

functx:get-matches-and-non-matches

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? the string to split
$regex the pattern
Returns:
element()*

functx:has-element-only-content

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

Whether an element has element-only content

Parameters:
$element the XML element to test
Returns:
xs:boolean

functx:has-empty-content

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

Whether an element has empty content

Parameters:
$element the XML element to test
Returns:
xs:boolean

functx:has-mixed-content

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

Whether an element has mixed content

Parameters:
$element the XML element to test
Returns:
xs:boolean

functx:has-simple-content

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

Whether an element has simple content

Parameters:
$element the XML element to test
Returns:
xs:boolean

functx:id-from-element

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

Gets the ID of an XML element

Parameters:
$element? the element
Returns:
xs:string?

functx:id-untyped

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* the root node(s) to start from
$id the "id" to find
Returns:
element()*

functx:if-absent

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* the item(s) that may be absent
$value* the item(s) to use if the item is absent
Returns:
item()*

functx:if-empty

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? the node that may be empty
$value* the item(s) to use if the node is empty
Returns:
item()*

functx:index-of-deep-equal-node

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* the node sequence
$nodeToFind the node to find in the sequence
Returns:
xs:integer*

functx:index-of-match-first

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? the string
$pattern the pattern to match
Returns:
xs:integer?

functx:index-of-node

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* the node sequence
$nodeToFind the node to find in the sequence
Returns:
xs:integer*

functx:index-of-string

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

The position(s) of a substring

Parameters:
$arg? the string
$substring the substring to find
Returns:
xs:integer*

functx:index-of-string-first

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

The first position of a substring

Parameters:
$arg? the string
$substring the substring to find
Returns:
xs:integer?

functx:index-of-string-last

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

The last position of a substring

Parameters:
$arg? the string
$substring the substring to find
Returns:
xs:integer?

functx:insert-string

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? the original string to insert into
$stringToInsert? the string to insert
$pos the position
Returns:
xs:string

functx:is-a-number

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

Whether a value is numeric

Parameters:
$value? the value to test
Returns:
xs:boolean

functx:is-absolute-uri

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

Whether a URI is absolute

Parameters:
$uri? the URI to test
Returns:
xs:boolean

functx:is-ancestor

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

Whether an XML node is an ancestor of another node

Parameters:
$node1 the first node
$node2 the second node
Returns:
xs:boolean

functx:is-descendant

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

Whether an XML node is a descendant of another node

Parameters:
$node1 the first node
$node2 the second node
Returns:
xs:boolean

functx:is-leap-year

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

Whether a date falls in a leap year

Parameters:
$date? the date or year
Returns:
xs:boolean

functx:is-node-among-descendants

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? the node to test
$seq* the sequence of nodes to search
Returns:
xs:boolean

functx:is-node-among-descendants-deep-equal

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? the node to test
$seq* the sequence of nodes to search
Returns:
xs:boolean

functx:is-node-in-sequence

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? the node to test
$seq* the sequence of nodes to search
Returns:
xs:boolean

functx:is-node-in-sequence-deep-equal

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? the node to test
$seq* the sequence of nodes to search
Returns:
xs:boolean

functx:is-value-in-sequence

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? the atomic value to test
$seq* the sequence of values to search
Returns:
xs:boolean

functx:last-day-of-month

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

The last day of the month of a date

Parameters:
$date? the date
Returns:
xs:date?

functx:last-day-of-year

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

The last day of the month of a date

Parameters:
$date? the date
Returns:
xs:date?

functx:last-node

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

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

Parameters:
$nodes* the sequence of nodes
Returns:
node()?

functx:leaf-elements

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

All XML elements that don't have any child elements

Parameters:
$root? the root
Returns:
element()*

functx:left-trim

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

Trims leading whitespace

Parameters:
$arg? the string to trim
Returns:
xs:string

functx:line-count

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

The number of lines

Parameters:
$arg? the string to test
Returns:
xs:integer

functx:lines

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

Split a string into separate lines

Parameters:
$arg? the string to split
Returns:
xs:string*

functx:max-depth

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

The maximum depth of elements in an XML tree

Parameters:
$root? the root to start from
Returns:
xs:integer?

functx:max-determine-type

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* the sequence of values to test
Returns:
xs:anyAtomicType?

functx:max-line-length

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

The maximum line length

Parameters:
$arg? the string to test
Returns:
xs:integer?

functx:max-node

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

The XML node whose typed value is the maximum

Parameters:
$nodes* the sequence of nodes to test
Returns:
node()*

functx:max-string

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

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

Parameters:
$strings* the sequence of values
Returns:
xs:string?

functx:min-determine-type

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* the sequence of values to test
Returns:
xs:anyAtomicType?

functx:min-node

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

The XML node whose typed value is the minimum

Parameters:
$nodes* the sequence of nodes to test
Returns:
node()*

functx:min-non-empty-string

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

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

Parameters:
$strings* the sequence of strings to search
Returns:
xs:string?

functx:min-string

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

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

Parameters:
$strings* the sequence of strings
Returns:
xs:string?

functx:mmddyyyy-to-date

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? the MMDDYYYY string
Returns:
xs:date?

functx:month-abbrev-en

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? the date
Returns:
xs:string?

functx:month-name-en

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

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

Parameters:
$date? the date
Returns:
xs:string?

functx:name-test

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? the name to test
$names* the list of names or name wildcards
Returns:
xs:boolean

functx:namespaces-in-use

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? the root node to start from
Returns:
xs:anyURI*

functx:next-day

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

The next day

Parameters:
$date? the date
Returns:
xs:date?

functx:node-kind

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

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

Parameters:
$nodes* the node(s) whose kind you want to determine
Returns:
xs:string*

functx:non-distinct-values

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

Returns any values that appear more than once in a sequence

Parameters:
$seq* the sequence of values
Returns:
xs:anyAtomicType*

functx:number-of-matches

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? the string to test
$pattern the regular expression
Returns:
xs:integer

functx:open-ref-document

functx:open-ref-document($refNode as node()) as document-node()?

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

Parameters:
$refNode a node whose value is a relative URI reference
Returns:
document-node()?

functx:ordinal-number-en

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? the number
Returns:
xs:string

functx:pad-integer-to-length

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? the integer to pad
$length the desired length
Returns:
xs:string

functx:pad-string-to-length

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? the string to pad
$padChar the character(s) to use as padding
$length the desired length
Returns:
xs:string

functx:path-to-node

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

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

Parameters:
$nodes* the node sequence
Returns:
xs:string*

functx:path-to-node-with-pos

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? the node sequence
Returns:
xs:string

functx:precedes-not-ancestor

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? the first node
$b? the second node
Returns:
xs:boolean

functx:previous-day

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

The previous day

Parameters:
$date? the date
Returns:
xs:date?

functx:remove-attributes

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

Removes attributes from an XML element, based on name

Parameters:
$elements* the element(s) from which to remove the attributes
$names* the names of the attributes to remove, or * for all attributes
Returns:
element()*

functx:remove-attributes-deep

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

Removes attributes from an XML fragment, based on name

Parameters:
$nodes* the root(s) to start from
$names* the names of the attributes to remove, or * for all attributes
Returns:
node()*

functx:remove-elements

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

Removes child elements from an XML node, based on name

Parameters:
$elements* the element(s) from which you wish to remove the children
$names* the names of the child elements to remove
Returns:
element()*

functx:remove-elements-deep

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* root(s) to start from
$names* the names of the elements to remove
Returns:
node()*

functx:remove-elements-not-contents

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

Removes descendant XML elements but keeps their content

Parameters:
$nodes* the root(s) to start from
$names* the names of the elements to remove
Returns:
node()*

functx:repeat-string

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

Repeats a string a given number of times

Parameters:
$stringToRepeat? the string to repeat
$count the desired number of copies
Returns:
xs:string

functx:replace-beginning

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? the entire string to change
$pattern the pattern of characters to replace up to
$replacement the replacement string
Returns:
xs:string

functx:replace-element-values

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

Updates the content of one or more elements

Parameters:
$elements* the elements whose content you wish to replace
$values* the replacement values
Returns:
element()*

functx:replace-first

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? the entire string to change
$pattern the pattern of characters to replace
$replacement the replacement string
Returns:
xs:string

functx:replace-multi

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? the string to manipulate
$changeFrom* the sequence of strings or patterns to change from
$changeTo* the sequence of strings to change to
Returns:
xs:string?

functx:reverse-string

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

Reverses the order of characters

Parameters:
$arg? the string to reverse
Returns:
xs:string

functx:right-trim

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

Trims trailing whitespace

Parameters:
$arg? the string to trim
Returns:
xs:string

functx:scheme-from-uri

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

Returns the scheme from a URI

Parameters:
$uri? the URI
Returns:
xs:string

functx:sequence-deep-equal

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* the first sequence
$seq2* the second sequence
Returns:
xs:boolean

functx:sequence-node-equal

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* the first sequence of nodes
$seq2* the second sequence of nodes
Returns:
xs:boolean

functx:sequence-node-equal-any-order

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* the first sequence of nodes
$seq2* the second sequence of nodes
Returns:
xs:boolean

functx:sequence-type

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

The sequence type that represents a sequence of nodes or values

Parameters:
$items* the items whose sequence type you want to determine
Returns:
xs:string

functx:siblings

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

The siblings of an XML node

Parameters:
$node? the node
Returns:
node()*

functx:siblings-same-name

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

The siblings of an XML element that have the same name

Parameters:
$element? the node
Returns:
element()*

functx:sort

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

Sorts a sequence of values or nodes

Parameters:
$seq* the sequence to sort
Returns:
item()*

functx:sort-as-numeric

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

Sorts a sequence of numeric values or nodes

Parameters:
$seq* the sequence to sort
Returns:
item()*

functx:sort-case-insensitive

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

Sorts a sequence of values or nodes regardless of capitalization

Parameters:
$seq* the sequence to sort
Returns:
item()*

functx:sort-document-order

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

Sorts a sequence of nodes in document order

Parameters:
$seq* the sequence to sort
Returns:
node()*

functx:substring-after-if-contains

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? the string to substring
$delim the delimiter
Returns:
xs:string?

functx:substring-after-last

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? the string to substring
$delim the delimiter
Returns:
xs:string?

functx:substring-after-last-match

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? the string to substring
$regex the regular expression
Returns:
xs:string?

functx:substring-after-match

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? the string to substring
$regex the regular expression
Returns:
xs:string?

functx:substring-before-if-contains

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? the string to substring
$delim the delimiter
Returns:
xs:string?

functx:substring-before-last

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? the string to substring
$delim the delimiter
Returns:
xs:string

functx:substring-before-last-match

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? the string to substring
$regex the regular expression
Returns:
xs:string?

functx:substring-before-match

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? the string to substring
$regex the regular expression
Returns:
xs:string?

functx:time

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 the hour
$minute the minute
$second the second
Returns:
xs:time

functx:timezone-from-duration

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 the duration
Returns:
xs:string

functx:total-days-from-duration

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

The total number of days in a dayTimeDuration

Parameters:
$duration? the duration
Returns:
xs:decimal?

functx:total-hours-from-duration

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

The total number of hours in a dayTimeDuration

Parameters:
$duration? the duration
Returns:
xs:decimal?

functx:total-minutes-from-duration

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

The total number of minutes in a dayTimeDuration

Parameters:
$duration? the duration
Returns:
xs:decimal?

functx:total-months-from-duration

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

The total number of months in a yearMonthDuration

Parameters:
$duration? the duration
Returns:
xs:decimal?

functx:total-seconds-from-duration

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

The total number of seconds in a dayTimeDuration

Parameters:
$duration? the duration
Returns:
xs:decimal?

functx:total-years-from-duration

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

The total number of years in a yearMonthDuration

Parameters:
$duration? the duration
Returns:
xs:decimal?

functx:trim

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

Trims leading and trailing whitespace

Parameters:
$arg? the string to trim
Returns:
xs:string

functx:update-attributes

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* the element(s) for which you wish to update the attribute
$attrNames* the name(s) of the attribute(s) to add
$attrValues* the value(s) of the attribute(s) to add
Returns:
element()*

functx:value-except

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* the first sequence
$arg2* the second sequence
Returns:
xs:anyAtomicType*

functx:value-intersect

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

The intersection of two sequences of values

Parameters:
$arg1* the first sequence
$arg2* the second sequence
Returns:
xs:anyAtomicType*

functx:value-union

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

The union of two sequences of values

Parameters:
$arg1* the first sequence
$arg2* the second sequence
Returns:
xs:anyAtomicType*

functx:word-count

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

The number of words

Parameters:
$arg? the string to measure
Returns:
xs:integer

functx:words-to-camel-case

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

Turns a string of words into camelCase

Parameters:
$arg? the string to modify
Returns:
xs:string

functx:wrap-values-in-elements

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* the values to wrap in elements
$elementName the name of the elements to construct
Returns:
element()*

functx:yearMonthDuration

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? the number of years
$months? the number of months
Returns:
xs:yearMonthDuration