Returns a query specifying the set difference of the matches specified by two sub-queries.

The cts:and-not-query constructor is fragment-based, so it returns true only if the specified query does not produce a match anywhere in a fragment. Therefore, a search using cts:and-not-query is only guaranteed to be accurate if the underlying query that is being negated is accurate from its index resolution (that is, if the unfiltered results of the $negative-query parameter to cts:not-query are accurate). The accuracy of the index resolution depends on many factors such as the query, if you search at a fragment root (that is, if the first parameter of cts:search specifies an XPath that resolves to a fragment root), the index options enabled on the database, the search options, and other factors. In cases where the $negative-query parameter has false positive matches, the negation of the query can miss matches (have false negative matches). In these cases, searches with cts:and-not-query can miss results, even if those searches are filtered.

  cts:search(//PLAY,
    cts:and-not-query(
      cts:word-query("summer"),
      cts:word-query("glorious")))
  => .. sequence of 'PLAY' elements containing some
  text node with the word 'summer' BUT NOT containing
  any text node with the word 'glorious'.  This sequence
  may be (in fact is) non-empty, but certainly does not
  contain the PLAY element with:

    PLAY/TITLE = 
      "The Tragedy of King Richard the Second"

  since this play contains both 'glorious' and 'summer'.

Returns the negative (second parameter) query used to construct the specified query.

let $query := cts:and-not-query(
                 cts:word-query("wanted"), 
                 cts:word-query("unwanted"))
return cts:and-not-query-negative-query($query)
  
  => cts:word-query("unwanted", (), 1)

Returns the positive (first parameter) query used to construct the specified query.

let $query := cts:and-not-query(
                 cts:word-query("wanted"), 
                 cts:word-query("unwanted"))
return cts:and-not-query-positive-query($query)
  
  => cts:word-query("wanted", (), 1)

Returns a query specifying the intersection of the matches specified by the sub-queries.

If the options parameter contains neither "ordered" nor "unordered", then the default is "unordered".

If you specify the empty sequence for the queries parameter to cts:and-query, you will get a match for every document in the database. For example, the following query always returns true:

   cts:contains(collection(), cts:and-query(()))

In order to match a cts:and-query, the matches from each of the specified sub-queries must all occur in the same fragment.

  cts:search(//PLAY,
    cts:and-query((
      cts:word-query("to be or"),
      cts:word-query("or not to be"))))
  => .. a sequence of 'PLAY' elements which are
  ancestors (or self) of some node whose text content
  contains the phrase 'to be or' AND some node
  whose text content contains the phrase 'or not to be'.
  With high probability this intersection contains only 
  one 'PLAY' element, namely,
    
    PLAY/TITLE = 
      "The Tragedy of Hamlet, Prince of Denmark".

Returns the options for the specified query.

  cts:and-query-options($query)
  => "ordered"

Returns a sequence of the queries that were used to construct the specified query.

  cts:and-query-queries($query)
  => ... a sequence of the queries used to 
            construct this query

let $query := 
  cts:and-query((
    cts:word-query("to be or"), 
    cts:word-query("or not to be")))
return cts:and-query-queries($query)
  => (cts:word-query("to be or", (), 1) 
         cts:word-query("or not to be", (), 1))

Returns a query matching documents in the collections with the given URIs. It will match both documents and properties documents in the collections with the given URIs.

  cts:search(//function,
    cts:collection-query(("reports", "analysis")))
  
  => .. a sequence of 'function' elements in any document in the 
     collection "reports" or in the collection "analysis".

cts:search(//function, cts:and-query(("repair", 
    cts:collection-query(("reports", "analysis")))))
  
  => .. relevance ordered sequence of 'function' elements in 
     any document that both contains the word "repair" and is
     in either the collection "reports" or in the collection 
     "analysis".

Returns the URIs used to construct the specified query.

  cts:collection-query-uris($query)
  => ("reports", "analysis")

Returns a query matching documents in the directories with the given URIs.

  cts:search(//function,
    cts:directory-query(("/reports/","/analysis/"),"1"))
  
  => .. a sequence of 'function' elements in any document 
     in the directory "/reports/" or the directory "/analysis/".

cts:search(//function, cts:and-query(("repair", 
  cts:directory-query(("/reports/", "/analysis/"), "1"))))
  
  => .. relevance ordered sequence of 'function' elements in 
     any document that both contains the word "repair" and is
     in either the directory "/reports/" or in the directory 
     "/analysis/".

Returns the depth used to construct the specified query.

  cts:directory-query-depth($query)
  => 1

Returns the URIs used to construct the specified query.

  cts:directory-query-uris($query)
  => ("/reports", "/analysis/")

Returns a query that matches all documents where $query matches any document fragment. When searching documents, document-properties, or document-locks, cts:document-fragment-query provides a convenient way to additionally constrain the search against any document fragment.

A query that uses cts:document-fragment-query allows you to cross fragment boundaries in a cts:and-query, as shown in the second example below.

cts:search(
xdmp:document-properties(),
  cts:document-fragment-query(
    cts:word-query("hello")))

=>  All properties documents whose corresponding document
    (that is, the document at the same URI as the 
    proerties document) contain the word "hello".

xquery version "1.0-ml";
(:
 Given a document with a fragment root of <fragment> 
 created as follows:

xdmp:document-insert("fragmented.xml",
   <root>
     <author>bob</author>
     <fragment>dog</fragment>
     <fragment>cat</fragment>
     <fragment>fish</fragment>
  </root>);

:)
 
cts:search(fn:doc("fragmented.xml"),
  cts:and-query((
    cts:document-fragment-query("bob"),
    "dog"
  ))
)
=> returns the fragmented.xml document

Returns the query used to construct the specified query.

  cts:document-fragment-query-query(cts:document-fragment-query(cts:word-query("word")))
  => cts:word-query("word")

Returns a query matching documents with the given URIs. It will match both documents and properties documents with the given URIs.

  cts:search(//function,
    cts:document-query("/reports.xml"))
  
  => .. relevance-ordered sequence of 'function' elements
  in the document "/reports.xml".

cts:search(//function, cts:and-query(("repair", 
  cts:document-query(("/reports.xml", "/analysis.xml")))))
  
  => .. relevance ordered sequence of 'function' elements in 
     any document that both contains the word "repair" and is
     in either the document "/reports.xml" or in the document 
     "/analysis.xml".

Returns the URIs used to construct the specified query.

  cts:document-query-uris($query)
  => ("/reports.xml", "/analysis.xml")

Returns a cts:query matching elements by name which has specific attributes representing latitude and longitude values for a point contained within the given geographic box, circle, or polygon, or equal to the given point. Points that lie between the southern boundary and the northern boundary of a box, travelling northwards, and between the western boundary and the eastern boundary of the box, travelling eastwards, will match. Points contained within the given radius of the center point of a circle will match, using the curved distance on the surface of the Earth. Points contained within the given polygon will match, using great circle arcs over a spherical model of the Earth as edges. An error may result if the polygon is malformed in some way. Points equal to the a given point will match, taking into account the fact that longitudes converge at the poles. Using the geospatial query constructors requires a valid geospatial license key; without a valid license key, searches that include geospatial queries will throw an exception.

