Returns the confidence of a node, or of the context node if no node is provided.

Confidence is similar to score, except that it is bounded. It is an xs:float in the range of 0.0 to 1.0. It does not include quality.

When using with any of the scoring methods, the confidence is calculated by first bounding the score in the range of 0.0 to 1.0, then taking the square root of that number.

  let $x := cts:search(collection(), "dog")
  return
  cts:confidence($x[1])

   => Returns the confidence value for the first item
      in the search.

Returns true if any of a sequence of nodes matches a query.

cts:contains(//PLAY
  [TITLE="The Tragedy of Hamlet, Prince of Denmark"]
      /ACT[3]/SCENE[1],
    cts:word-query("To be, or not to be"))
  => ..true, if ACT II, SCENE I of Hamlet contains
    the phrase "To be, or not to be" (it does).

Deregister a registered query, explicitly releasing the associated resources.

  cts:deregister(xs:unsignedLong("12345678901234567"))
  
   => ()

Returns values from the specified element-attribute value lexicon(s) that match the specified wildcard pattern. Element-attribute value lexicons are implemented using string range indexes; consequently this function requires an attribute range index of type xs:string for each of the element/attribute pairs specified in the function. If there is not a string range index configured for any of the specified element/attribute pairs, then an exception is thrown.

If multiple element and/or attribute QNames are specified, then all possible element/attribute QName combinations are used to select the matching values.

Note the following interactions about the options:

If neither "case-sensitive" nor "case-insensitive" is present, $pattern is used to determine case sensitivity. If $pattern contains no uppercase, it specifies "case-insensitive". If $pattern contains uppercase, it specifies "case-sensitive".

If neither "diacritic-sensitive" nor "diacritic-insensitive" is present, $pattern is used to determine diacritic sensitivity. If $pattern contains no diacritics, it specifies "diacritic-insensitive". If $pattern contains diacritics, it specifies "diacritic-sensitive".

If the options parameter contains neither "ascending" nor "descending", then the default is "ascending".

At most one of "any", "document", "properties", or "locks" may be specified in the options parameter. If the options parameter contains none of "any", "document", "properties", or "locks", then the default is "any".

If the $query parameter is not present, and the current user is assigned the admin role, no value filtering is performed. Values may be returned that only appear in deleted fragments not yet expunged by a merge. To filter deleted values in this case, use a $query parameter. For example:

      cts:and-query( () ) 

  cts:element-attribute-value-match(xs:QName("animals"),
                     xs:QName("name"),"aardvark*")
  => ("aardvark","aardvarks")

Returns values from the specified element-attribute value lexicon(s). Element-attribute value lexicons are implemented using string range indexes; consequently this function requires an attribute range index of type xs:string or xs:anyURI for each of the element/attribute pairs specified in the function. If there is not a string range index configured for any of the specified element/attribute pairs, then an exception is thrown. The values are returned in collation order.

If multiple element and/or attribute QNames are specified, then all possible element/attribute QName combinations are used to select the matching values.

If the options parameter contains neither "ascending" nor "descending", then the default is "ascending".

At most one of "any", "document", "properties", or "locks" may be specified in the options parameter. If the options parameter contains none of "any", "document", "properties", or "locks", then the default is "any".

If the $query parameter is not present, and the current user is assigned the admin role, no value filtering is performed. Values may be returned that only appear in deleted fragments not yet expunged by a merge. O filter deleted values in this case, use a $query parameter. For example:

      cts:and-query( () ) 

  cts:element-attribute-values(xs:QName("animal"),
                               xs:QName("name"),
			       "aardvark")
  => ("aardvark","aardvarks","aardwolf",...)

Returns words from the specified element-attribute word lexicon(s) that match a wildcard pattern. This function requires an element-attribute word lexicon for each of the element/attribute pairs specified in the function. If there is not an element-attribute word lexicon configured for any of the specified element/attribute pairs, then an exception is thrown.

If multiple element and/or attribute QNames are specified, then all possible element/attribute QName combinations are used to select the matching values.

Note the following interactions about the options:

If neither "case-sensitive" nor "case-insensitive" is present, $pattern is used to determine case sensitivity. If $pattern contains no uppercase, it specifies "case-insensitive". If $pattern contains uppercase, it specifies "case-sensitive".

If neither "diacritic-sensitive" nor "diacritic-insensitive" is present, $pattern is used to determine diacritic sensitivity. If $pattern contains no diacritics, it specifies "diacritic-insensitive". If $pattern contains diacritics, it specifies "diacritic-sensitive".

If the options parameter contains neither "ascending" nor "descending", then the default is "ascending".

