Main Page » Developer Section » REST

REST

This page describes how to use the REST API of BaseX.

BaseX offers a RESTful API for accessing database resources via URLs. REST (REpresentational State Transfer) facilitates a simple and fast access to databases through HTTP. The HTTP methods GET, PUT, DELETE, and POST can be used to interact with the database.

Usage

By default, REST services are available at http://localhost:8080/rest/. If no default credentials are specified in the URL or when starting the web application, they will be requested by the client (see Web Application).

A web browser can be used to perform simple GET-based REST requests and display the response. Some alternatives for using REST are listed in the Usage Examples.

Since BaseX 10, results in the rest namespace are returned unprefixed:

<!-- before -->
<rest:databases xmlns:rest="http://basex.org/rest"/>

<!-- now -->
<databases xmlns="http://basex.org/rest"/>

URL Architecture

A request to the root URL returns all available databases:

http://localhost:8080/rest

<databases xmlns="http://basex.org/rest">
  <database resources="25742" size="43813599">articles</database>
  ...
</databases>

The resources of a database (directories, resource metadata) are listed if a database and an optional directory path is specified:

http://localhost:8080/rest/articles

<database name="articles" xmlns="http://basex.org/rest">
  <dir>binaries</dir>
  <resource type="xml" content-type="application/xml" size="77192">1973-02-08.xml</resource>
  ...
</database>

If the path to a single resource is specified, the resource itself will be returned:

http://localhost:8080/rest/articles/1973-02-08.xml

Parameters

The following parameters can be applied to the operations:

Variables: External variables can be bound before a query is evaluated (see below for more).
Context: The context parameter may be used to provide an initial XML context node.
Options: Specified Options are applied before the actual operation will be performed.
Serialization: All Serialization parameters known to BaseX can be specified as query parameters. Parameters that are specified within a query will be interpreted by the REST server before the output is generated.

While Options can be specified for all operations, the remaining parameters will only make sense for Query and Run.

Request

GET Method

If the GET method is used, all query parameters are directly specified within the URL. Additionally, the following operations can be specified:

query: Evaluate an XQuery expression. If a database or database path is specified in the URL, it is set as query context.
command: Execute a single database command.
run: Evaluate an XQuery file or command script located on the server. The file path is resolved against the RESTPATH directory. Similar to query, a database or database path is set as context.
Updated: If no file is found and if the file suffix has been omitted, the extensions .xq and .bxs are successively attached to the supplied filename.

Examples

Lists all resources found in the tmp path of the factbook database: http://localhost:8080/rest/factbook/tmp
Returns the number of documents in a database called test: http://localhost:8080/rest/test?query=count(.)
Serializes a document as JsonML: http://localhost:8080/rest/factbook/factbook.xml?method=json&json=format=jsonml
US-ASCII is chosen as output encoding, and the query eval.xq is evaluated: http://localhost:8080/rest?run=eval&encoding=US-ASCII
The next URL lists all database users who are known to BaseX: http://localhost:8080/rest?command=show+users

POST Method

The body of a POST request is interpreted as XML fragment, which specifies the operation to perform.

The name of the root element determines how the body will be evaluated:

commands: Run Command Script
query: Execute XQuery expression
run: Run server-side file (query or command script)
command: Execute single command

The root element may be bound to the optional REST namespace. Existing command scripts can be sent to the server without any modifications.

For the other commands, the following child elements are supported:

Name	Description
`text`	Required; contains the query string, command string, or file to be run
`parameter`	Serialization parameter (with `@name` and `@value` attributes)
`option`	Database option (with `@name` and `@value` attributes)
`variable`	Variable bindings
`context`	Initial context item

Examples

Create an empty database and return database information:

<commands>
  <create-db name='db'/>
  <info-db/>
</commands>

Return the first five city names of the factbook database:

<rest xmlns="http://basex.org/rest">
  <rest><![CDATA[ (//city/name)[position() <= 5] ]]></text>
</rest>

Return string lengths of all text nodes that are found in the node that has been specified as initial context node:

<query xmlns="http://basex.org/rest">
  <text>for $i in .//text() return string-length($i)</text>
  <context>
    <xml>
      <text>Hello</text>
      <text>World</text>
    </xml>
  </context>
</query>

Return the registered database users encoded in ISO-8859-1:

<command>
  <text>show users</text>
  <parameter name='encoding' value='ISO-8859-1'/>
</command>

Create a new database from the specified input and preserve whitespace:

<command>
  <text>create db test https://files.basex.org/xml/xmark.xml</text>
  <option name='chop' value='false'/>
</command>

Bind value to the $person variable and run query find-person.xq:

<run>
  <variable name='person' value='Johannes Müller'/>
  <text>find-person.xq</text>
</run>

PUT Method

The PUT method is used to create new databases, or to add or update existing database resources:

Create Database: A new database is created if the URL only specifies the name of a database. If the request body contains XML, a single document is created, adopting the name of the database.
Store Resource: A resource is added to the database if the URL contains a database path. If the addressed resource already exists, it is replaced by the new input.

There are two ways to store non-XML data in BaseX:

Store as Raw Data:
If application/octet-stream is chosen as content-type, the input is added as Binary Data.
Convert to XML:
Incoming data is converted to XML if a parser is available for the specified content-type. The following content types are supported:
- application/json: Stores JSON as XML.
- text/plain: Stores plain text input as XML.
- text/comma-separated-values: Stores CSV text input as XML.
- text/html: Stores HTML input as XML.

Conversion can be influenced by specifying additional content-type parameters (see RESTXQ for more information).

If raw data is added and if no content type, or a wrong content, is specified, a 400 (BAD REQUEST) error will be raised.

Examples

A new database with the name XMark is created. If XML input is sent in the HTTP body, the resulting database resource will be called XMark.xml: http://localhost:8080/rest/XMark
A new database is created, and no whitespace will be removed from the passed on XML input: http://localhost:8080/rest/XMark?chop=false
The contents of the HTTP body will be taken as input for the document one.xml, which will be stored in the XMark database: http://localhost:8080/rest/XMark/one.xml

An HTTP response with status code 201 (CREATED) is sent back if the operation was successful. Otherwise, the server will reply with 404 (if a specified database was not found) or 400 (if the operation could not be completed).

Take a look at the usage examples for more detailed examples using Java and shell tools like cURL.

DELETE Method

The DELETE method is used to delete databases or resources within a database.

Examples

The factbook database is deleted: http://localhost:8080/rest/factbook
All resources of the XMark database are deleted that reside in the tmp path: http://localhost:8080/rest/XMark/tmp/

The HTTP status code 404 is returned if no database is specified. 200 (OK) will be sent in all other cases.

Assigning Variables

GET Method

Query parameters that have not been processed otherwise will be treated as variable assignments:

Example

The request http://localhost:8080/rest?run=multiply&a=21&b=2 assigns two variables and invokes multiply.xq:

(: XQuery file: multiply.xq :)
declare variable $a as xs:integer external;
declare variable $b as xs:integer external;
<mult>{ $a * $b }</mult>

Example

Updated: Support for multiple values.

The request http://localhost:8080/rest?run=sum&n=3&n=4&n=5 assigns multiple values to the same variable:

(: XQuery file: sum.xq :)
declare variable $n as xs:integer* external;
sum($n)

The dollar sign can be omitted as long as the variable name does not equal a parameter keyword (e.g.: method).

POST Method

If query or run is used as an operation, external variables can be specified via the <variable/> element:

<query xmlns="http://basex.org/rest">
  <text><![CDATA[
    declare variable $a as xs:integer external;
    declare variable $b as xs:integer external;
    <mult>{ $a * $b }</mult>
  ]]></text>
  <variable name="a" value="21"/>
  <variable name="b" value="2"/>
</query>

Response

Content Type

As the content type of a REST response cannot necessarily be dynamically determined, it can be enforced by the user. The final content type of a REST response is chosen as follows:

If the serialization parameter media-type is supplied, it will be adopted as content-type.
Otherwise, if the serialization parameter method is supplied, the content-type will be chosen according to the following mapping:
- xml, adaptive, basex → application/xml
- xhtml → text/html
- html → text/html
- text → text/plain
- json → application/json
If no media-type or serialization method is supplied, the content type of a response depends on the chosen REST operation:
- Query/Run → application/xml
- Command → text/plain
- Get → application/xml, or content type of the addressed resource

Serialization parameters can either be supplied as query parameters or within the query.

The following three example requests all return <a/> with application/xml as content-type:

Usage Examples

Java

Authentication

Most programming languages offer libraries to communicate with HTTP servers.

The following example demonstrates how easy it is to perform a DELETE request with Java.

Basic access authentication can be activated in Java by adding an authorization header

to the HttpURLConnection instance. The header contains the word Basic, which specifies the authentication method, followed by the

Base64-encoded USER:PASSWORD pair. As Java does not include a default

conversion library for Base64 data, the internal BaseX class org.basex.util.Base64 can be used for that purpose:

import java.net.*;
import org.basex.util.*;

public final class RESTExample {
  public static void main(String[] args) throws Exception {
    // The java URL connection to the resource. 
    URL url = new URL("http://localhost:8080/rest/factbook"); 
      
    // Establish the connection to the URL. 
    HttpURLConnection conn = (HttpURLConnection) url.openConnection(); 
    // Set as DELETE request. 
    conn.setRequestMethod("DELETE"); 
     
    // User and password.
    String user = "bob";
    String pw ="alice";
    // Encode username and password pair with a base64 implementation.
    String encoded = Base64.encode(user + ":" + pw);
    // Basic access authentication header to connection request.
    conn.setRequestProperty("Authorization", "Basic " + encoded);
      
    // Print the HTTP response code. 
    System.out.println("HTTP response: " + conn.getResponseCode()); 
      
    // Close connection. 
    conn.disconnect(); 
  }
}

Content-Types

The content-type of the input can easily be included, just add the following property to

the connection (in this example we explicitly store the input file as raw):

// store input as raw
conn.setRequestProperty("Content-Type", "application/octet-stream");

See the PUT Requests section for a description of the possible content-types.

Find Java examples for all methods here: GET, POST, PUT, DELETE.

Command Line

Tools such as the Linux commands Wget or cURL exist to perform HTTP requests (try copy & paste):

GET

curl -i "http://localhost:8080/rest/factbook?query=//city/name"

POST

curl -i -X POST -H "Content-Type: application/xml" -d "<query xmlns='http://basex.org/rest'><text>//city/name</text></query>" "http://localhost:8080/rest/factbook"
curl -i -X POST -H "Content-Type: application/xml" -T query.xml "http://localhost:8080/rest/factbook"

PUT

curl -i -X PUT -T "etc/xml/factbook.xml" "http://localhost:8080/rest/factbook"
curl -i -X PUT -H "Content-Type: application/json" -T "plain.json" "http://localhost:8080/rest/plain"

DELETE

curl -i -X DELETE "http://admin:admin@localhost:8080/rest/factbook"

Changelog

Version 11.0

Updated: Request: The extensions .xq and .bxs are successively attached to the supplied filename.
Updated: Assigning Variables: Support for multiple values.

Version 10.0

Updated: Results in the rest namespace will be returned unprefixed.
Updated: dir elements are returned when listing the contents of a database.

Version 9.0

Added: Support for command scripts in the POST Method.
Updated: The REST namespace in the POST Method has become optional.

Version 8.1

Added: Support for input-specific content-type parameters
Updated: The run operation now resolves file paths against the RESTPATH option.

Version 8.0

Removed: wrap parameter

Version 7.9

Updated: Also evaluate command scripts via the run operation.

Version 7.2

Removed: Direct evaluation of adresses resources with application/xquery as content type

Version 7.1.1

Added: options parameter for specifying database options

Version 7.1

Added: PUT request: automatic conversion to XML if known content type is specified

Version 7.0

Added: The REST API was introduced with Version 7.0, replacing the old JAX-RX API.

⚡Generated with XQuery