The point value is expressed as the numerical values in the textual content of the named attributes.

The point values and the boundary specifications are given in degrees relative to the WGS84 coordinate system. Southern latitudes and Western longitudes take negative values. Longitudes will be wrapped to the range (-180,+180) and latitudes will be clipped to the range (-90,+90).

If the northern boundary of a box is south of the southern boundary, no points will match. However, longitudes wrap around the globe, so that if the western boundary is east of the eastern boundary (that is, if the value of 'w' is greater than the value of 'e'), then the box crosses the anti-meridian.

Special handling occurs at the poles, as all longitudes exist at latitudes +90 and -90.

If neither "cached" nor "uncached" is present, it specifies "cached".

(: create a document with test data :)
xdmp:document-insert("/points.xml",
<root>
  <item><point lat="10.5" long="30.0"/></item>
  <item><point lat="15.35" long="35.34"/></item>
  <item><point lat="5.11" long="40.55"/></item>
</root> );

cts:search(doc("/points.xml")//item, 
  cts:element-attribute-pair-geospatial-query(xs:QName("point"), 
    xs:QName("lat"), xs:QName("long"), cts:box(10.0, 35.0, 20.0, 40.0)))
(:
  returns the following node: 
  <item><point lat="15.35" long="35.34"/></item>
:)
;

cts:search(doc("/points.xml")//item, 
  cts:element-attribute-pair-geospatial-query(xs:QName("point"), 
    xs:QName("lat"), xs:QName("long"), cts:box(10.0, 40.0, 20.0, 35.0)))
(:
  returns the following nodes (wrapping around the Earth):
  <item><point lat="10.5" long="30.0"/></item>
:)
;

cts:search(doc("/points.xml")//item, 
  cts:element-attribute-pair-geospatial-query(xs:QName("point"), 
    xs:QName("lat"), xs:QName("long"), cts:box(20.0, 35.0, 10.0, 40.0)))
(:
  throws an error (latitudes do not wrap)
:)
;

Returns the QNames used to construct the specified query.

let $query := 
   cts:element-attribute-pair-geospatial-query(xs:QName("point"), 
     xs:QName("lat"), xs:QName("long"), cts:box(10.1, 10.2, 20.1, 20.2))
return cts:element-attribute-pair-geospatial-query-element-name($query)
  => xs:QName("point")

Returns the QNames used to construct the specified query.

let $query := 
   cts:element-attribute-pair-geospatial-query(xs:QName("point"), 
     xs:QName("lat"), xs:QName("long"), cts:box(10.1, 10.2, 20.1, 20.2))
return cts:element-attribute-pair-geospatial-query-latitude-name($query)
  => xs:QName("lat")

Returns the QNames used to construct the specified query.

let $query := 
   cts:element-attribute-pair-geospatial-query(xs:QName("point"), 
     xs:QName("lat"), xs:QName("long"), cts:box(10.1, 10.2, 20.1, 20.2))
return cts:element-attribute-pair-geospatial-query-longitude-name($query)
  => xs:QName("lat")

Returns the options for the specified query.

let $query := 
   cts:element-attribute-pair-geospatial-query(xs:QName("point"), 
     xs:QName("lat"), xs:QName("long"), cts:box(10.1, 10.2, 20.1, 20.2))
return cts:element-attribute-pair-geospatial-query-options($query)
  => "coordinate-system=wgs84"

Returns the geographical regions with which the specified query was constructed.

let $query := 
   cts:element-attribute-pair-geospatial-query(xs:QName("point"), 
     xs:QName("lat"), xs:QName("long"), cts:box(10.1, 10.2, 20.1, 20.2))
return cts:element-attribute-pair-geospatial-query-region($query)
  => cts:box(10.1, 10.2, 20.1, 20.2)

Returns the weight with which the specified query was constructed.

let $query := 
   cts:element-attribute-pair-geospatial-query(xs:QName("point"), 
     xs:QName("lat"), xs:QName("long"), cts:box(10.1, 10.2, 20.1, 20.2))
return cts:element-attribute-pair-geospatial-query-weight($query)
  => 1

Returns a cts:query matching elements by name with a range-index entry equal a given value. Searches with the cts:element-attribute-range-query constructor require an attribute range index on the specified QName(s); if there is no range index configured, then an exception is thrown.

If you want to constrain on a range of values, you can combine multiple cts:element-attribute-range-query constructors together with cts:and-query or other composable cts:query constructors.

If neither "cached" nor "uncached" is present, it specifies "cached".

Negative "min-occurs" or "max-occurs" values will be treated as 0 and non-integral values will be rounded down. An error will be raised if the "min-occurs" value is greater than the "max-occurs" value.

(: create a document with test data :)
xdmp:document-insert("/attributes.xml",
<root>
  <entry sku="100">
    <product>apple</product>
  </entry>
  <entry sku="200">
    <product>orange</product>
  </entry>
  <entry sku="1000">
    <product>electric car</product>
  </entry>
</root>) ;

(: 
   requires an attribute (range) index of 
   type xs:int on the "sku" attribute of
   the "entry" element 
:)
cts:search(doc("/attributes.xml")/root/entry, 
  cts:element-attribute-range-query(
      xs:QName("entry"), xs:QName("sku"), ">=",
      500))
(:
  returns the following node: 
  <entry sku="1000">
    <product>electric car</product>
  </entry>
:)

Returns the QNames used to construct the specified query.

let $query := cts:element-attribute-range-query(
              xs:QName("function"),
              xs:QName("name"),
              "MarkLogic Corporation")
return cts:element-attribute-range-query-attribute-name($query)

  => xs:QName("name")

Returns the QNames used to construct the specified query.

let $query := cts:element-attribute-range-query(
              xs:QName("function"),
              xs:QName("name"),
              "MarkLogic Corporation")
return cts:element-attribute-range-query-element-name($query)

  => xs:QName("function")

Returns the operator used to construct the specified query.

  cts:element-attribute-range-query-operator($query)
  => "<"

Returns the options for the specified query.

  cts:element-attribute-range-query-options($query)
  => "collation=http://marklogic.com/collation/"

Returns the value used to construct the specified query.

  cts:element-attribute-range-query-value($query)
  => 123

Returns the weight with which the specified query was constructed.

  cts:element-attribute-range-query-weight($query)
  => 1

Returns a query matching elements by name with attributes by name with text content equal a given phrase.

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

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

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

If neither "whitespace-sensitive" nor "whitespace-insensitive" is present, the query is "whitespace-insensitive".