At most one of "any", "document", "properties", or "locks" may be specified in the options parameter. If the options parameter contains none of "any", "document", "properties", or "locks", then the default is "any".

If the $query parameter is not present, and the current user is assigned the admin role, no word filtering is performed. Words may be returned that only appear in deleted fragments not yet expunged by a merge. To filter deleted words in this case, use a $query parameter. For example:

      cts:and-query( () ) 

  cts:element-word-match(xs:QName("animals"),"aardvark*")
  => ("aardvark","aardvarks")

Returns words from the specified element-attribute word lexicon(s). This function requires an element-attribute lexicon for each of the element/attribute pairs specified in the function. If there is not an element/attribute word lexicon configured for any of the specified element/attribute pairs, then an exception is thrown. The words are returned in collation order.

If multiple element and/or attribute QNames are specified, then all possible element/attribute QName combinations are used to select the matching values.

If the options parameter contains neither "ascending" nor "descending", then the default is "ascending".

At most one of "any", "document", "properties", or "locks" may be specified in the options parameter. If the options parameter contains none of "any", "document", "properties", or "locks", then the default is "any".

If the $query parameter is not present, and the current user is assigned the admin role, no word filtering is performed. Words may be returned that only appear in deleted fragments not yet expunged by a merge. To filter deleted words in this case, use a $query parameter. For example:

      cts:and-query( () ) 

  cts:element-attribute-words(xs:QName("animal"),
                              xs:QName("name"),
			      "aardvark")
  => ("aardvark","aardvarks","aardwolf",...)

Returns values from the specified element value lexicon(s) that match the specified wildcard pattern. Element value lexicons are implemented using string range indexes; consequently this function requires an element range index of type xs:string for each element specified in the function. If there is not a string range index configured for any of the specified elements, then an exception is thrown.

Note the following interactions about the options:

If neither "case-sensitive" nor "case-insensitive" is present, $pattern is used to determine case sensitivity. If $pattern contains no uppercase, it specifies "case-insensitive". If $pattern contains uppercase, it specifies "case-sensitive".

If neither "diacritic-sensitive" nor "diacritic-insensitive" is present, $pattern is used to determine diacritic sensitivity. If $pattern contains no diacritics, it specifies "diacritic-insensitive". If $pattern contains diacritics, it specifies "diacritic-sensitive".

If the options parameter contains neither "ascending" nor "descending", then the default is "ascending".

At most one of "any", "document", "properties", or "locks" may be specified in the options parameter. If the options parameter contains none of "any", "document", "properties", or "locks", then the default is "any".

If the $query parameter is not present, and the current user is assigned the admin role, no value filtering is performed. Values may be returned that only appear in deleted fragments not yet expunged by a merge. To filter deleted values in this case, use a $query parameter. For example:

      cts:and-query( () ) 

  cts:element-value-match(xs:QName("animal"),"aardvark*")
  => ("aardvark","aardvarks")

Returns values from the specified element value lexicon(s). Element value lexicons are implemented using string range indexes; consequently this function requires an element index of type xs:string or xs:anyURI for each element specified in the function. If there is not a string range index configured for any of the specified elements, an exception is thrown. The values are returned in collation order.

If the options parameter contains neither "ascending" nor "descending", then the default is "ascending".

At most one of "any", "document", "properties", or "locks" may be specified in the options parameter. If the options parameter contains none of "any", "document", "properties", or "locks", then the default is "any".

If the $query parameter is not present, and the current user is assigned the admin role, no value filtering is performed. Values may be returned that only appear in deleted fragments not yet expunged by a merge. To filter deleted values in this case, use a $query parameter. For example:

      cts:and-query( () ) 

  cts:element-values(xs:QName("animal"),"aardvark")
  => ("aardvark","aardvarks","aardwolf",...)

Returns words from the specified element word lexicon(s) that match a wildcard pattern. This function requires an element word lexicon configured for each of the specified elements in the function. If there is not an element word lexicon configured for any of the specified elements, an exception is thrown.

Note the following interactions about the options:

If neither "case-sensitive" nor "case-insensitive" is present, $pattern is used to determine case sensitivity. If $pattern contains no uppercase, it specifies "case-insensitive". If $pattern contains uppercase, it specifies "case-sensitive".

If neither "diacritic-sensitive" nor "diacritic-insensitive" is present, $pattern is used to determine diacritic sensitivity. If $pattern contains no diacritics, it specifies "diacritic-insensitive". If $pattern contains diacritics, it specifies "diacritic-sensitive".

If the options parameter contains neither "ascending" nor "descending", then the default is "ascending".

