Returns a sequence of nodes based on the input object. If the input is a sequence of nodes, it is returned as it is. If it is a node, it is simply returned as a singleton sequence. For all other atomic types, a text node is returned based on the string-value of the type. This was a useful function in XSLT 1.0 where "Result Tree Fragments" are returned as a result of xslt instruction. In XSLT 2.0, however, xslt instructions return sequences. This function is simply being provided for backward compatibility to existing applications.

This function is based on the EXSLT functions (http://www.exslt.org/).

xquery version "1.0-ml";

xdmp:xslt-eval(
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
                   xmlns:exsl="http://exslt.org/common"
                   extension-element-prefixes="exsl"
                   version="2.0">
     <xsl:template match="/">
       <xsl:value-of select="count(exsl:node-set(//element()))" />
     </xsl:template>
   </xsl:stylesheet>
,
document{
 <doc>
   <one />
   <two />
   <three />
   <four />
</doc>})
  
=> 5
 

Returns a string that contains the type-name of the object passed as the argument.

This function is based on the EXSLT functions (http://www.exslt.org/).

xquery version "1.0-ml";

xdmp:xslt-eval(
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
                   xmlns:exsl="http://exslt.org/common"
                   extension-element-prefixes="exsl"
                   version="2.0">
     <xsl:variable name="string" select="'fred'" />
     <xsl:variable name="number" select="93.7" />
     <xsl:variable name="boolean" select="true()" />
     <xsl:variable name="node-set" select="//element()" />
     <xsl:template match="/">
        ;
        <xsl:value-of select="exsl:object-type($string)" />;
        <xsl:value-of select="exsl:object-type($number)" />;  
        <xsl:value-of select="exsl:object-type($boolean)" />;  
        <xsl:value-of select="exsl:object-type($node-set)" />
     </xsl:template>
   </xsl:stylesheet>
,
document{<doc/>})
 
=>
     ;
     string;
     number;  
     boolean;  
     node-set
 

Returns whether a given action on the specified document URI would succeed.

  xdmp:access(
         "http://example.com/foo.xml",
         "create")
   => true()

Add two 64-bit integer values, discarding overflow.

  xdmp:add64(11442580934957149475,14565934789622151058)
  => 7561771650869748917

AND two 64-bit integer values.

  xdmp:and64(255, 2)
   => 2

Applies an xdmp:function with the given parameters.

  let $function := xdmp:function(xs:QName("fn:empty"))
  return
    xdmp:apply($function, ())

  => true

  let $function := xdmp:function(xs:QName("fn:concat"))
  return
    xdmp:apply($function, "hello", " world")

  => hello world

  let $function := xdmp:function(xs:QName("fn:current-date"))
  return
    xdmp:apply($function)

  => 2009-02-14-08:00  (or whatever is the current date)

Returns the hardware architecture upon which MarkLogic Server is running. If xdmp:platform() returns "linux", it will return "x86_64" or "i686. If xdmp:platform() returns "solaris", it will return "amd64" or "sparcv9". If xdmp:platform() returns "winnt", it will return "amd64" or "i686". If xdmp:platform() returns "macosx", it will return "x86_64".

  xdmp:architecture()
   => "amd64"

Converts base64-encoded string to plaintext.

xdmp:base64-decode(
     "c2xpbmdzIGFuZCBhcnJvd3Mgb2Ygb3V0cmFnZW91cyBmb3J0dW5l")
=> slings and arrows of outrageous fortune

Converts plaintext into base64-encoded string.

  xdmp:base64-encode("slings and arrows of outrageous fortune")
   => c2xpbmdzIGFuZCBhcnJvd3Mgb2Ygb3V0cmFnZW91cyBmb3J0dW5l

Converts an encoded byte sequence, passed in as a binary node, from the specified encoding to a unicode string.

xdmp:binary-decode(
   fn:doc("binary_doc_encoded_as_ShiftJIS.dat")/node(),
          "sjis")
=> contents of document after decoding, in unicode characters

Returns true if a value is castable. This is similar to the "castable as" XQuery predicate, except that the type is determined at runtime.

  xdmp:castable-as(
    "http://www.w3.org/2001/XMLSchema",
    "integer",
    "12")
    => true()

Returns the canonical URI for the given URI, if it represents a valid collation. A canonical URI is the unique string MarkLogic Server uses to identify a given collation. The canonical URI string places any attributes that occur in the URI in a predefined order, and it removes any attributes that are redundant due to locale defaults.

If the specified collation URI is not a valid URI, an exception is thrown.

xdmp:collation-canonical-uri("http://marklogic.com/collation/en/S3") 
=> http://marklogic.com/collation/en

Returns locks of documents in a collection.

  for $d in xdmp:collection-locks(
                     ("http://example.com/col1/",
                      "http://example.com/col2/"))
  return xdmp:node-uri($d)
  => http://example.com/bar.xml 
     http://example.com/baz.xml

Returns a sequence of properties documents, one for each document in the specified collection(s) that has a corresponding properties document.

  xquery version "0.9-ml"
  declare namespace cpf="http://marklogic.com/cpf"

  for $d in xdmp:collection-properties(
                   ("http://example.com/col1/",
                    "http://example.com/col2/"))
  where $d/property::cpf:error
  return xdmp:node-uri($d)

  => A list of document URIs of documents that have a 
        cpf:error property in their corresponding properties 
	documents.  For example:

      http://example.com/bar.xml http://example.com/baz.xml

Calculates the password hash for the given password and salt.

You typically use the username as the salt, which ensures that no two hash values will be the same, even if different users have the same password.

  xdmp:crypt("123abc","admin")
  => "arQEnpM6JHR8vY4n3e5gr0"
 

Returns the size of the current node list.

This function is only available in XSLT; it is not available in XQuery.

xquery version "1.0-ml";

xdmp:xslt-eval(
<xsl:stylesheet version="2.0"
  xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
  xmlns:xdmp="http://marklogic.com/xdmp">
 <xsl:template match="foo">
   <xsl:value-of select="xdmp:current-last()"/>
 </xsl:template>
</xsl:stylesheet>,
document{<foo>
           <a>hello</a>
           <b>there</b>
         </foo>})


=> 1

Returns the position of the current item.

This function is only available in XSLT; it is not available in XQuery.

xquery version "1.0-ml";

xdmp:xslt-eval(
<xsl:stylesheet version="2.0"
  xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
  xmlns:xdmp="http://marklogic.com/xdmp">
 <xsl:template match="/">
   <xsl:value-of select="xdmp:current-position()"/>
 </xsl:template>
</xsl:stylesheet>,
document{<foo>hello there</foo>})

=> 1

Returns the the ID of the database named in the the parameter. Returns the ID of the current database if no parameter is specified.

  xdmp:database("myDB")
  => 74495681647284736476

Returns a sequence of forest IDs in the specified database.

  xdmp:database-forests(xdmp:database("Documents"))
  => (8456374036761185098, 10615125154705099114)

Return the name of the database with the given ID.

xdmp:database-name(8456374036761185098)
=> "Documents"

Returns a sequence of the IDs of all the databases in the system.

  xdmp:databases()
   => (14389140626518478220,
          8456374036761185098,
	  10615125154705099114)

Returns a string representing the description of a given item sequence. If you take the output of the xdmp:describe function and evaluate it as an XQuery program, it returns the item(s) input to the function.

If you specify an item that is in a database, xdmp:describe returns the path to the item (or to the items if you specify multiple items). If the item or items are constructed in XQuery, then it prints out the item, truncating the characters in each item according to the maxItemLength parameter.

  xdmp:describe(current-date())

  => xs:date("2007-01-15-08:00")

  let $x := <mynode>Some text here.</mynode>
  return
  xdmp:describe($x)

  => <mynode>Some text here.</mynode>

  (:  assume mydoc.xml is an XML document with
      the following content:
      <mynode>Some text here.</mynode> :)
  xdmp:describe(doc("mydoc.xml")/mynode)

  => doc("mydoc.xml")/mynode

Returns the specified string, converting all of the characters with diacritics to characters without diacritics.

xdmp:diacritic-less("José")
=> Jose 

Returns the documents in a directory.

  for $d in xdmp:directory("http://example.com/foo/","1")
  return xdmp:node-uri($d)
  => http://example.com/foo/bar.xml 
     http://example.com/foo/baz.xml

Returns locks of documents in a directory.

  for $d in xdmp:directory-locks("http://example.com/foo/","1")
  return xdmp:node-uri($d)
  => http://example.com/foo/bar.xml 
     http://example.com/foo/baz.xml

Returns a sequence of properties documents, one for each document in the specified directory that has a corresponding properties document.

  xdmp:directory-properties("http://example.com/dir/","1")
  => <prop:properties 
            xmlns:prop="http://marklogic.com/xdmp/property">
         <prop:directory/>
     </prop:properties>
   

The properties document returned has one directory element, indicating that there is a single directory that is an immediate child of the specified directory.

Returns the forest ID of the forest in which a document (or a lock or a property) with the specified URI is stored. Otherwise, returns the empty sequence.

  xdmp:document-forest("example.xml")
  => 12972338785465832200

Returns the document in the file specified by $location.

http://marklogic.com/xdmp/privileges/xdmp-document-get

If no format is specified in $options, and the document is from an HTTP server, the format is specified by the document content type from the HTTP response. If no format is specified in $options, and the document is from the filesystem, the format is specified by the document content type from the filename extension. The mimetype extensions and corresponding content types are set in the Admin Interface.

If no repair option is specified, the default is specified by the XQuery version of the caller. In XQuery version 1.0 and 1.0-ml the default is <repair>none</repair>. In XQuery version 0.9-ml the default is <repair>full</repair>.

When the document is from an HTTP server, xdmp:document-get will always return the response from the HTTP server, even if it is an error response such as 404 or 500. If you want to be able to examine the response header in your application, use the xdmp:http-get instead, which returns both the response header and the response.

  xdmp:document-get("myDocument.xml")
  => the xml contained in myDocument.xml, 
        for example, <myDocument/>

  xdmp:document-get("myDocument.html", 
       <options xmlns="xdmp:document-get">
           <repair>full</repair>
       </options>)
  => myDocument.html as an XML document that has gone 
     through any needed tag repair

  xdmp:document-get("http://myCompany.com/file.xml", 
       <options xmlns="xdmp:document-get"
                xmlns:http="xdmp:http">
           <format>xml</format>
           <http:authentication>
	      <http:username>user</http:username>
	      <http:password>pass</http:password>
	   </http:authentication>
       </options>)
  => gets an XML document named file.xml, sending the 
     authentication credentials user/pass to the 
     http://myCompany.com server
  

Returns the collections to which a given document belongs.

  xdmp:document-get-collections("chapter5.xml")
  =>("http://marklogic.com/all-books", 
        "http://marklogic.com/xml-books")

Returns the property values for a document's property.

  xdmp:document-get-properties(
         "http://example.com/foo.xml",
         fn:QName("http://examples.com/","priority"))
   => <priority xmlns="http://examples.com/">5</priority>

Returns the quality of the specified document if the document exists. Otherwise, returns the empty sequence.

  xdmp:document-get-quality("example.xml")
  => 10

Returns the locks for one or more documents or directories. Returns the locks for all documents and directories in the database if no parameter is given.

xdmp:document-locks("example.xml")
=>
<?xml version="1.0" encoding="ASCII"?>
<lock:lock xmlns:lock="http://marklogic.com/xdmp/lock">
  <lock:lock-type>write</lock:lock-type>
  <lock:lock-scope>exclusive</lock:lock-scope>
  <lock:active-locks>
    <lock:active-lock>
      <lock:depth>0</lock:depth>
      <lock:owner>
        <DAV:href xmlns:DAV="DAV:">http://example.com/~user</DAV:href>
      </lock:owner>
      <lock:timeout>120</lock:timeout>
      <lock:lock-token>http://marklogic.com/xdmp/locks/1c267a036b8480c3
      </lock:lock-token>
      <lock:timestamp>1290136652</lock:timestamp>
      <sec:user-id xmlns:sec="http://marklogic.com/xdmp/security">
        893641342095093063</sec:user-id>
    </lock:active-lock>
  </lock:active-locks>
</lock:lock>

xquery version "1.0-ml";

(: 
   The time is in epoch time, which is seconds from the start 
   of 1970, so this code does a little math on the values in 
   the lock document to figure out how many seconds are left 
   for the lock.  Assumes a lock on /example.xml, for example 
   by running the following:

xquery version "1.0-ml";
declare namespace DAV="DAV:";

xdmp:lock-acquire("/example.xml", 
           "exclusive",
           "0",
           <DAV:href>http://example.com/~user</DAV:href>,
           xs:unsignedLong(120))
   
:)
let $lock := xdmp:document-locks("/example.xml")
let $lock-duration := 
   $lock/lock:lock/lock:active-locks/lock:active-lock/
         lock:timeout/fn:data(.)
let $current-epoch-time := 
 fn:round(
  ( fn:current-dateTime() - xs:dateTime("1970-01-01T00:00:00-00:00") )
  div xs:dayTimeDuration('PT1S') ) 
let $start-time := 
  $lock/lock:lock/lock:active-locks/lock:active-lock/
        lock:timestamp/fn:data(.)
let $end-time := $start-time + $lock-duration
let $seconds-left := $end-time - $current-epoch-time
return 
 ($current-epoch-time, $start-time, $seconds-left)
=>
1290136837
1290136832
115

Returns a sequence of properties documents, one for each of the specified documents that has a corresponding properties document. If no documents are specified, returns a sequence of properties documents for all documents in the database that have a corresponding properties document.

  xdmp:document-properties("/mydoc.xml")
  =>
<prop:properties xmlns:prop="http://marklogic.com/xdmp/property">
  <cpf:processing-status xmlns:cpf="http://marklogic.com/cpf">done
    </cpf:processing-status>
  <cpf:last-updated xmlns:cpf="http://marklogic.com/cpf">
    2010-05-24T16:28:11.577608-07:00</cpf:last-updated>
  <cpf:state xmlns:cpf="http://marklogic.com/cpf">
    http://marklogic.com/states/final</cpf:state>
  <prop:last-modified>2010-05-24T16:29:58-07:00</prop:last-modified>
</prop:properties>

  xdmp:document-properties()
    => 
    <prop:properties 
          xmlns:prop="http://marklogic.com/xdmp/property">
    Property Node1
    </prop:properties>
    <prop:properties 
          xmlns:prop="http://marklogic.com/xdmp/property">
    Property Node2
    </prop:properties>
    <prop:properties 
          xmlns:prop="http://marklogic.com/xdmp/property">
    Property NodeN
    </prop:properties>

Returns the elapsed time since the start of processing of this query. Gives the same information as the elapsed-time element of the xdmp:query-meters output, but has less overhead than calling xdmp:query-meters.

Certain operations are run concurrently with the timing operations, and if those operations are not actually used in the query, they might not be included in the timings. This occurs for operations like xdmp:estimate, xdmp:exists, and lexicon calls (for example, cts:element-values). If you want to see the total timings that include calls that are not used, you can form some other expression with the results of the calls. For example, if you have an expression that calls xdmp:estimate in a let expression, you can add 0 to the output, which causes it to be included in the timings (something like xdmp:estimate($query) + 0).

xquery version "1.0-ml";

fn:count(collection()),
xdmp:elapsed-time()

=> The count of the number of documents in the database followed by
   the elapsed-time of the query:

   153
   PT0.04S

Returns the schema-defined content-type of an element ("empty", "simple", "element-only", or "mixed").

  xdmp:element-content-type(<html xmlns="http://www.w3.org/1999/xhtml"/>)
  => "element-only"

Send an email in an XQuery program. A valid SMTP Relay must be configured in the Groups page of the Admin Interface for the email to be sent. The format of the email message must be an XML file that complies with the schema files listed below.

http://marklogic.com/xdmp/privileges/xdmp-email

This example demonstrates sending a message with 
HTML content.
   
xdmp:email(
<em:Message 
 xmlns:em="URN:ietf:params:email-xml:" 
 xmlns:rf="URN:ietf:params:rfc822:">
  <rf:subject>Sample HTML Email</rf:subject>
  <rf:from>
    <em:Address>
      <em:name>MarkLogic</em:name>
      <em:adrs>marklogic@yourdomain</em:adrs>
    </em:Address>
  </rf:from>
  <rf:to>
    <em:Address>
      <em:name>System Administrator</em:name>
      <em:adrs>admin@yourdomain</em:adrs>
    </em:Address>
  </rf:to>
  <em:content>
    <html xmlns="http://www.w3.org/1999/xhtml"> 
      <head>
        <title>Test HTML message</title>
      </head>
      <body>
        <h1>Test HTML message</h1>
        <p>Here is a simple paragraph</p>
      </body> 
    </html>
  </em:content>
</em:Message>)

This example demonstrate sending a message with 
plain text content. 

xdmp:email(
<em:Message 
 xmlns:em="URN:ietf:params:email-xml:" 
 xmlns:rf="URN:ietf:params:rfc822:">
  <rf:subject>Sample Plain Text Email</rf:subject>
  <rf:from>
    <em:Address>
      <em:name>MarkLogic</em:name>
      <em:adrs>marklogic@yourdomain</em:adrs>
    </em:Address>
  </rf:from>
  <rf:to>
    <em:Address>
      <em:name>System Administrator</em:name>
      <em:adrs>admin@yourdomain</em:adrs>
    </em:Address>
  </rf:to>
  <em:content xml:space="preserve">
This is a sample email with a plain text body.
</em:content>
</em:Message>)

Analyzes binary, text, or XML data and suggests possible pairs of encoding and language, with a confidence score for each pair. Scores of 10 and above are high confidence recommendations. The results are given in order of decreasing score. Accuracy may be poor for short documents.

If the input is very small (for example, less than two words), then xdmp:encoding-language-detect returns the empty sequence.

For best results, the input should be at least several hundred bytes.

xdmp:encoding-language-detect(xdmp:document-get("/tmp/unknown.dat"))
=>
<encoding-language xmlns="xdmp:encoding-language-detect">
  <encoding>windows-1252</encoding>
  <language>en</language>
  <score>9.834</score>
</encoding-language>
<encoding-language xmlns="xdmp:encoding-language-detect">
  <encoding>windows-1252</encoding>
  <language>it</language>
  <score>8.976</score>
</encoding-language>
<encoding-language xmlns="xdmp:encoding-language-detect">
  <encoding>windows-1250</encoding>
  <language>sl</language>
  <score>8.265</score>
</encoding-language>
<encoding-language xmlns="xdmp:encoding-language-detect">
  <encoding>windows-1250</encoding>
  <language>ro</language>
  <score>7.975</score>
</encoding-language>
<encoding-language xmlns="xdmp:encoding-language-detect">
  <encoding>windows-1252</encoding>
  <language>fr</language>
  <score>7.933</score>
</encoding-language>
<encoding-language xmlns="xdmp:encoding-language-detect">
  <encoding>windows-1252</encoding>
  <language>da</language>
  <score>7.656</score>
</encoding-language>
<encoding-language xmlns="xdmp:encoding-language-detect">
  <encoding>windows-1252</encoding>
  <language>nb</language>
  <score>7.603</score>
</encoding-language>
<encoding-language xmlns="xdmp:encoding-language-detect">
  <encoding>windows-1252</encoding>
  <language>nl</language>
  <score>7.331</score>
</encoding-language>
<encoding-language xmlns="xdmp:encoding-language-detect">
  <encoding>windows-1252</encoding>
  <language>es</language>
  <score>7.167</score>
</encoding-language>
<encoding-language xmlns="xdmp:encoding-language-detect">
  <encoding>windows-1252</encoding>
  <language>ca</language>
  <score>7.143</score>
</encoding-language>
<encoding-language xmlns="xdmp:encoding-language-detect">
  <encoding>windows-1252</encoding>
  <language>de</language>
  <score>6.605</score>
</encoding-language>
<encoding-language xmlns="xdmp:encoding-language-detect">
  <encoding>windows-1250</encoding>
  <language>sr</language>
  <score>6.595</score>
</encoding-language>
<encoding-language xmlns="xdmp:encoding-language-detect">
  <encoding>windows-1250</encoding>
  <language>sk</language>
  <score>6.455</score>
</encoding-language>
<encoding-language xmlns="xdmp:encoding-language-detect">
  <encoding>windows-1250</encoding>
  <language>cs</language>
  <score>6.438</score>
</encoding-language>
<encoding-language xmlns="xdmp:encoding-language-detect">
  <encoding>windows-1252</encoding>
  <language>nn</language>
  <score>6.337</score>
</encoding-language>
<encoding-language xmlns="xdmp:encoding-language-detect">
  <encoding>windows-1252</encoding>
  <language>sv</language>
  <score>5.827</score>
</encoding-language>
<encoding-language xmlns="xdmp:encoding-language-detect">
  <encoding>windows-1252</encoding>
  <language>pt</language>
  <score>5.762</score>
</encoding-language>
<encoding-language xmlns="xdmp:encoding-language-detect">
  <encoding>windows-1250</encoding>
  <language>hu</language>
  <score>5.356</score>
</encoding-language>
<encoding-language xmlns="xdmp:encoding-language-detect">
  <encoding>windows-1250</encoding>
  <language>hr</language>
  <score>4.941</score>
</encoding-language>
<encoding-language xmlns="xdmp:encoding-language-detect">
  <encoding>windows-1250</encoding>
  <language>pl</language>
  <score>4.693</score>
</encoding-language>
<encoding-language xmlns="xdmp:encoding-language-detect">
  <encoding>windows-1252</encoding>
  <language>fi</language>
  <score>3.885</score>
</encoding-language>

Returns the number of fragments selected by an expression. This can be used as a fast estimate of the number of items in a sequence.

Queries that use xdmp:estimate require that the XPath expression searched is partially searchable. A partially searchable XPath expression is one whose first step is searchable. You can use xdmp:query-trace() to determine if a step is searchable. If there are no entries in the xdmp:query-trace() output indicating that the first step is unsearchable, then the expression is partially searchable and you can perform an xdmp:estimate operation on it.

  xdmp:estimate(collection())
   => 10476

Returns the result of evaluating a string as an XQuery module.

http://marklogic.com/xdmp/privileges/xdmp-eval

You must have the http://marklogic.com/xdmp/privileges/xdmp-eval-in privilege to specify the <database> option with a database other than the context database.

You must have the http://marklogic.com/xdmp/privileges/xdmp-eval-modules-change (for xdmp:eval), http://marklogic.com/xdmp/privileges/xdmp-invoke-modules-change (for xdmp:invoke), or the http://marklogic.com/xdmp/privileges/xdmp-spawn-modules-change (for xdmp:spawn) privilege to change either the modules database to another database or to change the root to another path. You must have the http://marklogic.com/xdmp/privileges/xdmp-eval-modules-change-file (for xdmp:eval), http://marklogic.com/xdmp/privileges/xdmp-invoke-modules-change-file (for xdmp:invoke), or the http://marklogic.com/xdmp/privileges/xdmp-eval-modules-change-file (for xdmp:spawn) privilege to change the modules database to the file system or to change a root on the filesystem.

You must have the http://marklogic.com/xdmp/privileges/xdmp-login privilege to use the user-login option.

  xdmp:eval("1+1")
  => 2

xquery version "1.0-ml";
declare namespace my='http://mycompany.com/test'; 

let $s := 
      "xquery version '1.0-ml';
       declare namespace my='http://mycompany.com/test'; 
       declare variable $my:x as xs:string external;
       concat('hello ', $my:x)"
return 
    (: evaluate the query string $s using the variables 
       supplied as the second parameter to xdmp:eval :)
    xdmp:eval($s, (xs:QName("my:x"), "world"))

=> hello world
  

  xdmp:eval("doc('/docs/mydoc.xml')",  (),
		  <options xmlns="xdmp:eval">
		    <database>{xdmp:database("otherdb")}</database>
		  </options>)
  => The '/docs/mydoc.xml' document from the
     otherdb database.

xdmp:eval('xdmp:get-current-user()', (), 
 <options xmlns="xdmp:eval">
  <user-id>{xdmp:user("someuser")}</user-id>
 </options>)
(:
  returns "someuser", assuming "someuser" exists in the
  security database and the user running the eval request has the 
  xdmp:login privilege.
:)

[DEPRECATED: use xdmp:eval with the database option instead] Returns the result of evaluating a string as an XQuery module in a given database.

  xdmp:eval-in("1+1",2348790529)
  => 2

xquery version "0.9-ml"
declare namespace my='http://mycompany.com/test' 

let $s := 
      "xquery version '0.9-ml'
       declare namespace my='http://mycompany.com/test' 
       define variable $my:x as xs:string external
       concat('hello ', $my:x)"
return 
    (: evaluate the query string $s using the variables 
       supplied as the second parameter to xdmp:eval :)
    xdmp:eval-in($s, 
                 xdmp:database("Documents"), 
		 (xs:QName("my:x"), 
		 "world"))

=> hello world
  

Returns true if any fragment is selected by an expression, false if no fragments are selected. This can be used as a fast existence check.

Queries that use xdmp:exists require that the XPath expression searched is partially searchable. A partially searchable XPath expression is one whose first step is searchable. You can use xdmp:query-trace() to determine if a step is searchable. If there are no entries in the xdmp:query-trace() output indicating that the first step is unsearchable, then the expression is partially searchable and you can perform an xdmp:exists operation on it.

Calling xdmp:exists on an expression is the same as calling xdmp:estimate on the expression with a maximum of 1. For example, the following are equivalent:

     xdmp:exists(cts:search(collection(), "foo"))
     
       is equivalent to:
     
     xs:boolean(xdmp:estimate(cts:search(collection(), "foo"), 1)) 

  xdmp:exists(collection())
   => true

Returns the the ID of the forest specified as the parameter.

  xdmp:forest("myForest")
  => 15495681647217162987

Returns the database ID corresponding to the database to which the specified forest belongs.

  xdmp:forest-databases(xdmp:forest("Documents"))
  => 2032458498523149048

Return the name of the forest with the given id.

xdmp:forest-name(8456374036761185098)
=> "Documents"

Returns a sequence of the IDs of all the forests in the system.

  xdmp:forests()
   => 18263538320779601865
2760886727871312968
1551965607977434000
2714941248661564752

Returns a formatted number value based on the picture argument. The difference between this function and the W3C standards fn:format-number function is that this function imitates the XSLT xsl:number instruction, which has richer formatting options than the fn:format-number function. This function can be used for spelled-out and ordinal numbering in many languages. This function is available in XSLT as well as in all dialects of XQuery.

Most, but not all formatting combinations work. The following table shows formatting options by language, and lists what is supported and what is not.

Language	Numeric Cardinals	Numeric Ordinals	Spelled Out Cardinals	Spelled Out Ordinals
en	Yes	Yes	Yes	Yes
fr	Yes	Yes	Yes	No
it	Yes	Yes	Yes	No
de	Yes	No	Yes	Yes
ru	Yes	No	Yes	No
es	Yes	Yes	Yes	No
ar	Yes	Yes	Yes	No
zh	Yes	Yes	Yes	Yes
ko	Yes	Yes	Yes	Yes
fa	Yes	No	Yes	No
nl	Yes	Yes	Yes	Yes
ja	Yes	Yes	Yes	Yes
pt	Yes	Yes	Yes	No

xdmp:format-number(29,"01","en","",(),'0',",",3),
xdmp:format-number(09,"W","en","",(),'"',",",3),
xdmp:format-number((5),"w","es",(),(),"0",",",3)
=>
29
NINE
cinco
 

Parses a string as JSON, returning an item sequence.

JSON objects are parsed as maps.

The JSON null value is represented as the empty sequence.

Nested arrays in JSON are flattened out.

Any codepoints in the JSON string that aren't allowed in XML are rejected and an error is thrown.

  xdmp:from-json('["a", false]')
  => ("a", fn:false())
  

xquery version "1.0-ml";

let $json := 
  '[{"some-key":45683}, "this is a string", 123]'
return
xdmp:from-json($json)

=>

map:map(
 <map:map xmlns:xs="http://www.w3.org/2001/XMLSchema" 
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
          xmlns:map="http://marklogic.com/xdmp/map">
   <map:entry key="some-key">
     <map:value xsi:type="xs:integer">45683</map:value>
   </map:entry>
 </map:map>)
this is a string
123

Note that what is shown above is the serialization of the XQuery items. 
You can also use some or all of the items in the XQuery data model. 
For example, consider the following, which adds to the map based on the 
other values:

xquery version "1.0-ml";
let $json := 
  '[{"some-key":45683}, "this is a string", 123]'
let $items := xdmp:from-json($json)
let $put := map:put($items[1], xs:string($items[3]), $items[2]) 
return
$items[1]

(: returns the following map:
map:map(
 <map:map xmlns:xs="http://www.w3.org/2001/XMLSchema"
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xmlns:map="http://marklogic.com/xdmp/map">
    <map:entry key="123">
       <map:value xsi:type="xs:string">this is a string</map:value>
    </map:entry>
    <map:entry key="some-key">
      <map:value xsi:type="xs:integer">45683</map:value>
    </map:entry>
 </map:map>)
:)

In the above query, the first item ($items[1]) returned from the 
xdmp:from-json call is a map, and the map is then modified, and then 
the modified map is returned.

Returns a function value as an xdmp:function type. You can return an xdmp:function from an expression or a function. You can execute the function referred to by an xdmp:function by passing the xdmp:function value to xdmp:apply.

xquery version "1.0-ml";

xdmp:function(xs:QName("fn:empty"))

xquery version "1.0-ml";

declare namespace admin="http://marklogic.com/xdmp/admin";

xdmp:function(xs:QName("admin:get-configuration"), 
      "/MarkLogic/admin.xqy")

xquery version "1.0-ml";

let $function := xdmp:function(xs:QName("fn:concat"))
return
   xdmp:apply($function, "hello", " world")

=> hello world

Returns the module location (if any) that the xdmp:function value refers to.

  let $fn := xdmp:function(xs:QName("admin:get-configuration"),"/MarkLogic/admin.xqy")
  return
    xdmp:function-module($fn)
  ==> "/MarkLogic/admin.xqy"

Returns the QName of the function(s) that the xdmp:function refers to.

  let $fn := xdmp:function(xs:QName("fn:empty"))
  return
    xdmp:function-name($fn)
  ==> "fn:empty"

[DEPRECATED: use xdmp:document-get instead] Returns the document in the XML file specified by $path.

This function is deprecated and will be removed from a future release. Use xdmp:document-get instead.

If no format is specified in $options, it is specified by the document content type specified by the extension of the document URI. The mimetype extensions and corresponding content types are set in the Admin Interface.

If neither "repair-full" nor "repair-none" is present, the default is specified by the XQuery version of the caller. In XQuery version 1.0 and 1.0-ml the default is "repair-none". In XQuery version 0.9-ml the default is "repair-full".

  xdmp:get("foo.xml")
  => <foo/>

  xdmp:get("foo.html", "", ("repair-full", "format-xml"))
  => foo.html as an XML document that has gone through any 
        needed tag repair

Returns the the ID of the group specified in the parameter. Returns the ID of the current group if no parameter is specified.

  xdmp:group("Default")
  => 134722342511344334243

Returns the IDs of all hosts belonging to the group with the given ID. If no parameter is specified, it uses the group of the current host.

  xdmp:group-hosts(134722342511344334243)
  => 18263538320779601865
2760886727871312968

Returns the the name of the group with the given ID. Returns the name of the current group if no parameter is specified.

  xdmp:group-name(134722342511344334243)
  => "Default"

Returns the the IDs of all App Servers belonging to the group with the given ID. If no parameter is specified, it uses the group of the current host.

  xdmp:group-servers(xdmp:group("Default"))
   => 18263538320779601865
       2760886727871312968
       2714941248661564752

Returns a sequence of the IDs of all the groups in the system.

  xdmp:groups()
   => 12363538320723601865
2350822345151312968
7891965607973455300
2314941134541564752

Returns the 32-bit hash of a string.

  xdmp:hash32("/a/b[1]/c")
  => 152930691

Returns the 64-bit hash of a string.

  xdmp:hash64("/a/b[1]/c")
  => 5082244643751628547

Parses a hexadecimal string, returning an integer.

  xdmp:hex-to-integer("1234567890abcdef")
   => 1311768467294899695

Returns the the ID of the host named in the parameter. Returns the ID of the current host if no parameter is specified.

  xdmp:host("foo.example.com")
  => 15495681647217162987

Returns the the name of the host ID specified as the parameter. Returns the current host if no name is specified.

  xdmp:host-name(15495681647217162987)
  => foo.example.com

Returns a sequence of the IDs of all the hosts in the system.

  xdmp:hosts()
   => 18263538320779601865
2760886727871312968
1551965607977434000
2714941248661564752

Sends an http DELETE request to the http server specified in the URI to delete the specified resource. The server should respond if the request is to be completed, but a response is not guaranteed. Also, even if the server does respond, it does not guarantee that the request has been or will be completed.

The http functions only operate on URIs that use the http or https schemes; specifying a URI that does not begin with http:// or https:// throws an exception.

If an http function times out, it throws a socket received exception (SVC-SOCRECV).

Note the the xdmp:http-delete function simply sends a DELETE request to the specified web server; what happens with the DELETE request depends on the web server. The request does not delete a document from a MarkLogic Server database. To delete a document from a database, use the xdmp:document-delete function.

xdmp:http-delete("http://www.my.com/document.xhtml",
     <options xmlns="xdmp:http">
       <authentication method="basic">
         <username>myname</username>
         <password>mypassword</password>
       </authentication>
     </options>)
=> an optional response from the server

Sends the http GET method to the specified URI. Returns the http response as well as whatever information is identified by the specified URI (for example, an html document).

The http functions only operate on URIs that use the http or https schemes; specifying a URI that does not begin with http:// or https:// throws an exception.

If an http function times out, it throws a socket received exception (SVC-SOCRECV).

An automatic encoding detector will be used if the value auto is specified for the encoding option (in the xdmp:document-get namespace). If no option is specified, the encoding defaults to the encoding specified in the http header. If there is no encoding in the http header, the encoding defaults to UTF-8.

The first node in the output of xdmp:http-get is the response header from the http server.

The second node in the output of xdmp:http-get is the response from the http server. The response is treated as text, XML, or binary, depending on the content-type header sent from the http server. If the node is html, the header should indicate text/html, which is returned as a text document by default. The type of document is determined by the mimetypes mappings, and you can change the mappings in the Admin Interface as needed. If you happen to know that the response is XML, even if the header does not specify it as XML, and want to process the response as XML, you can wrap the response in an xdmp:unquote call to parse the response as XML. You could also use the <format>xml</format> option (in the xdmp:document-get namespace) to tell the API to treat the document as XML. Also, if you know the response is an HTML document, you can wrap the response in an xdmp:tidy call, which will treat the text as HTML, clean it up, and return an XHTML XML document.

xdmp:http-get("http://www.my.com/document.xhtml",
     <options xmlns="xdmp:http">
       <authentication method="basic">
         <username>myname</username>
         <password>mypassword</password>
       </authentication>
     </options>)
=> the response from the server as well as the specified document

xdmp:http-get("http://www.my.com/iso8859document.html",
     <options xmlns="xdmp:document-get">
       <encoding>iso-8859-1</encoding>
     </options>)[2]
=> The specified document, transcoded from ISO-8859-1
   to UTF-8 encoding.  This assumes the document is
   encoded in ISO-8859-1. Note that the encoding option
   is in the "xdmp:document-get" namespace.

xdmp:unquote(
  xdmp:http-get("http://www.my.com/somexml.xml")[2])
=> The specified xml document, parsed as XML by
   xdmp:unquote.  If the header specifies a 
   mimetype that is configured to be treated as
   XML, the xdmp:unquote call is not needed.  
   Alternately, you can treat the response as XML
   by specifying XML in the options node as 
   follows (note that the format option is in
   the "xdmp:document-get" namespace:

xdmp:http-get("http://www.my.com/somexml.xml",
	<options xmlns="xdmp:http-get">
	   <format xmlns="xdmp:document-get">xml</format>
	</options>)[2]

xdmp:tidy(
  xdmp:http-get("http://www.my.com/somehtml.html")[2])[2]
=> The specified html document, cleaned and transformed 
   to xhtml by xdmp:tidy.  The second node of the tidy 
   output is the xhtml node (the first node is the status).
   You could then perform XPath on the output to return 
   portions of the document. Note that the document (and 
   all of its elements) will be in the XHTML namespace, so 
   you need to specify the namespace in the XPath steps.  
   For example:
 
xquery version "1.0-ml";  
declare namespace xh="http://www.w3.org/1999/xhtml";

xdmp:tidy(
  xdmp:http-get("http://www.my.com/somehtml.html")[2])[2]//xh:title

Sends the http HEAD method to the specified URI. Returns the http response header for the specified URI.

The http functions only operate on URIs that use the http or https schemes; specifying a URI that does not begin with http:// or https:// throws an exception.

If an http function times out, it throws a socket received exception (SVC-SOCRECV).

xdmp:http-head("http://www.my.com/document.xhtml",
     <options xmlns="xdmp:http">
       <authentication method="basic">
         <username>myname</username>
         <password>mypassword</password>
       </authentication>
     </options>)
=> the response header from the server

Sends the http OPTIONS method to the specified URI. Returns the http response for the specified URI.

The http functions only operate on URIs that use the http or https schemes; specifying a URI that does not begin with http:// or https:// throws an exception.

If an http function times out, it throws a socket received exception (SVC-SOCRECV).

xdmp:http-options("http://localhost:8000/",
     <options xmlns="xdmp:http">
       <authentication method="digest">
         <username>myname</username>
         <password>mypassword</password>
       </authentication>
     </options>)
=> the response from the HTTP server, for example:

<response xmlns="xdmp:http">
  <code>302</code>
  <message>Found</message>
  <headers>
    <location>/use-cases/</location>
    <server>MarkLogic</server>
    <content-length>0</content-length>
    <connection>close</connection>
  </headers>
</response>

Sends the http POST request to the server.

The http functions only operate on URIs that use the http or https schemes; specifying a URI that does not begin with http:// or https:// throws an exception.

If an http function times out, it throws a socket received exception (SVC-SOCRECV).

If you expect the request body from this http function to be processed by another application (via a web service, for example), you should specify a content-type header. If no content-type header is specified, the content type defaults to text/plain.

xdmp:http-post("http://www.my.com/document.xhtml",
     <options xmlns="xdmp:http">
       <authentication method="basic">
         <username>myname</username>
         <password>mypassword</password>
       </authentication>
     </options>)
=> the response from the server as well as the specified document

(: Use xdmp:unquote to encode the XML as a string 
   because the <data> options element is a string :)
let $payload := xdmp:quote(
<SOAP-ENV:Envelope xmlns:SOAP-ENV='http://schemas.xmlsoap.org/soap/envelope/'
  xmlns:xsd='http://www.w3.org/2001/XMLSchema'
  xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'
  xmlns:SOAP-ENC='http://schemas.xmlsoap.org/soap/encoding/'
  xmlns:my='urn:MyConnection'>
 <SOAP-ENV:Body>
   <my:LogOn>
     <my:User>user</my:User>
     <my:Password>pass</my:Password> 
     <my:Ticket>abc123</my:Ticket>
     <my:newData>1234</my:newData>
   </my:LogOn>
 </SOAP-ENV:Body>
</SOAP-ENV:Envelope>
)
return
xdmp:http-post("http://www.my.com/document.xhtml",
     <options xmlns="xdmp:http">
       <authentication method="basic">
         <username>myname</username>
         <password>mypassword</password>
       </authentication>
       <data>{$payload}</data>
       <headers>
         <content-type>text/xml</content-type>
       </headers>
     </options>)
=> the response from the server as well as the specified document

Sends an HTTP PUT request to an HTTP server. The HTTP server should return a response, which will differ depending on the action the HTTP server takes for the PUT.

The http functions only operate on URIs that use the http or https schemes; specifying a URI that does not begin with http:// or https:// throws an exception.

If an http function times out, it throws a socket received exception (SVC-SOCRECV).

If you expect the request body from this http function to be processed by another application (via a web service, for example), you should specify a content-type header. If no content-type header is specified, the content type defaults to text/plain.

xdmp:http-put("http://www.my.com/document.xhtml",
     <options xmlns="xdmp:http">
       <authentication method="basic">
         <username>myname</username>
         <password>mypassword</password>
       </authentication>
     </options>)
=> the response from the HTTP server as well as the specified document

Returns a hexadecimal representation of an integer.

  xdmp:integer-to-hex(1234567890)
   => "499602d2"

Returns an octal representation of an integer.

  xdmp:integer-to-octal(1234567890)
   => "11145401322"

Returns the result of evaluating a module at the given path.

http://marklogic.com/xdmp/privileges/xdmp-invoke

  xdmp:invoke("http://example.com/modules/foo.xqy")
  => 2

  This example invokes a module using external variables.
  
  Assume you have a module in the modules database with a URI
  "http://example.com/application/module.xqy" containing the
  following code:

  xquery version "1.0-ml";
  declare namespace my="my-namespace-uri";
  declare variable $my:var as xs:string external;
  xdmp:log($my:var)

  Then you can call this module using xdmp:invoke as follows:

  xquery version "1.0-ml";
  declare namespace my="my-namespace-uri";
  xdmp:invoke("module.xqy", 
        (xs:QName("my:var"), "log this to ErrorLog.txt"), 
        <options xmlns="xdmp:eval">
          <modules>{xdmp:modules-database()}</modules>
	  <root>http://example.com/application/</root>
         </options>)
	 
  => Invokes an XQuery module from the modules database 
     with the URI http://example.com/application/module.xqy.
     The invoked module will then be executed, logging the 
     message sent in the external variable to the log file. 

[DEPRECATED: use xdmp:invoke with the database option instead] Returns the result of evaluating a module at the given path.

  xdmp:invoke-in("http://example.com/modules/foo.xqy",2348790529)
  => 2

Construct a context-independent string from a QName. This string is of the form "{namespaceURI}localname" and is suitable for use as a map key.

Logs a debug message to the log file <install_dir>/Logs/ErrorLog.txt.

  xdmp:log("AAAA")
  => ()

Retrieves the current server log level.

  xdmp:log-level()
  => finest

Left-shift a 64-bit integer value.

  xdmp:lshift64(255, 2)
   => 1020

Calculates the md5 hash of the given argument.

  xdmp:md5("foo")
  => "acbd18db4cc2f85cedef654fccc4a4d8"
 

Returns the database ID of the modules database. Returns 0 if the current App Server uses the file system for its modules.

  xdmp:modules-database()
  => 8447094497219470018

Returns the current root path for modules.

  xdmp:modules-root()
   => Docs

Muliply two 64-bit integer values, discarding overflow.

  xdmp:mul64(15107650474313474666,13290239292956375463)
  => 1404109880107289894

Returns the database id where the parameter is stored. If the specified node does not come from a document in a database, then xdmp:node-database returns an empty list.

  xdmp:node-database(doc("http://marklogic.com/document"))
   => 18384173956586417397

Returns an xs:string representing the node's kind: either "document", "element", "attribute", "text", "namespace", "processing-instruction", "binary", or "comment".

The fn:node-kind builtin was dropped from the final XQuery 1.0 spec. This is the equivalent function in the xdmp: namespace carried over for MarkLogic 1.0 dialects.

let $x := <hello><goodbye>1</goodbye></hello>
return
xdmp:node-kind($x/node())

=> element

Returns the document-uri property of the parameter or its ancestor.

  xdmp:node-uri(doc("http://marklogic.com/document"))
   => "http://marklogic.com/document"

NOT a 64-bit integer value.

  xdmp:not64(255)
   => 18446744073709551360

Parses an octal string, returning an integer.

  xdmp:octal-to-integer("12345670")
   => 2739128

OR two 64-bit integer values.

  xdmp:or64(255, 2)
   => 255

Parses a string containing date, time or dateTime using the supplied picture argument and returns a dateTime value. While this function is closely related to other XSLT functions, it is available in XSLT as well as in all XQuery dialects.

Dates before October 15, 1582 (the start of the Gregorian calendar) will not return the correct dateTime value.

   xdmp:parse-dateTime("[Y0001]-[M01]-[D01]T[h01]:[m01]:[s01].[f1][Z]","2010-01-06T17:13:50.873594-08:00")
 

Parses a string containing date, time or dateTime using the supplied picture argument and returns a dateTime value. While this function is closely related to other XSLT functions, it is available in XSLT as well as in all XQuery dialects.

Dates before October 15, 1582 (the start of the Gregorian calendar) will not return the correct dateTime value.

   xdmp:parse-yymmdd("yyyy-MM-ddThh:mm:ss.Sz","2010-01-06T17:13:50.873594-8.00")
 

Returns a string whose value corresponds to the path of the node.

  let $arg := <a><b><c>ccc</c></b>
                <b>bbb</b></a>
  return xdmp:path($arg/b[1]/c)
  => "/a/b[1]/c"

Returns an XML element recording information about how the given expression will be processed by the index. The information is a structured representation of the information provided in the error log when query trace is enabled. The query will be processed up to the point of getting an estimate of the number of fragments returned by the index.

The output from xdmp:plan will vary depending on various index settings.

Running an xdmp:plan on a search is similar to running an xdmp:estimate on a search, but it returns a report on the search instead of just an estimate. As part of the report, the qry:result element includes the estimate. If the search expression argument cannot be run in the plan because it is not partially searchable, then an XDMP-UNSEARCHABLE exception is returned as part of the xdmp:plan output.

If you are running a search using the search API (for example, search:search), use the option <return-plan>true</return-plan> in your search API options node.

  xdmp:plan(cts:search(fn:doc(),cts:word-query("cat")))
   => 
<qry:query-plan xmlns:qry="http://marklogic.com/cts/query">
  <qry:info-trace>xdmp:eval("xquery version &amp;quot;1.0-ml&amp;quot;;&amp;#13;
  &amp;#10;xdmp:plan(cts:search...", (), &lt;options xmlns="xdmp:eval"&gt;&lt;
  default-xquery-version&gt;0.9-ml&lt;/default-xquery-version&gt;&lt;root
  &gt;c:/...&lt;/options&gt;)</qry:info-trace>
  <qry:info-trace>Analyzing path for search: fn:doc()</qry:info-trace>
  <qry:info-trace>Step 1 is searchable: fn:doc()</qry:info-trace>
  <qry:info-trace>Path is fully searchable.</qry:info-trace>
  <qry:info-trace>Gathering constraints.</qry:info-trace>
  <qry:word-trace text="cat">
    <qry:key>12545744176132597186</qry:key>
  </qry:word-trace>
  <qry:info-trace>Search query contributed 1 constraint:
  cts:word-query("cat", ("lang=en"), 1)</qry:info-trace>
  <qry:partial-plan>
    <qry:term-query weight="1">
      <qry:key>12545744176132597186</qry:key>
    </qry:term-query>
  </qry:partial-plan>
  <qry:info-trace>Executing search.</qry:info-trace>
  <qry:final-plan>
    <qry:and-query>
      <qry:term-query weight="1">
	<qry:key>12545744176132597186</qry:key>
      </qry:term-query>
    </qry:and-query>
  </qry:final-plan>
  <qry:info-trace>Selected 2 fragments to filter</qry:info-trace>
  <qry:result estimate="2"/>
</qry:query-plan>

xquery version "1.0-ml" ;

xdmp:plan(
 cts:search(/document, 
   cts:word-query("cut?", 
    ("unstemmed", "wildcarded") ) ) ) 
(:
The <qry:expansion-trace> element indicates that a 
lexicon expansion occurred on the wildcarded query
(word searches, three character searches and 
a codepoint lexicon are enabled in the database 
configuration for wildcard queries).  The 
<qry:expansion> element shows what term(s) the 
lexicon expansion found.  In this case, "cut?" 
expands to "cute".
:)
=>
<qry:query-plan xmlns:qry="http://marklogic.com/cts/query">
  <qry:info-trace>xdmp:eval("xquery version &amp;quot;1.0-ml&amp;quot; ;
  &amp;#13;&amp;#10;&amp;#13;&amp;#10;xdmp:plan...", (), 
  &lt;options xmlns="xdmp:eval"&gt;&lt;database&gt;
  13960881382049922482&lt;/database&gt;&lt;default-xquery-version...
  &lt;/options&gt;)</qry:info-trace>
  <qry:info-trace>Analyzing path for search: fn:collection()/document
  </qry:info-trace>
  <qry:info-trace>Step 1 is searchable: fn:collection()</qry:info-trace>
  <qry:info-trace>Step 2 is searchable: document</qry:info-trace>
  <qry:info-trace>Path is fully searchable.</qry:info-trace>
  <qry:info-trace>Gathering constraints.</qry:info-trace>
  <qry:expansion-trace text="cut?">
    <qry:expansion text="cute"/>
  </qry:expansion-trace>
  <qry:word-trace text="cute">
    <qry:key>16588943567160478160</qry:key>
  </qry:word-trace>
  <qry:info-trace>Search query contributed 1 constraint: 
  cts:word-query("cut?", ("unstemmed","wildcarded","lang=en"), 1)
  </qry:info-trace>
  <qry:partial-plan>
    <qry:term-query weight="1">
      <qry:key>16588943567160478160</qry:key>
    </qry:term-query>
  </qry:partial-plan>
  <qry:info-trace>Executing search.</qry:info-trace>
  <qry:final-plan>
    <qry:and-query>
      <qry:or-two-queries>
	<qry:term-query weight="0">
	  <qry:key>3998944933214536873</qry:key>
	</qry:term-query>
	<qry:term-query weight="0">
	  <qry:key>13616698357625443361</qry:key>
	</qry:term-query>
      </qry:or-two-queries>
      <qry:term-query weight="1">
	<qry:key>16588943567160478160</qry:key>
      </qry:term-query>
    </qry:and-query>
  </qry:final-plan>
  <qry:info-trace>Selected 1 fragment to filter</qry:info-trace>
  <qry:result estimate="1"/>
</qry:query-plan>

Returns the operating-system platform upon which MarkLogic Server is running ("solaris", "winnt", "linux", or "macosx").

  xdmp:platform()
   => "winnt"

Returns a well-formatted XQuery module.

  xdmp:pretty-print("for $x in 1 to 10 return $x")
   => "for $x in 1 to 10
       return $x"

Returns the current MarkLogic product edition.

  xdmp:product-edition()
   => "Standard"

Construct a QName from a string of the form "{namespaceURI}localname". This function is useful for constructing Clark notation parameters for the xdmp:xslt-eval and xdmp:xslt-invoke functions.

xquery version "1.0-ml";
(: returns the Clark notation form of the QName :)

xdmp:key-from-QName(xs:QName("fn:foo"))
=>
{http://www.w3.org/2005/xpath-functions}foo

Returns the current value of the resource meters for this query sequence.

The resource meters returned include:

elapsed-time

The time elapsed since the start of the processing of this query, in the form of a duration.

requests

The number of requests.

list-cache-hits

The number of successful list cache lookups. The list cache holds search termlists used to accelerate path expressions and text searches.

list-cache-misses

The number of unsuccessful list cache lookups. Each unsuccessful list cache lookup was followed by a disk access to load the search termlist into the cache.

in-memory-list-hits

The number of successful list lookups in in-memory stands.

expanded-tree-cache-hits

The number of successful expanded tree cache lookups. The expanded tree cache cache holds XML document data in the expanded representation used by the XQuery evaluator.

expanded-tree-cache-misses

The number of unsuccessful expanded tree cache lookups. Each unsuccessful expanded tree lookup was followed by a compressed tree cache lookup to load the expanded tree into the cache.

compressed-tree-cache-hits

The number of successful compressed tree cache lookups. The compressed tree cache holds XML document data in the compressed representation stored on disk.

compressed-tree-cache-misses

The number of unsuccessful compressed tree cache lookups. Each unsuccessful compressed tree cache lookup was followed by a disk access to load the compressed tree into the cache.

in-memory-compressed-tree-hits

The number of successful compressed tree lookups in in-memory stands.

value-cache-hits

The number of successful value cache lookups. The value cache is a transient cache that exists only for the duration of one query. It holds typed values, and is used to accelerate the frequent conversion of nodes to typed values.

value-cache-misses

The number of unsuccessful value cache lookups. Each unsuccessful value cache lookup was followed by a conversion of an XML node to a typed value.

regexp-cache-hits

The number of successful regular expression cache lookups. The regular expression cache is a transient cache that exists only for the duration of one query. It holds compiled regular expressions, and is used to accelerate the frequent use of regular expressions during the evaluation of a query.

regexp-cache-misses

The number of unsuccessful regular expression cache lookups. Each unsuccessful regular expression cache lookup was followed by a compilation of a regular expression from source text.

link-cache-hits

The number of successful link cache lookups. The link cache is a transient cache that exists only for the duration of one query. It holds pointers to expanded trees, and is used to accelerate the frequent dereferencing of link nodes.

link-cache-misses

The number of unsuccessful link cache lookups. Each unsuccessful link cache lookup was followed by a search for the link target tree.

filter-hits

The number of successful search filter matches.

filter-misses

The number of unsuccessful search filter matches.

fragments-added

The number of XML fragments added to the database by an update.

fragments-deleted

The number of XML fragments deleted from the database by an update.

fs-program-cache-hits

The number of module cache hits from the entire program made from modules on the file system.

fs-program-cache-misses

The number of module cache misses from the entire program made from modules on the file system.

db-program-cache-hits

The number of module cache hits from the entire program made from modules in a database (may contain library modules from the special Modules directory).

db-program-cache-misses

The number of module cache misses from the entire program made from modules in a database (may contain library modules from the special Modules directory).

env-program-cache-hits

The number of module cache hits from the entire program made from ad hoc XSLT stylesheet nodes.

env-program-cache-misses

The number of module cache misses from the entire program made from ad hoc XSLT stylesheet nodes.

fs-main-module-sequence-cache-hits

The number of main module cache hits from main modules on the file system.

fs-main-module-sequence-cache-misses

The number of main module cache misses from main modules on the file system.

db-main-module-sequence-cache-hits

The number of main module cache hits from main modules in a database.

db-main-module-sequence-cache-misses

The number of main module cache misses from main modules in a database.

fs-library-module-cache-hits

The number of library module cache hits from library modules on the file system.

fs-library-module-cache-misses

The number of library module cache misses from library modules on the file system.

db-library-module-cache-hits

The number of library module cache hits from library modules from the modules database.

db-library-module-cache-misses

The number of library module cache misses from library modules from the modules database.

Some meters are broken down by fragment root and document URI:

fragments

A sequence of fragment elements, each containing:

root

The fragment root name.

expanded-tree-cache-hits

A count of successful expanded tree cache lookups for this fragment root.

expanded-tree-cache-misses

A count of unsuccessful expanded tree cache lookups for this fragment root.

documents

A sequence of document elements, each containing:

uri

The document URI.

expanded-tree-cache-hits

A count of successful expanded tree cache lookups for this document URI.

expanded-tree-cache-misses

A count of unsuccessful expanded tree cache lookups for this document URI.

There are also meters that measure the query activity per host. There is a qm:hosts element with one qm:host child per host that participates in the query. Each qm:host element contains meters showing the round-trip-time and round-trip-count for communications between the evaluator host and the host referenced in the xdmp:query-meters output. The qm:hosts element is empty for a single-node cluster.

Certain operations are run concurrently with the timing operations, and if those operations are not actually used in the query, they might not be included in the timings. This occurs for operations like xdmp:estimate, xdmp:exists, and lexicon calls (for example, cts:element-values). If you want to see the total timings that include calls that are not used, you can form some other expression with the results of the calls. For example, if you have an expression that calls xdmp:estimate in a let expression, you can add 0 to the output, which causes it to be included in the timings (something like xdmp:estimate($query) + 0).

  xdmp:query-meters();
  => 
  <qm:query-meters 
   xsi:schemaLocation="http://marklogic.com/xdmp/query-meters 
       query-meters.xsd" 
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
   xmlns:qm="http://marklogic.com/xdmp/query-meters">
    <qm:elapsed-time>PT0.22S</qm:elapsed-time>
    <qm:requests>1</qm:requests>
    <qm:list-cache-hits>0</qm:list-cache-hits>
    <qm:list-cache-misses>0</qm:list-cache-misses>
    <qm:in-memory-list-hits>0</qm:in-memory-list-hits>
    <qm:expanded-tree-cache-hits>0
       </qm:expanded-tree-cache-hits>
    <qm:expanded-tree-cache-misses>0
       </qm:expanded-tree-cache-misses>
    <qm:compressed-tree-cache-hits>0
       </qm:compressed-tree-cache-hits>
    <qm:compressed-tree-cache-misses>0
       </qm:compressed-tree-cache-misses>
    <qm:in-memory-compressed-tree-hits>0
       </qm:in-memory-compressed-tree-hits>
    <qm:value-cache-hits>0</qm:value-cache-hits>
    <qm:value-cache-misses>0</qm:value-cache-misses>
    <qm:regexp-cache-hits>0</qm:regexp-cache-hits>
    <qm:regexp-cache-misses>0</qm:regexp-cache-misses>
    <qm:link-cache-hits>0</qm:link-cache-hits>
    <qm:link-cache-misses>0</qm:link-cache-misses>
    <qm:fragments-added>0</qm:fragments-added>
    <qm:fragments-deleted>0</qm:fragments-deleted>
    <qm:fs-program-cache-hits>1</qm:fs-program-cache-hits>
    <qm:fs-program-cache-misses>0</qm:fs-program-cache-misses>
    <qm:db-program-cache-hits>0</qm:db-program-cache-hits>
    <qm:db-program-cache-misses>0</qm:db-program-cache-misses>
    <qm:env-program-cache-hits>0</qm:env-program-cache-hits>
    <qm:env-program-cache-misses>0</qm:env-program-cache-misses>
    <qm:fs-main-module-sequence-cache-hits>0
       </qm:fs-main-module-sequence-cache-hits>
    <qm:fs-main-module-sequence-cache-misses>0
       </qm:fs-main-module-sequence-cache-misses>
    <qm:db-main-module-sequence-cache-hits>0
       </qm:db-main-module-sequence-cache-hits>
    <qm:db-main-module-sequence-cache-misses>0
       </qm:db-main-module-sequence-cache-misses>
    <qm:fs-library-module-cache-hits>0
       </qm:fs-library-module-cache-hits>
    <qm:fs-library-module-cache-misses>0
       </qm:fs-library-module-cache-misses>
    <qm:db-library-module-cache-hits>0
       </qm:db-library-module-cache-hits>
    <qm:db-library-module-cache-misses>0
       </qm:db-library-module-cache-misses>
    <qm:fragments/>
    <qm:documents/>
    <qm:hosts/>
  </qm:query-meters> 

xquery version "1.0-ml";
declare namespace qm="http://marklogic.com/xdmp/query-meters";

fn:count(collection()),
xdmp:query-meters()/qm:elapsed-time

=> The count of the number of documents in the database followed by
   the elapsed-time element of the xdmp:query-trace XML output:

153
<qm:elapsed-time xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
                 xmlns:qm="http://marklogic.com/xdmp/query-meters">
		 PT0.04S</qm:elapsed-time>

Enables or disables tracing of this query. When query tracing is enabled, "info" level messages are logged detailing the search optimizations performed.

Search optimizations are performed in three phases:

the path analysis phase

In this phase a path expression is analyzed to determine whether it can be executed in whole or in part through an optimized search. Each individual component of the path is analyzed to see if it is searchable. The searchablity of each path component is logged.

the search constraint gathering phase

In this phase, search constraints are gathered from the path expression components. The number of constraints contributed by each path component is logged.

the search execution phase

In this phase, a search is performed using the gathered constraints. The actual number of fragments selected for filtering is logged.

  xdmp:query-trace(true())
  => ()

Returns the unevaluated serialized representation of the input parameter as a string.

  let $arg := <a>aaa</a>
  return ($arg, xdmp:quote($arg))
  => (<a>aaa</a>, "<a>aaa</a>")

Returns a random unsigned integer between 0 and a number up to 64 bits long.

  xdmp:random(100)
  => 47

Returns the unique key of the current request.

  xdmp:request()
   => 18263538320779601865

Returns the system timestamp for this request if the request is a query statement. Returns the empty sequence if the current request is an update statement.

The xdmp:request-timestamp function returns the system timestamp that is in effect for current query. This timestamp will remain unchanged for the duration of the query. If you want to get the most recent system timestamp external to the current running context during an update statement (for example, if your query takes a long time to run, and there are other updates occurring in your database while your update statement is running), you can use xdmp:eval to evaluate a separate query statement that returns the system timestamp at the time the xdmp:eval query is evaluated.

  xdmp:request-timestamp()
   => 1234567

Within the catch section of a try-catch expression, re-throw the currently caught error.

  try {
    xdmp:document-delete($uri)
  } catch ($ex) {
    (: ignore documents that aren't there :)
    if ($ex/error:code eq 'XDMP-DOCNOTFOUND') then ()
    else xdmp:rethrow()
  }

Right-shift a 64-bit integer value.