If neither "stemmed" nor "unstemmed" is present, the database configuration determines stemming. If the database has "stemmed searches" enabled, it specifies "stemmed". Otherwise it specifies "unstemmed".

If neither "wildcarded" nor "unwildcarded" is present, the database configuration and $text determine wildcarding. If the database has any wildcard indexes enabled ("three character searches", "two character searches", "one character searches", or "trailing wildcard searches") and if $text contains either of the wildcard characters '?' or '*', it specifies "wildcarded". Otherwise it specifies "unwildcarded".

If neither "stemmed" nor "unstemmed" is present, then the database configuration determines if a query is run as "stemmed" (stemmed searches enabled) or "unstemmed" (word searches enabled and stemmed searches disabled). If the query is a wildcard query and is also a phrase query (contains two or more terms), then any wildcard terms in the query will be "unstemmed".

Negative "min-occurs" or "max-occurs" values will be treated as 0 and non-integral values will be rounded down. An error will be raised if the "min-occurs" value is greater than the "max-occurs" value.

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

  cts:search(//module,
    cts:element-attribute-value-query(
      xs:QName("function"), 
      xs:QName("type"), 
      "MarkLogic Corporation"))
  

  => .. relevance-ordered sequence of 'module' element
  ancestors (or self) of 'function' elements that have
  an attribute 'type' whose value equals 'MarkLogic 
  Corporation'.

  cts:search(//module,
    cts:and-query((
      cts:element-attribute-value-query(
        xs:QName("function"), 
        xs:QName("type"), 
        "MarkLogic Corporation",
        false(), true(), 0.5),
      cts:element-word-query(
        xs:QName("title"), 
        "faster"))))
  

  => .. relevance-ordered sequence of 'module' element
  ancestors (or self) of both:
   (a) 'function' elements with attribute 'type' whose
       value equals the string 'MarkLogic Corporation', 
       ignoring embedded punctuation,
   AND
   (b) 'title' elements whose text content contains the
       word 'faster', with the results from (a) given
       weight 0.5, and the results from (b) given default
       weight 1.0.

Returns the attribute QNames used to construct the specified query.

let $query := cts:element-attribute-value-query(
              xs:QName("function"),
              xs:QName("type"),
              "MarkLogic Corporation")
return 
  cts:element-attribute-value-query-attribute-name($query)

  => xs:QName("type")

Returns the element QNames used to construct the specified query.

let $query := cts:element-attribute-value-query(
              xs:QName("function"),
              xs:QName("type"),
              "MarkLogic Corporation")
return 
  cts:element-attribute-value-query-element-name($query)

  => xs:QName("function")

Returns the options for the specified query.

  cts:element-attribute-value-query-options($query)
  => ("case-sensitive", "punctuation-insensitive")

Returns the text used to construct the specified query.

  cts:element-attribute-value-query-text($query)
  => "choice of law"

Returns the weight with which the specified query was constructed.

  cts:element-attribute-value-query-weight($query)
  => 1

Returns a query matching elements by name with attributes by name with text content containing a given phrase.

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

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

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

If neither "whitespace-sensitive" nor "whitespace-insensitive" is present, the query is "whitespace-insensitive".

If neither "stemmed" nor "unstemmed" is present, the database configuration determines stemming. If the database has "stemmed searches" enabled, it specifies "stemmed". Otherwise it specifies "unstemmed".

If neither "wildcarded" nor "unwildcarded" is present, the database configuration and $text determine wildcarding. If the database has any wildcard indexes enabled ("three character searches", "two character searches", "one character searches", or "trailing wildcard searches") and if $text contains either of the wildcard characters '?' or '*', it specifies "wildcarded". Otherwise it specifies "unwildcarded".

If neither "stemmed" nor "unstemmed" is present, then the database configuration determines if a query is run as "stemmed" (stemmed searches enabled) or "unstemmed" (word searches enabled and stemmed searches disabled). If the query is a wildcard query and is also a phrase query (contains two or more terms), then any wildcard terms in the query will be "unstemmed".

Negative "min-occurs" or "max-occurs" values will be treated as 0 and non-integral values will be rounded down. An error will be raised if the "min-occurs" value is greater than the "max-occurs" value.

  cts:search(//module,
    cts:element-attribute-word-query(
      xs:QName("function"), 
      xs:QName("type"), 
      "MarkLogic Corporation"))
  

  => .. relevance-ordered sequence of 'module' element
  ancestors of 'function' elements that have a 'type'
  attribute whose value contains the phrase 
  'MarkLogic Corporation'.

  cts:search(//module,
    cts:element-attribute-word-query(
      xs:QName("function"), 
      xs:QName("type"), 
      "MarkLogic Corporation", "case-insensitive"))
  

  => .. relevance-ordered sequence of 'module' element
  ancestors of 'function' elements that have a 'type'
  attribute whose value contains the phrase 
  'MarkLogic Corporation', or any other case-shift,
  like 'MARKLOGIC CorpoRation'.

  cts:search(//module,
    cts:and-query((
      cts:element-attribute-word-query(
        xs:QName("function"), 
        xs:QName("type"), 
        "MarkLogic Corporation",
        "punctuation-insensitive", 0.5),
      cts:element-word-query(
        xs:QName("title"), 
        "faster"))))
  

  => .. relevance-ordered sequence of 'module' element
  ancestors of both:
  (a) 'function' elements with 'type' attribute whose value
      contains the phrase 'MarkLogic Corporation', 
      ignoring embedded punctuation,
  AND
  (b) 'title' elements whose text content contains the
      term 'faster',
  with the results of the first query given weight 0.5,
  as opposed to the default 1.0 for the second query.

Returns the attribute QNames used to construct the specified query.

let $query := cts:element-attribute-word-query(
              xs:QName("function"),
              xs:QName("type"),
              "MarkLogic Corporation")
return 
  cts:element-attribute-word-query-attribute-name($query)

  => xs:QName("type")

Returns the element QNames used to construct the specified query.

let $query := cts:element-attribute-word-query(
              xs:QName("function"),
              xs:QName("type"),
              "MarkLogic Corporation")
return 
  cts:element-attribute-word-query-element-name($query)

  => xs:QName("function")

Returns the options for the specified query.

  cts:element-attribute-word-query-options($query)
  => ("case-sensitive", "punctuation-insensitive")

Returns the text used to construct the specified query.

  cts:element-attribute-word-query-text($query)
  => "choice of law"

Returns the weight with which the specified query was constructed.

  cts:element-attribute-word-query-weight($query)
  => 1

Returns a cts:query matching elements by name which has specific element children representing latitude and longitude values for a point contained within the given geographic box, circle, or polygon, or equal to the given point. Points that lie between the southern boundary and the northern boundary of a box, travelling northwards, and between the western boundary and the eastern boundary of the box, travelling eastwards, will match. Points contained within the given radius of the center point of a circle will match, using the curved distance on the surface of the Earth. Points contained within the given polygon will match, using great circle arcs over a spherical model of the Earth as edges. An error may result if the polygon is malformed in some way. Points equal to the a given point will match, taking into account the fact that longitudes converge at the poles. Using the geospatial query constructors requires a valid geospatial license key; without a valid license key, searches that include geospatial queries will throw an exception.

