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

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".

  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

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

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")
  => <lock:lock>
          <lock:active-locks>
            <lock:active-lock>
              <lock:lock-type>write</lock:lockt-ype>
              <lock:lock-scope>exclusive</lock:lock-scope>
              <lock:depth>infinity</lock:depth>
              <lock:owner>
                http://example.com/~user
              </lock:owner>
              <lock:timeout>5000</lock:timeout>
              <lock:lock-token>
                  http://marklogic.com/xdmp/locks/e71d4fae
              </lock:lock-token>
              <lock:timestamp>5234768</lock:timestamp>
              <sec:user-id>52378234768</sec:user-id>
            </lock:active-lock>
          </lock:active-locks>
        </lock:lock>

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()
    => 
    <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>

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>Mark Logic</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>Mark Logic</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>)

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

[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 scheme; specifying a URI that does not begin with http:// 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 scheme; specifying a URI that does not begin with http:// throws an exception.

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

If no encoding option (in the xdmp:document-get namespace) 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 scheme; specifying a URI that does not begin with http:// 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 scheme; specifying a URI that does not begin with http:// 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 scheme; specifying a URI that does not begin with http:// 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 must specify a content-type header. If no content-type header is specified, the content type defaults to application/x-www-form-urlencoded and the request body will be empty (the request is still accessible via the request fields).

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>
     </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 scheme; specifying a URI that does not begin with http:// 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 must specify a content-type header. If no content-type header is specified, the content type defaults to application/x-www-form-urlencoded and the request body will be empty (the request is still accessible via the request fields).

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

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

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 Mark Logic 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"

Parses an octal string, returning an integer.

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

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 the operating-system platform upon which MarkLogic Server is running ("solaris", "winnt", or "linux").

  xdmp:platform()
   => "winnt"

Returns the current Mark Logic product edition.

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

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.

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.

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).

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.

  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: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: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

Rethrow the currently caught error.

xdmp:rethrow()

Returns the database ID of the schema database associated with the current database.

To run queries against the schema database, you can specify the xdmp:schema-database() function as the second parameter to xdmp:eval-in().

  xdmp:schema-database()
  => 15467547981724877000

Returns the database ID of the security database associated with the current database.

To run queries against the security database, you can specify the xdmp:security-database() function as the second parameter to xdmp:eval-in().

  xdmp:security-database()
  => 8447094497219470018

Returns the the ID(s) of the App Server specified in the parameter. Returns the ID of the current App Server if no parameter is specified.

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

Return the name of the App Server with the given ID.

xdmp:server-name(845637403676198)
=> "Docs"

Returns a sequence of the IDs of all the App Servers in the system.

  xdmp:servers()
   => 18263538320779601865
2760886727871312968
1551965607977434000
2714941248661564752

Set the value of a variable to the specified expression. The xdmp:set command allows you to introduce changes to the state (side effects) of a query by changing the value of a variable to something other than what it is bound to.

When a variable is bound to a sequence in a for loop, and when that variable is changed by xdmp:set in the return clause, the change only effects the value for one iteration of the for loop at a time; when the next value is sent to the return clause, it is set to the next value in the sequence specified in the for clause. The value changes only after the xdmp:set call is made.

(: set the value of the variable $x 
   to 1234 and then print out $x :)

let $x := 12
return
(xdmp:set($x, 1234), $x)

=> 1234

(: set the value of the variable $x 
   to 5 and then print out $x for 
   each value of $y :)

for $x in (1, 2)
  for $y in ($x, $x)
return
($y, xdmp:set($x, 5), $x)

=> (1, 5, 1, 5, 2, 5, 2, 5)

(: note the effect on $z of changing the 
   value of $x :)

for $x in (1, 2)
  for $y in (3,4)
    for $z in ($x, $x)
return
($z, xdmp:set($x, 5))

=> (1, 1, 5, 5, 2, 2, 5, 5)

(: every time the name of the input node changes,
   output the new name  :)

let $n := ()
for $i in (<x>1</x>, <x>2</x>, <y>3</y>)
return (
   if (name($i) eq $n) 
   then () 
   else (xdmp:set($n, name($i)), $n)
  , data($i)
)

=> (x, 1, 2, y, 3)

Delays for a specific amount of time.

  xdmp:sleep(1000)
   => ()

Place the specified module on the task queue for evaluation.

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

The xdmp:spawn function places the specified XQuery module in the task queue to be processed. The module will be evaluated when the task server has the available resources to process it. The tasks are processed in the order in which they are added to the queue.

Once xdmp:spawn is called, it cannot be rolled back, even if the transaction from which it is called does not complete. Therefore, use care or preferably avoid calling xdmp:spawn from a module that is performing an update transaction. Once a module is spawned, its evaluation is completely asynchronous of the statement in which xdmp:spawn was called. Consequently, if you call xdmp:spawn from a module that is updating a document, and if the update ends up retrying (for example, if a deadlock is detected), then the entire module is re-evaluated and the xdmp:spawn call is therefore called again. This will only happen in update statements, not in query statements. For details on how transactions work in MarkLogic Server, see "Understanding Transactions in MarkLogic Server" in the Developer's Guide.

  xdmp:spawn("module.xqy", (), 
        <options xmlns="xdmp:eval">
          <modules>{xdmp:modules-database()}</modules>
	  <root>http://example.com/application/</root>
         </options>)
	 
  => Puts the module from the modules database with the 
     URI http://example.com/application/module.xqy 
     in the task server queue.

[DEPRECATED: use xdmp:spawn with the database option instead] Place the specified module on the task queue for evaluation. It will be evaluated in the given database.