At most one of "any", "document", "properties", or "locks" may be specified in the options parameter. If the options parameter contains none of "any", "document", "properties", or "locks", then the default is "any".

If the $query parameter is not present, and the current user is assigned the admin role, no word filtering is performed. Words may be returned that only appear in deleted fragments not yet expunged by a merge. To filter deleted words in this case, use a $query parameter. For example:

      cts:and-query( () ) 

Only words that can be matched with element-word-query are returned. That is, only words present in immediate text node children of the specified element as well as any text node children of child elements defined in the Admin Interface as element-word-query-throughs or phrase-throughs.

  cts:element-word-match(xs:QName("animal"),"aardvark*")
  => ("aardvark","aardvarks")

Returns words from the specified element word lexicon. This function requires an element lexicon for each of the element specified in the function. If there is not an element word lexicon configured for any of the specified elements, an exception is thrown. The words are returned in collation order.

If the options parameter contains neither "ascending" nor "descending", then the default is "ascending".

At most one of "any", "document", "properties", or "locks" may be specified in the options parameter. If the options parameter contains none of "any", "document", "properties", or "locks", then the default is "any".

If the $query parameter is not present, and the current user is assigned the admin role, no word filtering is performed. Words may be returned that only appear in deleted fragments not yet expunged by a merge. To filter deleted words in this case, use a $query parameter. For example:

      cts:and-query( () ) 

Only words that can be matched with element-word-query are returned. That is, only words present in immediate text node children of the specified element as well as any text node children of child elements defined in the Admin Interface as element-word-query-throughs or phrase-throughs.

  cts:element-words(xs:QName("animal"),"aardvark")
  => ("aardvark","aardvarks","aardwolf",...)

Returns a copy of the node, replacing any text matching the query with the specified expression. You can use this function to easily highlight any text found in a query. Unlike fn:replace and other XQuery string functions that match literal text, cts:highlight matches every term that matches the search, including stemmed matches or matches with different capitalization.

There are three built-in variables to represent a query match. These variables can be used inline in the the expression parameter.

$cts:text as xs:string

the matched text

$cts:node as text()

the node containing the matched text

$cts:queries as cts:query*

the matching queries

You cannot use cts:highlight to highlight results from cts:similar-query and cts:element-attribute-*-query items. Using cts:highlight with these queries will return the nodes without any highlighting.

You can also use cts:highlight as a general search and replace function. The specified expression will replace any matching text. For example, you could replace the word "hello" with "goodbye" in a query similar to the following:

 cts:highlight($node, "hello", "goodbye")

Because the expressions can be any XQuery expression, they can be very simple like the above example or they can be extremely complex.

To highlight "MarkLogic" with bold in the following paragraph:
  
let $x :=  <p>MarkLogic Server is an enterprise-class 
  database specifically built for content.</p>
return 
cts:highlight($x, "MarkLogic", <b>{$cts:text}</b>)

Returns:
  
  <p><b>MarkLogic</b> Server is an enterprise-class 
  database specifically built for content.</p> 
  

Given the following document with the URI "hellogoodbye.xml":

<root>
  <a>It starts with hello and ends with goodbye.</a>
</root>

The following query will highlight the word "hello" in 
blue, and everything else in red.

cts:highlight(doc("hellogoodbye.xml"), 
       cts:and-query((cts:word-query("hello"),
                      cts:word-query("goodbye"))),
  if ( cts:word-query-text($cts:queries) eq "hello" )
  then ( <font color="blue">{$cts:text}</font> )
  else ( <font color="red">{$cts:text}</font> ) 
             )
	     
returns:

<root>
  <a>It starts with <font color="blue">hello</font> 
  and ends with <font color="red">goodbye</font>.</a>
</root>

for $x in cts:search(collection(), "MarkLogic")
return
cts:highlight($x, "MarkLogic", <b>{$cts:text}</b>)

returns all of the nodes that contain "MarkLogic", 
placing bold markup around the matched words.

Returns the quality of a node, or of the context node if no node is provided.

If you run cts:quality on a constructed node, it always returns 0; it is primarily intended to run on nodes that are the retrieved from the database (an item from a cts:search result or an item from the result of an XPath expression that searches through the database).

  xdmp:document-insert("/test.xml", <a>my test</a>, (), (), 50);
  for $x in cts:search(collection(),"my test")
  return cts:quality($x) => 50

  for $a in cts:search(collection(),"my test")
  where $a[cts:quality() gt 10]
  return base-uri($a) => /test.xml

Register a query for later use.

  cts:register(cts:collection-query("mycollection"))
  
  => 12345678901234567