The point value is expressed in the content of the element as a child of numbers, separated by whitespace and punctuation (excluding decimal points and sign characters).

Point values and boundary specifications of boxes are given in degrees relative to the WGS84 coordinate system. Southern latitudes and Western longitudes take negative values. Longitudes will be wrapped to the range (-180,+180) and latitudes will be clipped to the range (-90,+90).

If the northern boundary of a box is south of the southern boundary, no points will match. However, longitudes wrap around the globe, so that if the western boundary is east of the eastern boundary, then the box crosses the anti-meridian.

Special handling occurs at the poles, as all longitudes exist at latitudes +90 and -90.

If neither "cached" nor "uncached" is present, it specifies "cached".

(: create a document with test data :)
xdmp:document-insert("/points.xml",
<root>
  <item><point><pos>10.5 30.0</pos></point></item>
  <item><point><pos>15.35 35.34</pos></point></item>
  <item><point><pos>5.11 40.55</pos></point></item>
</root> );

cts:search(doc("/points.xml")//item,
  cts:element-child-geospatial-query(xs:QName("point"), xs:QName("pos"),
    cts:box(10.0, 35.0, 20.0, 40.0)))
(:
  returns the following node: 
  <item><point><pos>15.35 35.34</pos></point></item>
:)
;

cts:search(doc("/points.xml")//item, 
  cts:element-child-geospatial-query(xs:QName("point"), xs:QName("pos"),
    cts:box(10.0, 40.0, 20.0, 35.0)))
(:
  returns the following nodes (wrapping around the Earth):
  <item><point><pos>10.5 30.0</pos></point></item>
:)
;

cts:search(doc("/points.xml")//item, 
  cts:element-child-geospatial-query(xs:QName("point"), xs:QName("pos"),
    cts:box(20.0, 35.0, 10.0, 40.0)))
(:
  throws an error (latitudes do not wrap)
:)
;

Returns the QNames used to construct the specified query.

let $query := 
   cts:element-child-geospatial-query(xs:QName("point"), xs:QName("pos"),
     cts:box(10.1, 10.2, 20.1, 20.2))
return cts:element-child-geospatial-query-child-name($query)
  => xs:QName("pos")

Returns the QNames used to construct the specified query.

let $query := 
   cts:element-child-geospatial-query(xs:QName("point"), xs:QName("pos"),
     cts:box(10.1, 10.2, 20.1, 20.2))
return cts:element-child-geospatial-query-element-name($query)
  => xs:QName("point")

Returns the options for the specified query.

let $query := 
   cts:element-child-geospatial-query(xs:QName("point"), xs:QName("pos"),
     cts:box(10.1, 10.2, 20.1, 20.2))
return cts:element-child-geospatial-query-options($query)
  => "coordinate-system=wgs84"

Returns the geographical regions with which the specified query was constructed.

let $query := 
   cts:element-child-geospatial-query(xs:QName("point"), xs:QName("pos"),
     cts:box(10.1, 10.2, 20.1, 20.2))
return cts:element-child-geospatial-query-region($query)
  => cts:box(10.1, 10.2, 20.1, 20.2)

Returns the weight with which the specified query was constructed.

let $query := 
   cts:element-child-geospatial-query(xs:QName("point"), xs:QName("pos"),
     cts:box(10.1, 10.2, 20.1, 20.2))
return cts:element-child-geospatial-query-weight($query)
  => 1

Returns a cts:query matching elements by name whose content represents a point contained within the given geographic box, circle, or polygon, or equal to the given point. Points that lie between the southern boundary and the northern boundary of a box, travelling northwards, and between the western boundary and the eastern boundary of the box, travelling eastwards, will match. Points contained within the given radius of the center point of a circle will match, using the curved distance on the surface of the Earth. Points contained within the given polygon will match, using great circle arcs over a spherical model of the Earth as edges. An error may result if the polygon is malformed in some way. Points equal to the a given point will match, taking into account the fact that longitudes converge at the poles. Using the geospatial query constructors requires a valid geospatial license key; without a valid license key, searches that include geospatial queries will throw an exception.

The point value is expressed in the content of the element as a pair of numbers, separated by whitespace and punctuation (excluding decimal points and sign characters).

Point values and boundary specifications of boxes are given in degrees relative to the WGS84 coordinate system. Southern latitudes and Western longitudes take negative values. Longitudes will be wrapped to the range (-180,+180) and latitudes will be clipped to the range (-90,+90).

If the northern boundary of a box is south of the southern boundary, no points will match. However, longitudes wrap around the globe, so that if the western boundary is east of the eastern boundary, then the box crosses the anti-meridian.

Special handling occurs at the poles, as all longitudes exist at latitudes +90 and -90.

If neither "cached" nor "uncached" is present, it specifies "cached".

(: create a document with test data :)
xdmp:document-insert("/points.xml",
<root>
  <item><point>10.5, 30.0</point></item>
  <item><point>15.35, 35.34</point></item>
  <item><point>5.11, 40.55</point></item>
</root> );

cts:search(doc("/points.xml")//item, 
  cts:element-geospatial-query(xs:QName("point"), cts:box(10.0, 35.0, 20.0, 40.0)))
(:
  returns the following node: 
  <item><point>15.35, 35.34</point></item>
:)
;

cts:search(doc("/points.xml")//item, 
  cts:element-geospatial-query(xs:QName("point"), cts:box(10.0, 40.0, 20.0, 35.0)))
(:
  returns the following nodes (wrapping around the Earth):
  <item><point>10.5, 30.0</point></item>
:)
;

cts:search(doc("/points.xml")//item, 
  cts:element-geospatial-query(xs:QName("point"), cts:box(20.0, 35.0, 10.0, 40.0)))
(:
  throws an error (latitudes do not wrap)
:)
;

Returns the QNames used to construct the specified query.

let $query := 
   cts:element-geospatial-query(xs:QName("point"), cts:box(10.1, 10.2, 20.1, 20.2))
return
cts:element-geospatial-query-element-name($query)
  => xs:QName("point")

Returns the options for the specified query.

let $query := 
   cts:element-geospatial-query(xs:QName("point"), cts:box(10.1, 10.2, 20.1, 20.2))
return cts:element-geospatial-query-options($query)
  => "coordinate-system=wgs84"

Returns the geographical regions with which the specified query was constructed.

let $query := 
   cts:element-geospatial-query(xs:QName("point"),
       cts:box(10.1, 10.2, 20.1, 20.2))
return cts:element-geospatial-query-region($query)
  => cts:box(10.1, 10.2, 20.1, 20.2)

Returns the weight with which the specified query was constructed.

