Returns true if the specified parameters are the same Unicode code point, otherwise returns false. The codepoints are compared according to the Unicode code point collation (http://www.w3.org/2005/xpath-functions/collation/codepoint).

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

let $cp := fn:string-to-codepoints("123456")
return
fn:codepoint-equal("123456", fn:codepoints-to-string($cp) )

=> true

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

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

Returns -1, 0, or 1, depending on whether the value of the $comparand1 is respectively less than, equal to, or greater than the value of $comparand2, according to the rules of the collation that is used.

fn:compare("hello", "goodbye")

=> 1

Returns the xs:string that is the concatenation of the values of the specified parameters. Accepts two or more xs:anyAtomicType arguments and casts them to xs:string. If any of the parameters is the empty sequence, the parameter is treated as the zero-length string.

fn:concat("a", "b", "c")

=> abc

Returns true if the first parameter contains the string from the second parameter, otherwise returns false.

fn:contains("this is a string", "s a s")

=> true

Invertible function that escapes characters required to be escaped inside path segments of URIs.

fn:encode-for-uri("http://example.com/Weather/Los%20Angeles#ocean")
=> "http%3A%2F%2Fexample.com%2FWeather%2FLos%2520Angeles%23ocean"

Returns true if the first parameter ends with the string from the second parameter, otherwise returns false.

fn:ends-with("this is a string", "a string")

=> true

%-escapes everything except printable ASCII characters.

fn:escape-html-uri("http://example.com/Weather/Los Angeles#ocean")
=> "http://example.com/Weather/Los Angeles#ocean"

This is a May 2003 function, and is only available in compatibility mode (XQuery 0.9-ML)--it has been replaced with fn:encode-for-uri, fn:iri-to-uri, and fn:escape-html-uri. Returns a string representing the specified URI either with escaped reserved characters ($escape-reserved=true) or with the reserved characters left as specified ($escape-reserved=true). For more details, see the W3C XQuery Functions and Operators specification.

fn:escape-uri("http://developer.marklogic.com", fn:true())

=> http%3A%2F%2Fdeveloper.marklogic.com

fn:escape-uri("http://developer.marklogic.com", fn:false())

=> http://developer.marklogic.com

Idempotent function that escapes non-URI characters.

fn:iri-to-uri("http://example.com/Weather/Los%20Angeles#ocean")
=> "http://example.com/Weather/Los%20Angeles#ocean"

Returns the specified string converting all of the characters to lower-case characters. If a character does not have a corresponding lower-case character, then the original character is returned. The lower-case characters are determined using the Unicode Case Mappings.

fn:lower-case("aBCD")

=> abcd 

Returns true if the specified $input matches the specified $pattern, otherwise returns false.

fn:matches("this is a string", "is")

=> true

fn:matches("this is a string", "zoo")

=> false

Returns the specified string with normalized whitespace, which strips off any leading or trailing whitespace and replaces any other sequences of more than one whitespace characters with a single space character (#x20).

fn:normalize-space("
this
is
  a string
  ")

=> this is a string

Return the argument normalized according to the normalization criteria for a normalization form identified by the value of $normalizationForm. The effective value of the $normalizationForm is computed by removing leading and trailing blanks, if present, and converting to upper case.

Returns a string constructed by replacing the specified $pattern on the $input string with the specified $replacement string.

fn:replace("this is a string", "this", "that")

-> that is a string

Returns true if the first parameter starts with the string from the second parameter, otherwise returns false.

fn:starts-with("abcd", "ab")

=> true

Returns an xs:string created by concatenating the members of the $parameter1 sequence using $parameter2 as a separator. If the value of $arg2 is the zero-length string, then the members of $parameter1 are concatenated without a separator.

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

fn:string-join(("hello", "goodbye"), " and ")

=> hello and goodbye

let $string := "this is a string"
return
fn:string-join(fn:tokenize($string, " "),
               "-")

=> this-is-a-string

Returns an integer representing the length of the specified string. The length is 1-based, so a string that is one character long returns a value of 1.

fn:string-length("12345")

=> 5

[0.9-ml only] Returns a string representing the $padString concatenated with itself the number of times specifed in $padCount.

fn:string-pad("abc", 3)

=> abcabcabc

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

fn:string-to-codepoints("Thèrése") 

returns the sequence (84, 104, 233, 114, 232, 115, 101)

Returns a substring starting from the $startingLoc and continuing for $length characters.

fn:substring("123456", 2, 2)

=> "23"

Returns the substring created by taking all of the input characters that occur after the specified $after characters.

fn:substring-after("123456", "3")

=> "456"

Returns the substring created by taking all of the input characters that occur before the specified $before characters.

fn:substring-before("abcdef", "def")

=> abc

Returns a sequence of strings contructed by breaking the specified input into substrings separated by the specified $pattern. The specified $pattern is not returned as part of the returned items.

fn:tokenize("this is a string", " ")

=> returns the sequence ("this", "is", "a", "string")

fn:tokenize("this is a string", " ")[last()]

=> string

Returns a string where every character in $src that occurs in some position in the $mapString is translated into the $transString character in the corresponding location of the $mapString character.

fn:translate("abcd", "abcd", "wxyz") 

=> wxyz

Returns the specified string converting all of the characters to upper-case characters. If a character does not have a corresponding upper-case character, then the original character is returned. The upper-case characters are determined using the Unicode Case Mappings.

fn:upper-case("Abcd")

=> ABCD