The xdmp:spawn-in function places the specified XQuery module in the task queue to be processed. The module will be evaluated when the task server has the available resources to process it. The tasks are processed in the order in which they are added to the queue.

  xdmp:spawn-in("example.xqy",
                324398742983742,
                (),
                xdmp:modules-database(),
                "http://example.com/application/")
  => ()
  Puts the module from the modules database with the 
  URI http://example.com/application/module.xqy 
  in the task server queue. The module will be 
  executed in the context of the database with
  an ID of 324398742983742.

Formats a dateTime value using POSIX strftime.

The supported format strings differ for different platforms. For the supported format strings for Windows, see the following link:

http://msdn2.microsoft.com/en-us/library/fe06s4ak(VS.80).aspx

For the supported format strings for Solaris, see the following link:

http://docs.sun.com/app/docs/doc/817-5438/6mkt5pcec?a=view

For the supported format strings for Linux, see the following link:

http://linux.about.com/library/cmd/blcmdl3_strftime.htm

  xdmp:strftime("%a, %d %b %Y %H:%M:%S",current-dateTime())
   => Tue, 08 Apr 2003 17:21:37

Returns a binary node made up of a subset of the given binary node.

Usage is exactly like fn:substring except that it applies to a binary node rather than a string.

  data(xdmp:subbinary(binary { xs:hexBinary("DEADBEEF") }, 3, 2))
  => xs:hexBinary("BEEF")

Signal a trace event. If trace events are activated and the event is enabled, the trace event is logged.

  xdmp:trace("My Application Event",$my-application-data)
  => ()

Returns the database ID of the triggers database associated with the current database.

  xdmp:triggers-database()
  => 8447094497219470018

Evaluate a string as an XPath and return the corresponding node(s). Any value that is the result of xdmp:path is a valid input to xdmp:unpath. To evaluate non-XPath expressions, use xdmp:value.

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

  xdmp:unpath("/bookstore/book/title")
  => <title>Querying XML</title>
  

The following example shows how you can use xdmp:unpath and specify namespace bindings that are not in the current query scope.

xquery version "1.0-ml";

let $doc := <html xmlns="http://www.w3.org/1999/xhtml">
              <body><p>This is a document</p></body>
            </html>
let $namespaces:= ("xh", "http://www.w3.org/1999/xhtml")
let $xpath-str := "$doc/xh:body/xh:p"
return xdmp:with-namespaces($namespaces, xdmp:unpath($xpath-str))

=> <p xmlns="http://www.w3.org/1999/xhtml">This is a document</p>
  

Parses a string as XML, returning one or more document nodes.

If no format is specified in $options, it is XML.

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".

If $arg is the empty string, xdmp:unquote returns an empty document node.

  xdmp:unquote("<foo/>")
  => <foo/>
  It returns this as a document node.

  xdmp:unquote('<foo>hello</foo>', "", 
          ("repair-none", "default-language=en"))
  => <foo xml:lang="en">hello</foo>
  It returns this as a document node and does
  not perform tag repair on the node.

Returns the content type of the given URI as matched in the mimetypes configuration. xdmp:content-type continues to work too.

  xdmp:uri-content-type("example.txt")
  => text/plain

  xdmp:uri-content-type("example.xml")
  => text/xml

  xdmp:uri-content-type("example.doc")
  => application/msword

Returns the format of the given URI as matched in the mimetypes configuration.

  xdmp:uri-format("example.txt")
  => text

  xdmp:format("example.xml")
  => xml

Returns the last-login node for the specified user ID. If no user ID is specified, then the current user is assumed. If no last-login database is specified in the App Server configuration, then the empty sequence is returned.

  xdmp:user-last-login(xdmp:user("sylvester"))
  => 
  <last-login xmlns="http://marklogic.com/xdmp/last-login">
    <user-id>1134406269933351074</user-id>
    <last-successful-login>2008-03-19T15:41:08</last-successful-login>
    <last-unsuccessful-login>2008-03-19T15:40:45</last-unsuccessful-login>
    <number-unsuccessful-logins>0</number-unsuccessful-logins>
    <display-last-login>true</display-last-login>
  </last-login> 

Evaluate an expression in the context of the current evaluating statement. This differs from xdmp:eval in that xdmp:value preserves all of the context from the calling query, so you do not need to re-define namespaces, variables, and so on. Although the expression retains the context from the calling query, it is evaluated in its own transaction with same-statement isolation.

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

You can only evaluate expressions with xdmp:value; no prolog definitions (namespace declarations, function definitions, module imports, and so on) are allowed.

If the expression references something not in the context of either the calling query or the value expression, then an error is thrown. For example, the following throws an undefined variable exception:

xdmp:value("$y")

  let $var := 5 
  return
  xdmp:value("$var")
  => 5
  

Returns the current MarkLogic Server version.

  xdmp:version()
   => "3.2-1"

Evaluates the expression in the context of a specific set of namespace bindings.

http://marklogic.com/xdmp/privileges/xdmp-with-namespaces

let $version := "1.2" return 
xdmp:with-namespaces(("p", fn:concat("http://marklogic.com/p/",$version)),
   <p:bar/>
)  

Returns:

   <p:bar xmlns:p="http://marklogic.com/p/1.2"/>
  

Returns the XQuery language version of the calling module. Currently supported XQuery versions are:

• "0.9-ml": The legacy Mark Logic XQuery version. This was the only XQuery version available on MarkLogic Server 3.2 and earlier. It is based on the May 2003 XQuery Draft Recommendation, with Mark Logic extensions
• "1.0-ml": XQuery version 1.0, with Mark Logic extensions. This is the preferred version of XQuery beginning with release 4.0.
• "1.0": Strict XQuery version 1.0. This XQuery version complies as closely as possible with the published XQuery 1.0 specification.

  xdmp:xquery-version()
   => "1.0-ml"