let $query := 
   cts:element-geospatial-query(xs:QName("point"), cts:box(10.1, 10.2, 20.1, 20.2))
return cts:element-geospatial-query-weight($query)
  => 1

Returns a cts:query matching elements by name which has specific element children representing latitude and longitude values for a point contained within the given geographic box, circle, or polygon, or equal to the given point. Points that lie between the southern boundary and the northern boundary of a box, travelling northwards, and between the western boundary and the eastern boundary of the box, travelling eastwards, will match. Points contained within the given radius of the center point of a circle will match, using the curved distance on the surface of the Earth. Points contained within the given polygon will match, using great circle arcs over a spherical model of the Earth as edges. An error may result if the polygon is malformed in some way. Points equal to the a given point will match, taking into account the fact that longitudes converge at the poles. Using the geospatial query constructors requires a valid geospatial license key; without a valid license key, searches that include geospatial queries will throw an exception.

The point value is expressed in the content of the element as a pair of numbers, separated by whitespace and punctuation (excluding decimal points and sign characters).

Point values and boundary specifications of boxes are given in degrees relative to the WGS84 coordinate system. Southern latitudes and Western longitudes take negative values. Longitudes will be wrapped to the range (-180,+180) and latitudes will be clipped to the range (-90,+90).

If the northern boundary of a box is south of the southern boundary, no points will match. However, longitudes wrap around the globe, so that if the western boundary is east of the eastern boundary, then the box crosses the anti-meridian.

Special handling occurs at the poles, as all longitudes exist at latitudes +90 and -90.

If neither "cached" nor "uncached" is present, it specifies "cached".

(: create a document with test data :)
xdmp:document-insert("/points.xml",
<root>
  <item><point><lat>10.5</lat><long>30.0</long></point></item>
  <item><point><lat>15.35</lat><long>35.34</long></point></item>
  <item><point><lat>5.11</lat><long>40.55</long></point></item>
</root> );

cts:search(doc("/points.xml")//item, 
  cts:element-pair-geospatial-query(xs:QName("point"), 
    xs:QName("lat"), xs:QName("long"), cts:box(10.0, 35.0, 20.0, 40.0)))
(:
  returns the following node: 
  <item><point><lat>15.35</lat><long>35.34</long></point></item>
:)
;

cts:search(doc("/points.xml")//item, 
  cts:element-pair-geospatial-query(xs:QName("point"), 
    xs:QName("lat"), xs:QName("long"), cts:box(10.0, 40.0, 20.0, 35.0)))
(:
  returns the following nodes (wrapping around the Earth):
  <item><point><lat>10.5</lat><long>30.0</long></point></item>
:)
;

cts:search(doc("/points.xml")//item, 
  cts:element-pair-geospatial-query(xs:QName("point"), 
    xs:QName("lat"), xs:QName("long"), cts:box(20.0, 35.0, 10.0, 40.0)))
(:
  throws an error (latitudes do not wrap)
:)
;

Returns the QNames used to construct the specified query.

let $query := 
   cts:element-pair-geospatial-query(xs:QName("point"), 
     xs:QName("lat"), xs:QName("long"), cts:box(10.1, 10.2, 20.1, 20.2))
return cts:element-pair-geospatial-query-element-name($query)
  => xs:QName("point")

Returns the QNames used to construct the specified query.

let $query := 
   cts:element-pair-geospatial-query(xs:QName("point"), 
     xs:QName("lat"), xs:QName("long"), cts:box(10.1, 10.2, 20.1, 20.2))
return cts:element-pair-geospatial-query-latitude-name($query)
  => xs:QName("lat")

Returns the QNames used to construct the specified query.

let $query := 
   cts:element-pair-geospatial-query(xs:QName("point"), 
     xs:QName("lat"), xs:QName("long"), cts:box(10.1, 10.2, 20.1, 20.2))
return cts:element-pair-geospatial-query-longitude-name($query)
  => xs:QName("lat")

Returns the options for the specified query.

let $query := 
   cts:element-pair-geospatial-query(xs:QName("point"), 
     xs:QName("lat"), xs:QName("long"), cts:box(10.1, 10.2, 20.1, 20.2))
return cts:element-pair-geospatial-query-options($query)
  => "coordinate-system=wgs84"

Returns the geographical regions with which the specified query was constructed.

let $query := 
   cts:element-pair-geospatial-query(xs:QName("point"), 
     xs:QName("lat"), xs:QName("long"), cts:box(10.1, 10.2, 20.1, 20.2))
return cts:element-pair-geospatial-query-region($query)
  => cts:box(10.1, 10.2, 20.1, 20.2)

Returns the weight with which the specified query was constructed.

let $query := 
   cts:element-pair-geospatial-query(xs:QName("point"), 
     xs:QName("lat"), xs:QName("long"), cts:box(10.1, 10.2, 20.1, 20.2))
return cts:element-pair-geospatial-query-weight($query)
  => 1

Returns a cts:query matching elements by name with the content constrained by the given cts:query in the second parameter. Searches for matches in the specified element and all of its descendants. If the specified query in the second parameter has any cts:element-attribute-*-query constructors, it will search attributes directly on the specified element and attributes on any descendant elements (see the second example below).

Enabling both the word position and element position indexes ("word position" and "element word position" in the database configuration screen of the Admin Interface) will speed up query performance for many queries that use cts:element-query. The position indexes enable MarkLogic Server to eliminate many false-positive results, which can reduce disk I/O and processing, thereby speeding the performance of many queries. The amount of benefit will vary depending on your data.

  cts:search(//module,
    cts:element-query(
      xs:QName("function"), 
      "MarkLogic Corporation"))
  

  => .. relevance-ordered sequence of 'module' elements
  ancestors (or self) of elements with QName 'function'
  and text content containing the phrase 'MarkLogic 
  Corporation'.

let $x := <a attr="something">hello</a>
return
cts:contains($x, cts:element-query(xs:QName("a"), 
   cts:and-query((
     cts:element-attribute-word-query(xs:QName("a"), 
         xs:QName("attr"), "something"),
     cts:word-query("hello")))))
(: returns true :)

Returns the QNames used to construct the specified query.

let $query := cts:element-query(
              xs:QName("function"),
              "MarkLogic Corporation")
return cts:element-query-element-name($query)

  => xs:QName("function")

Returns the query used to construct the element query.

let $query := cts:element-query(
                 cts:word-query("wanted"))
return cts:element-query-query($query)
  
  => cts:word-query("wanted", (), 1)

Returns a cts:query matching elements by name with a range-index entry equal a given value. Searches with the cts:element-range-query constructor require an element range index on the specified QName(s); if there is no range index configured, then an exception is thrown.

If you want to constrain on a range of values, you can combine multiple cts:element-range-query constructors together with cts:and-query or any of the other composable cts:query constructors, as in the last part of the example below.

If neither "cached" nor "uncached" is present, it specifies "cached".

