XQuery Function Documentation

-------------------------------- 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#3

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#2

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#3

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#1

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#1

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#1

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#2

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#3

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#3

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#2

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#1

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#3

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#3

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#3

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#1

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#2

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#2

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#2

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#2

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#3

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#6

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#1

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#1

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#1

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#1

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#4

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#1

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#1

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#1

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#1

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#1

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#1

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#1

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#1

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#2

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#1

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#2

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#1

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#1

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#1

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#2

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#1

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#1

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#2

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#2

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#1

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#1

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#1

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#1

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#1

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#2

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#2

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#2

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#2

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#2

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#2

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#2

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#2

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#2

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#3

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#1

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#1

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#2

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#2

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#1

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#2

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#2

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#2

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#2

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#2

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#1

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#1

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#1

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#1

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#1

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#1

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#1

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#1

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#1

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#1

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#1

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#1

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#1

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#1

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#1

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#1

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#1

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#1

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#1

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#2

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#1

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#1

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

The next day

Parameters:

$date

the date

Returns:

xs:date?

functx:node-kind#1

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#1

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#2

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#1

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#1

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#2

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#3

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#1

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#1

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#2

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#1

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

The previous day

Parameters:

$date

the date

Returns:

xs:date?

functx:remove-attributes#2

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#2

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#2

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#2

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#2

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#2

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#3

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#2

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#3

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#3

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#1

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#1

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#1

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#2

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#2

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#2

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#1

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#1

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

The siblings of an XML node

Parameters:

$node

the node

Returns:

node()*

functx:siblings-same-name#1

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#1

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#1

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#1

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#1

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#2

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#2

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#2

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#2

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#2

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#2

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#2

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#2

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#3

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#1

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#1

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#1

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#1

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#1

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#1

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#1

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#1

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#3

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#2

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#2

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#2

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#1

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#1

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#2

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#2

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

XQuery Function Documentation

http://www.functx.com

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