Negative "min-occurs" or "max-occurs" values will be treated as 0 and non-integral values will be rounded down. An error will be raised if the "min-occurs" value is greater than the "max-occurs" value.

(: create a document with test data :)
xdmp:document-insert("/dates.xml",
<root>
  <entry>
    <date>2007-01-01</date>
    <info>Some information.</info>
  </entry>
  <entry>
    <date>2006-06-23</date>
    <info>Some other information.</info>
  </entry>
  <entry>
    <date>1971-12-23</date>
    <info>Some different information.</info>
  </entry>
</root>);

(: 
   requires an element (range) index of 
   type xs:date on "date" 
:)
cts:search(doc("/dates.xml")/root/entry, 
  cts:element-range-query(xs:QName("date"), "<=",
      xs:date("2000-01-01")))
(:
  returns the following node: 
  <entry>
    <date>1971-12-23</date>
    <info>Some different information.</info>
  </entry>
:)
;
(: 
   requires an element (range) index of 
   type xs:date on "date" 
:)
cts:search(doc("/dates.xml")/root/entry, 
  cts:and-query((
   cts:element-range-query(xs:QName("date"), ">",
      xs:date("2006-01-01")),
   cts:element-range-query(xs:QName("date"), "<",
      xs:date("2008-01-01")))))
(:
  returns the following 2 nodes: 
  <entry>
    <date>2007-01-01</date>
    <info>Some information.</info>
  </entry>

  <entry>
    <date>2006-06-23</date>
    <info>Some other information.</info>
  </entry>
:)

Returns the QNames used to construct the specified query.

cts:element-range-query-element-name($query)
  => xs:QName("function")

Returns the operator used to construct the specified query.

  cts:element-range-query-operator($query)
  => "<"

Returns the options for the specified query.

  cts:element-range-query-options($query)
  => "collation=http://marklogic.com/collation/"

Returns the value used to construct the specified query.

  cts:element-range-query-value($query)
  => 123

Returns the weight with which the specified query was constructed.

  cts:element-range-query-weight($query)
  => 1

Returns a query matching elements by name with text content equal a given phrase. cts:element-value-query only matches against simple elements (that is, elements that contain only text and have no element children).

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

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

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

If neither "whitespace-sensitive" nor "whitespace-insensitive" is present, the query is "whitespace-insensitive".

If neither "stemmed" nor "unstemmed" is present, the database configuration determines stemming. If the database has "stemmed searches" enabled, it specifies "stemmed". Otherwise it specifies "unstemmed".

If neither "wildcarded" nor "unwildcarded" is present, the database configuration and $text determine wildcarding. If the database has any wildcard indexes enabled ("three character searches", "two character searches", "one character searches", or "trailing wildcard searches") and if $text contains either of the wildcard characters '?' or '*', it specifies "wildcarded". Otherwise it specifies "unwildcarded".

If neither "stemmed" nor "unstemmed" is present, then the database configuration determines if a query is run as "stemmed" (stemmed searches enabled) or "unstemmed" (word searches enabled and stemmed searches disabled). If the query is a wildcard query and is also a phrase query (contains two or more terms), then any wildcard terms in the query will be "unstemmed".

Negative "min-occurs" or "max-occurs" values will be treated as 0 and non-integral values will be rounded down. An error will be raised if the "min-occurs" value is greater than the "max-occurs" value.

Note that the text content for the value in a cts:element-value-query is treated the same as a phrase in a cts:word-query, where the phrase is the element value. Therefore, any wildcard and/or stemming rules are treated like a phrase. For example, if you have an element value of "hello friend" with wildcarding enabled for a query, a cts:element-value-query for "he*" will not match because the wildcard matches do not span word boundaries, but a cts:element-value-query for "hello *" will match. A search for "*" will match, because a "*" wildcard by itself is defined to match the value. Similarly, stemming rules are applied to each term, so a search for "hello friends" would match when stemming is enabled for the query because "friends" matches "friend". For an example, see the fourth example below.

Similarly, because a "*" wildcard by itself is defined to match the value, the following query will match any element with the QName my-element, regardless of the wildcard indexes enabled in the database configuration:

cts:element-value-query(xs:QName("my-element"), "*", "wildcarded")

  cts:search(//module,
    cts:element-value-query(
      xs:QName("function"), 
      "MarkLogic Corporation"))
  

  => .. relevance-ordered sequence of 'module' element
  ancestors of 'function' elements whose text
  content equals 'MarkLogic Corporation'.

  cts:search(//module,
    cts:element-value-query(
      xs:QName("function"), 
      "MarkLogic Corporation", "case-insensitive"))
  

  => .. relevance-ordered sequence of 'module' element
  ancestors of 'function' elements whose text
  content equals 'MarkLogic Corporation', or any other 
  case-shift like 'MARKLOGIC CorpoRation'.

  cts:search(//module,
    cts:and-query((
      cts:element-value-query(
        xs:QName("function"), 
        "MarkLogic Corporation",
        "punctuation-insensitive", 0.5),
      cts:element-value-query(
        xs:QName("title"),
        "Word Query"))))
  => .. relevance-ordered sequence of 'module' elements
  which are ancestors of both:
  (a) 'function' elements with text content equal to
      'MarkLogic Corporation', ignoring embedded 
      punctuation,
  AND
  (b) 'title' elements with text content equal to 
      'Word Query', with the results of the first sub-query
      query given weight 0.5, and the results of the second
      sub-query given the default weight 1.0.  As a result,
      the title phrase 'Word Query' counts more heavily
      towards the relevance score.

let $node := <my-node>hello friend</my-node>
return (
cts:contains($node, cts:element-value-query(xs:QName('my-node'), 
      "hello friends", "stemmed")),
cts:contains($node, cts:element-value-query(xs:QName('my-node'), 
      "he*", "wildcarded")),
cts:contains($node, cts:element-value-query(xs:QName('my-node'), 
      "hello f*", "wildcarded"))
)

=> true
   false
   true

Returns the QNames used to construct the specified query.

let $query := cts:element-value-query(
              xs:QName("function"),
              "MarkLogic Corporation")
return cts:element-value-query-element-name($query)

  => xs:QName("function")

Returns the options for the specified query.

  cts:element-value-query-options($query)
  => ("case-sensitive", "punctuation-insensitive")

Returns the text used to construct the specified query.

  cts:element-value-query-text($query)
  => "choice of law"

Returns the weight with which the specified query was constructed.

  cts:element-value-query-weight($query)
  => 1

Returns a query matching elements by name with text content containing a given phrase. Searches only through 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; does not search through any other children of the specified element.

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

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

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

If neither "whitespace-sensitive" nor "whitespace-insensitive" is present, the query is "whitespace-insensitive".

If neither "stemmed" nor "unstemmed" is present, the database configuration determines stemming. If the database has "stemmed searches" enabled, it specifies "stemmed". Otherwise it specifies "unstemmed".

If neither "wildcarded" nor "unwildcarded" is present, the database configuration and $text determine wildcarding. If the database has any wildcard indexes enabled ("three character searches", "two character searches", "one character searches", or "trailing wildcard searches") and if $text contains either of the wildcard characters '?' or '*', it specifies "wildcarded". Otherwise it specifies "unwildcarded".

If neither "stemmed" nor "unstemmed" is present, then the database configuration determines if a query is run as "stemmed" (stemmed searches enabled) or "unstemmed" (word searches enabled and stemmed searches disabled). If the query is a wildcard query and is also a phrase query (contains two or more terms), then any wildcard terms in the query will be "unstemmed".

Negative "min-occurs" or "max-occurs" values will be treated as 0 and non-integral values will be rounded down. An error will be raised if the "min-occurs" value is greater than the "max-occurs" value.

Relevance adjustment for the "distance-weight" option depends on the closest proximity of any two matches of the query. For example,

  cts:element-word-query(xs:QName("p"),("dog","cat"),("distance-weight=10"))
  

will adjust relevance based on the distance between the closest pair of matches of either "dog" or "cat" within an element named "p" (the pair may consist only of matches of "dog", only of matches of "cat", or a match of "dog" and a match of "cat").

  cts:search(//module,
    cts:element-word-query(
      xs:QName("function"), 
      "MarkLogic Corporation"))
  

  => .. relevance-ordered sequence of 'module' elements
  ancestors (or self) of elements with QName 'function'
  and text content containing the phrase 'MarkLogic 
  Corporation'.

  cts:search(//module,
    cts:element-word-query(
      xs:QName("function"), 
        "MarkLogic Corporation", "case-sensitive"))
  

  => .. relevance-ordered sequence of 'module' elements
  ancestors (or self) of elements with QName 'function'
  and text content containing the phrase 'MarkLogic 
  Corporation',
  or any other case-shift, like 'MarkLogic Corporation'.

  cts:search(//module,
    cts:and-query((
      cts:element-word-query(
        xs:QName("function"), 
        "MarkLogic Corporation",
        ("case-insensitive", "punctuation-insensitive"), 0.5),
      cts:element-word-query(
        xs:QName("title"), 
        "faster"))))
  

  => .. relevance-ordered sequence of 'module' element
  ancestors (or self) of both:
  (a) 'function' elements with text content containing
      the phrase 'MarkLogic Corporation', ignoring embedded 
      punctuation,
  AND
  (b) 'title' elements containing the word 'faster',
      with the results of the first sub-query query given
      weight 0.5, and the results of the second sub-query
      given the default weight 1.0.  As a result, the title
      term 'faster' counts more towards the relevance 
      score.

Returns the QNames used to construct the specified query.

let $query := cts:element-word-query(
              xs:QName("function"),
              "MarkLogic Corporation")
return cts:element-word-query-element-name($query)

  => xs:QName("function")

Returns the options for the specified query.

  cts:element-word-query-options($query)
  => ("case-sensitive", "punctuation-insensitive")

Returns the text used to construct the specified query.

  cts:element-word-query-text($query)
  => "choice of law"

Returns the weight with which the specified query was constructed.

  cts:element-word-query-weight($query)
  => 1

Returns a cts:query matching fields by name with a range-index entry equal a given value. Searches with the cts:field-range-query constructor require a field range index on the specified field name(s); if there is no range index configured, then an exception is thrown.

If you want to constrain on a range of values, you can combine multiple cts:field-range-query constructors together with cts:and-query or any of the other composable cts:query constructors.

If neither "cached" nor "uncached" is present, it specifies "cached".

Negative "min-occurs" or "max-occurs" values will be treated as 0 and non-integral values will be rounded down. An error will be raised if the "min-occurs" value is greater than the "max-occurs" value.

(: Insert few documents with test data :)
let $content1 :=  <name><fname>John</fname><mname>Rob</mname><lname>Goldings</lname></name>
let $content2 :=  <name><fname>Jim</fname><mname>Ken</mname><lname>Kurla</lname></name>
let $content3 :=  <name><fname>Ooi</fname><mname>Ben</mname><lname>Fu</lname></name>
let $content4 :=  <name><fname>James</fname><mname>Rick</mname><lname>Tod</lname></name>
return (
xdmp:document-insert("/aname1.xml",$content1),
xdmp:document-insert("/aname2.xml",$content2),
xdmp:document-insert("/aname3.xml",$content3),
xdmp:document-insert("/aname4.xml",$content4));

(: 
   requires a field (range) index of 
   type xs:string on field "aname" 
:)

(:
  returns the following: 
<?xml version="1.0" encoding="UTF-8"?>
<name><fname>John</fname><mname>Rob</mname><lname>Goldings</lname></name>
<?xml version="1.0" encoding="UTF-8"?>
<name><fname>Ooi</fname><mname>Ben</mname><lname>Fu</lname></name>
:)
;
(: 
   requires an element (range) index of 
   type xs:string on "aname" 
:)
cts:contains(doc(),cts:field-range-query("aname",">","Jim Kurla"))
(:
  returns "true".
:)

Returns the fieldname used to construct the specified query.

cts:field-range-query-field-name($query)
  => xs:QName("function")

Returns the operator used to construct the specified query.

  cts:field-range-query-operator($query)
  => "<"

Returns the options for the specified query.

  cts:field-range-query-options($query)
  => "collation=http://marklogic.com/collation/"

Returns the value used to construct the specified query.

  cts:field-range-query-value($query)
  => 123

Returns the weight with which the specified query was constructed.

  cts:field-range-query-weight($query)
  => 1

Returns a query matching text content containing a given value in the specified field. If the specified field does not exist, cts:field-value-query throws an exception. If the specified field does have the index setting field value searches enabled, either for the database or for the specified field, then a cts:search with a cts:field-value-query throws an exception. A field is a named object that specified elements to include and exclude from a search, and can include score weights for any included elements. You create fields at the database level using the Admin Interface. For details on fields, see the chapter on "Fields Database Settings" in the Administrator's Guide.

If you use cts:near-query with cts:field-value-query, the distance supplied in the near query applies to the whole document, not just to the field. For example, if you specify a near query with a distance of 3, it will return matches when the values are within 3 words in the whole document, For a code example illustrating this, see the second example below.

Values are determined based on words (tokens)of values of elements that are included in the field. Field values span all the included elements. They cannot span excluded elements (this is because MarkLogic Server breaks out of the field when it encounters the excluded element and start it again field when it encounters the next included element). Field values will also span included sibling elements.

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

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

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

If neither "whitespace-sensitive" nor "whitespace-insensitive" is present, the query is "whitespace-insensitive".

If neither "stemmed" nor "unstemmed" is present, the database configuration determines stemming. If the database has "stemmed searches" enabled, it specifies "stemmed". Otherwise it specifies "unstemmed".

If neither "wildcarded" nor "unwildcarded" is present, the database configuration and $text determine wildcarding. If the database has any wildcard indexes enabled ("three character searches", "two character searches", "one character searches", or "trailing wildcard searches") and if $text contains either of the wildcard characters '?' or '*', it specifies "wildcarded". Otherwise it specifies "unwildcarded".

If neither "stemmed" nor "unstemmed" is present, then the database configuration determines if a query is run as "stemmed" (stemmed searches enabled) or "unstemmed" (word searches enabled and stemmed searches disabled). If the query is a wildcard query and is also a phrase query (contains two or more terms), then any wildcard terms in the query will be "unstemmed".

Negative "min-occurs" or "max-occurs" values will be treated as 0 and non-integral values will be rounded down. An error will be raised if the "min-occurs" value is greater than the "max-occurs" value.

let $contents := <Employee><name><fname>Jaz</fname><mname>Roy</mname><lname>Smith</lname></name></Employee>
return
cts:contains($contents,cts:field-value-query("myField","Jaz Roy Smith"))

=> check if the filed myField has a value matching to "Jaz Roy Smith"
in node $contents. The field must exist in the database against which 
this query is evaluated. "myField" in thic case includes element "name" and excludes "mname". This expression returns false.

let $contents := <Employee><name><fname>Jaz</fname><mname>Roy</mname><lname>Smith</lname></name></Employee>
return
cts:contains($contents,cts:field-value-query("myField","Jaz Smith"))

=> Returns true.

In this query, the search is fully resolved in the index.

cts:search(fn:doc("/Employee/jaz.xml"),cts:field-value-query("myField","Jaz Smith"),"unfiltered")

=> Returns the doc which has field "myField" and a match with the value of the field.

Returns the names used to construct the specified cts:field-value-query.

let $query := cts:field-value-query(
                "function",
                "MarkLogic Corporation")
return 
cts:field-value-query-field-name($query)

  => "function"

Returns the options for the specified cts:field-value-query.

let $query := cts:field-value-query("myField",
      "to be or not to be",
      ("case-sensitive", "punctuation-insensitive"))
return
cts:field-value-query-options($query)
  => ("case-sensitive", "punctuation-insensitive", "lang=en")

Returns the text used to construct the specified cts:field-value-query.

let $query := cts:field-value-query("myField", "choice of law")
return
cts:field-value-query-text($query)

=> "choice of law"

Returns the weight with which the specified query was constructed.

  cts:field-value-query-weight($query)
  => 1

Returns a query matching text content containing a given phrase in the specified field. If the specified field does not exist, cts:field-word-query throws an exception. A field is a named object that specified elements to include and exclude from a search, and can include score weights for any included elements. You create fields at the database level using the Admin Interface. For details on fields, see the chapter on "Fields Database Settings" in the Administrator's Guide.

If you use cts:near-query with cts:field-word-query, the distance supplied in the near query applies to the whole document, not just to the field. For example, if you specify a near query with a distance of 3, it will return matches when the words or phrases are within 3 words in the whole document, even if some of those words are not in the specified field. For a code example illustrating this, see the second example below.

Phrases are determined based on words being next to each other (word positions with a distance of 1) and words being in the same instance of the field. Because field word positions are determined based on the fragment, not on the field, field phrases cannot span excluded elements (this is because MarkLogic Server breaks out of the field when it encounters the excluded element and start a new field when it encounters the next included element). Similarly, field phrases will not span included sibling elements. The second code example below illustrates this.

Field phrases will automatically phrase-through all child elements of an included element, until it encounters an explicitly excluded element. The third example below illustrates this. An example of when this automatic phrase-through behavior might be convenient is if you create a field that includes only the element ABSTRACT. Then all child elements of ABSTRACT are included in the field, and phrases would span all of the child elements (that is, phrases would "phrase-through" all the child elements).

Negative "min-occurs" or "max-occurs" values will be treated as 0 and non-integral values will be rounded down. An error will be raised if the "min-occurs" value is greater than the "max-occurs" value.

cts:search(fn:doc(), cts:field-word-query("myField", "my phrase"))

=> a list of documents that contain the phrase
   "my phrase" in the field "myField". The field
   must exist in the database against which this query
   is evaluated.

(: 
   Assume the database has a field named 
   "buzz" with the element "buzz"
   included and the element "baz" excluded. 
:)
let $x := 
<hello>word1 word2 word3
  <buzz>word4 word5</buzz>
  <baz>word6 word7 word8</baz>
  <buzz>word9 word10</buzz>
</hello>
return (
cts:contains($x, cts:near-query(
  (cts:field-word-query("buzz", "word5"), 
   cts:field-word-query("buzz", "word9")), 3)),
cts:contains($x, cts:near-query(
  (cts:field-word-query("buzz", "word5"), 
   cts:field-word-query("buzz", "word9")), 4)),
cts:contains($x, 
  cts:field-word-query("buzz", "word5 word9")))
(: 
   Returns the sequence ("false", "true", "false").
   The first part does not match because 
   the distance between "word5" and "word9" 
   is 4.  This is because the distance is 
   calculated based on the whole node (if the
   document was in a database, based on the 
   fragment), not based on the field. The 
   second part specifies a distance of 4, and 
   therefore matches and returns true. The third 
   part does not match because the phrase is 
   based on the entire node, not on the field, 
   and there are words between "word5" and "word9" 
   in the node (even though not in the field).
:)

(: 
   Assume the database has a field named 
   "buzz" with the element "buzz"
   included and the element "baz" excluded. 
:)
let $x := 
<hello>
  <buzz>word1 word2
    <gads>word3 word4 word5</gads>
    <zukes>word6 word7 word8</zukes>
  word9 word10
  </buzz>
</hello>
return (
cts:contains($x, 
  cts:field-word-query("buzz", "word2 word3")))
(: 
   Returns "true" because the children of
   "buzz" are not excluded, and are therefore
   automatically phrased through.
:)

Returns the names used to construct the specified cts:field-word-query.

let $query := cts:field-word-query(
                "function",
                "MarkLogic Corporation")
return 
cts:field-word-query-field-name($query)

  => "function"

Returns the options for the specified cts:field-word-query.

let $query := cts:field-word-query("myField",
      "to be or not to be",
      ("case-sensitive", "punctuation-insensitive"))
return
cts:field-word-query-options($query)
  => ("case-sensitive", "punctuation-insensitive", "lang=en")

Returns the text used to construct the specified cts:field-word-query.

let $query := cts:field-word-query("myField", "choice of law")
return
cts:field-word-query-text($query)

=> "choice of law"

Returns the weight with which the specified query was constructed.

  cts:field-word-query-weight($query)
  => 1

Returns a query that matches all documents where $query matches document-locks. When searching documents or document-properties, cts:locks-query provides a convenient way to additionally constrain the search against document-locks fragments.