HTTP interfaces for AQL queries

The HTTP API for AQL queries lets you to execute, track, kill, explain, and validate queries written in ArangoDB’s query language

Cursors

Results of AQL queries are returned as cursors in order to batch the communication between server and client. Each batch contains a number of documents and an indication if the current batch is the final batch. Depending on the query, the total number of documents in the result set may or may not be known in advance.

If the number of documents doesn’t exceed the batch size, the full query result is returned to the client in a single round-trip. If there are more documents, then the first batch is returned to the client and the client needs to use the cursor to retrieve the other batches.

In order to free up server resources, the client should delete a cursor as soon as it is no longer needed.

Single roundtrip

The server only transfers a certain number of result documents back to the client in one roundtrip. This number is controllable by the client by setting the batchSize attribute when issuing the query.

If the complete result can be transferred to the client in one go, the client does not need to issue any further request. The client can check whether it has retrieved the complete result set by checking the hasMore attribute of the result set. If it is set to false, then the client has fetched the complete result set from the server. In this case, no server-side cursor is created.

> curl --data @- -X POST --dump - http://localhost:8529/_api/cursor
{ "query" : "FOR u IN users LIMIT 2 RETURN u", "count" : true, "batchSize" : 2 }

HTTP/1.1 201 Created
Content-type: application/json

{
  "hasMore" : false,
  "error" : false,
  "result" : [
    {
      "name" : "user1",
      "_rev" : "210304551",
      "_key" : "210304551",
      "_id" : "users/210304551"
    },
    {
      "name" : "user2",
      "_rev" : "210304552",
      "_key" : "210304552",
      "_id" : "users/210304552"
    }
  ],
  "code" : 201,
  "count" : 2
}

Using a cursor

If the result set contains more documents than should be transferred in a single roundtrip (i.e. as set via the batchSize attribute), the server returns the first few documents and creates a temporary cursor. The cursor identifier is also returned to the client. The server puts the cursor identifier in the id attribute of the response object. Furthermore, the hasMore attribute of the response object is set to true. This is an indication for the client that there are additional results to fetch from the server.

Examples

Create and extract first batch:

> curl --data @- -X POST --dump - http://localhost:8529/_api/cursor
{ "query" : "FOR u IN users LIMIT 5 RETURN u", "count" : true, "batchSize" : 2 }

HTTP/1.1 201 Created
Content-type: application/json

{
  "hasMore" : true,
  "error" : false,
  "id" : "26011191",
  "result" : [
    {
      "name" : "user1",
      "_rev" : "258801191",
      "_key" : "258801191",
      "_id" : "users/258801191"
    },
    {
      "name" : "user2",
      "_rev" : "258801192",
      "_key" : "258801192",
      "_id" : "users/258801192"
    }
  ],
  "code" : 201,
  "count" : 5
}

Extract next batch, still have more:

> curl -X POST --dump - http://localhost:8529/_api/cursor/26011191

HTTP/1.1 200 OK
Content-type: application/json

{
  "hasMore" : true,
  "error" : false,
  "id" : "26011191",
  "result": [
    {
      "name" : "user3",
      "_rev" : "258801193",
      "_key" : "258801193",
      "_id" : "users/258801193"
    },
    {
      "name" : "user4",
      "_rev" : "258801194",
      "_key" : "258801194",
      "_id" : "users/258801194"
    }
  ],
  "code" : 200,
  "count" : 5
}

Extract next batch, done:

> curl -X POST --dump - http://localhost:8529/_api/cursor/26011191

HTTP/1.1 200 OK
Content-type: application/json

{
  "hasMore" : false,
  "error" : false,
  "result" : [
    {
      "name" : "user5",
      "_rev" : "258801195",
      "_key" : "258801195",
      "_id" : "users/258801195"
    }
  ],
  "code" : 200,
  "count" : 5
}

Do not do this because hasMore now has a value of false:

> curl -X POST --dump - http://localhost:8529/_api/cursor/26011191

HTTP/1.1 404 Not Found
Content-type: application/json

{
  "errorNum": 1600,
  "errorMessage": "cursor not found: disposed or unknown cursor",
  "error": true,
  "code": 404
}

The response object contains a nextBatchId attribute, except for the last batch (when hasMore is false). If the allowRetry query option is set to true and if retrieving a result batch fails because of a connection issue, you can ask for that batch again using the POST /_api/cursor/<cursor-id>/<batch-id> endpoint. The first batch has an ID of 1 and the value is incremented by 1 with every batch. Every result response except the last one also includes a nextBatchId attribute, indicating the ID of the batch after the current. You can remember and use this batch ID should retrieving the next batch fail.

> curl --data @- -X POST --dump - http://localhost:8529/_api/cursor
{ "query": "FOR i IN 1..5 RETURN i", "batchSize": 2, "options": { "allowRetry": true } }

HTTP/1.1 201 Created
Content-type: application/json

{
  "result":[1,2],
  "hasMore":true,
  "id":"3517",
  "nextBatchId":2,
  "cached":false,
  "error":false,
  "code":201
}

Fetching the second batch would look like this:

> curl -X POST --dump - http://localhost:8529/_api/cursor/3517

Assuming the above request fails because of a connection issue but advances the cursor nonetheless, you can retry fetching the batch using the nextBatchId of the first request (2):

curl -X POST --dump http://localhost:8529/_api/cursor/3517/2

{
  "result":[3,4],
  "hasMore":true,
  "id":"3517",
  "nextBatchId":3,
  "cached":false,
  "error":false,
  "code":200
}

To allow refetching of the last batch of the query, the server cannot automatically delete the cursor. After the first attempt of fetching the last batch, the server would normally delete the cursor to free up resources. As you might need to reattempt the fetch, it needs to keep the final batch when the allowRetry option is enabled. Once you successfully received the last batch, you should call the DELETE /_api/cursor/<cursor-id> endpoint so that the server doesn’t unnecessarily keep the batch until the cursor times out (ttl query option).

curl -X POST --dump http://localhost:8529/_api/cursor/3517/3

{
  "result":[5],
  "hasMore":false,
  "id":"3517",
  "cached":false,
  "error":false,
  "code":200
}

curl -X DELETE --dump http://localhost:8529/_api/cursor/3517

{
  "id":"3517",
  "error":false,
  "code":202
}

If you are no longer interested in the results of a query, you can call the DELETE /_api/cursor/<cursor-id> endpoint as long as a cursor exists to discard the cursor, even before you requested the last batch.

Execute AQL queries

Create a cursor

POST /_db/{database-name}/_api/cursor

Submits an AQL query for execution in the current database. The server returns a result batch and may indicate that further batches need to be fetched using a cursor identifier.

The query details include the query string plus optional query options and bind parameters. These values need to be passed in a JSON representation in the body of the POST request.

Path Parameters

database-name* string
The name of the database.

Query Parameters

HTTP Headers

x-arango-allow-dirty-read boolean
Set this header to true to allow the Coordinator to ask any shard replica for the data, not only the shard leader. This may result in “dirty reads”.
The header is ignored if this operation is part of a Stream Transaction (x-arango-trx-id header). The header set when creating the transaction decides about dirty reads for the entire transaction, not the individual read operations.
x-arango-trx-id string
To make this operation a part of a Stream Transaction, set this header to the transaction ID returned by the POST /_api/transaction/begin call.

Request Body application/json object

batchSize integer
maximum number of result documents to be transferred from the server to the client in one roundtrip. If this attribute is not set, a server-controlled default value will be used. A batchSize value of 0 is disallowed.
bindVars object
An object with key/value pairs representing the bind parameters. For a bind variable @var in the query, specify the value using an attribute with the name var. For a collection bind variable @@coll, use @coll as the attribute name. For example: "bindVars": { "var": 42, "@coll": "products" }.
cache boolean
flag to determine whether the AQL query results cache shall be used. If set to false, then any query cache lookup will be skipped for the query. If set to true, it will lead to the query cache being checked for the query if the query cache mode is either on or demand.
count boolean
indicates whether the number of documents in the result set should be returned in the “count” attribute of the result. Calculating the “count” attribute might have a performance impact for some queries in the future so this option is turned off by default, and “count” is only returned when requested.
memoryLimit integer
the maximum number of memory (measured in bytes) that the query is allowed to use. If set, then the query will fail with error “resource limit exceeded” in case it allocates too much memory. A value of 0 indicates that there is no memory limit.
options object
key/value object with extra options for the query.
- allowDirtyReads boolean
  If you set this option to true and execute the query against a cluster deployment, then the Coordinator is allowed to read from any shard replica and not only from the leader.
  You may observe data inconsistencies (dirty reads) when reading from followers, namely obsolete revisions of documents because changes have not yet been replicated to the follower, as well as changes to documents before they are officially committed on the leader.
  This feature is only available in the Enterprise Edition.
- allowRetry boolean
  Set this option to true to make it possible to retry fetching the latest batch from a cursor. The default is false.
  If retrieving a result batch fails because of a connection issue, you can ask for that batch again using the POST /_api/cursor/<cursor-id>/<batch-id> endpoint. The first batch has an ID of 1 and the value is incremented by 1 with every batch. Every result response except the last one also includes a nextBatchId attribute, indicating the ID of the batch after the current. You can remember and use this batch ID should retrieving the next batch fail.
  You can only request the latest batch again (or the next batch). Earlier batches are not kept on the server-side. Requesting a batch again does not advance the cursor.
  You can also call this endpoint with the next batch identifier, i.e. the value returned in the nextBatchId attribute of a previous request. This advances the cursor and returns the results of the next batch. This is only supported if there are more results in the cursor (i.e. hasMore is true in the latest batch).
  From v3.11.1 onward, you may use the POST /_api/cursor/<cursor-id>/<batch-id> endpoint even if the allowRetry attribute is false to fetch the next batch, but you cannot request a batch again unless you set it to true.
  To allow refetching of the very last batch of the query, the server cannot automatically delete the cursor. After the first attempt of fetching the last batch, the server would normally delete the cursor to free up resources. As you might need to reattempt the fetch, it needs to keep the final batch when the allowRetry option is enabled. Once you successfully received the last batch, you should call the DELETE /_api/cursor/<cursor-id> endpoint so that the server doesn’t unnecessarily keep the batch until the cursor times out (ttl query option).
- failOnWarning boolean
  When set to true, the query will throw an exception and abort instead of producing a warning. This option should be used during development to catch potential issues early. When the attribute is set to false, warnings will not be propagated to exceptions and will be returned with the query result. There is also a server configuration option --query.fail-on-warning for setting the default value for failOnWarning so it does not need to be set on a per-query level.
- fillBlockCache boolean
  if set to true or not specified, this will make the query store the data it reads via the RocksDB storage engine in the RocksDB block cache. This is usually the desired behavior. The option can be set to false for queries that are known to either read a lot of data which would thrash the block cache, or for queries that read data which are known to be outside of the hot set. By setting the option to false, data read by the query will not make it into the RocksDB block cache if not already in there, thus leaving more room for the actual hot set.
- fullCount boolean
  if set to true and the query contains a LIMIT clause, then the result will have an extra attribute with the sub-attributes stats and fullCount, { ... , "extra": { "stats": { "fullCount": 123 } } }. The fullCount attribute will contain the number of documents in the result before the last top-level LIMIT in the query was applied. It can be used to count the number of documents that match certain filter criteria, but only return a subset of them, in one go. It is thus similar to MySQL’s SQL_CALC_FOUND_ROWS hint. Note that setting the option will disable a few LIMIT optimizations and may lead to more documents being processed, and thus make queries run longer. Note that the fullCount attribute may only be present in the result if the query has a top-level LIMIT clause and the LIMIT clause is actually used in the query.
- intermediateCommitCount integer
  The maximum number of operations after which an intermediate commit is performed automatically.
- intermediateCommitSize integer
  The maximum total size of operations after which an intermediate commit is performed automatically.
- maxDNFConditionMembers integer
  A threshold for the maximum number of OR sub-nodes in the internal representation of an AQL FILTER condition.
  Yon can use this option to limit the computation time and memory usage when converting complex AQL FILTER conditions into the internal DNF (disjunctive normal form) format. FILTER conditions with a lot of logical branches (AND, OR, NOT) can take a large amount of processing time and memory. This query option limits the computation time and memory usage for such conditions.
  Once the threshold value is reached during the DNF conversion of a FILTER condition, the conversion is aborted, and the query continues with a simplified internal representation of the condition, which cannot be used for index lookups.
  You can set the threshold globally instead of per query with the --query.max-dnf-condition-members startup option.
- maxNodesPerCallstack integer
  The number of execution nodes in the query plan after that stack splitting is performed to avoid a potential stack overflow. Defaults to the configured value of the startup option --query.max-nodes-per-callstack.
  This option is only useful for testing and debugging and normally does not need any adjustment.
- maxNumberOfPlans integer
  Limits the maximum number of plans that are created by the AQL query optimizer.
- maxRuntime number
  The query has to be executed within the given runtime or it is killed. The value is specified in seconds. The default value is 0.0 (no timeout).
- maxTransactionSize integer
  The transaction size limit in bytes.
- maxWarningCount integer
  Limits the maximum number of warnings a query will return. The number of warnings a query will return is limited to 10 by default, but that number can be increased or decreased by setting this attribute.
- optimizer object
  Options related to the query optimizer.
  rules array of strings
  A list of to-be-included or to-be-excluded optimizer rules can be put into this attribute, telling the optimizer to include or exclude specific rules. To disable a rule, prefix its name with a -, to enable a rule, prefix it with a +. There is also a pseudo-rule all, which matches all optimizer rules. -all disables all rules.
- profile integer
  If set to true or 1, then the additional query profiling information is returned in the profile sub-attribute of the extra return attribute, unless the query result is served from the query cache. If set to 2, the query includes execution stats per query plan node in stats.nodes sub-attribute of the extra return attribute. Additionally, the query plan is returned in the extra.plan sub-attribute.
- satelliteSyncWait number
  This Enterprise Edition parameter allows to configure how long a DB-Server has time to bring the SatelliteCollections involved in the query into sync. The default value is 60.0 seconds. When the maximal time is reached, the query is stopped.
- skipInaccessibleCollections boolean
  Let AQL queries (especially graph traversals) treat collection to which a user has no access rights for as if these collections are empty. Instead of returning a forbidden access error, your queries execute normally. This is intended to help with certain use-cases: A graph contains several collections and different users execute AQL queries on that graph. You can naturally limit the accessible results by changing the access rights of users on collections.
  This feature is only available in the Enterprise Edition.
- spillOverThresholdMemoryUsage integer
  This option allows queries to store intermediate and final results temporarily on disk if the amount of memory used (in bytes) exceeds the specified value. This is used for decreasing the memory usage during the query execution.
  This option only has an effect on queries that use the SORT operation but without a LIMIT, and if you enable the spillover feature by setting a path for the directory to store the temporary data in with the --temp.intermediate-results-path startup option.
  Default value: 128MB.
  Spilling data from RAM onto disk is an experimental feature and is turned off by default. The query results are still built up entirely in RAM on Coordinators and single servers for non-streaming queries. To avoid the buildup of the entire query result in RAM, use a streaming query (see the stream option).
- spillOverThresholdNumRows integer
  This option allows queries to store intermediate and final results temporarily on disk if the number of rows produced by the query exceeds the specified value. This is used for decreasing the memory usage during the query execution. In a query that iterates over a collection that contains documents, each row is a document, and in a query that iterates over temporary values (i.e. FOR i IN 1..100), each row is one of such temporary values.
  This option only has an effect on queries that use the SORT operation but without a LIMIT, and if you enable the spillover feature by setting a path for the directory to store the temporary data in with the --temp.intermediate-results-path startup option.
  Default value: 5000000 rows.
  Spilling data from RAM onto disk is an experimental feature and is turned off by default. The query results are still built up entirely in RAM on Coordinators and single servers for non-streaming queries. To avoid the buildup of the entire query result in RAM, use a streaming query (see the stream option).
- stream boolean
  Can be enabled to execute the query lazily. If set to true, then the query is executed as long as necessary to produce up to batchSize results. These results are returned immediately and the query is suspended until the client asks for the next batch (if there are more results). Depending on the query this can mean that the first results will be available much faster and that less memory is needed because the server only needs to store a subset of results at a time. Read-only queries can benefit the most, unless SORT without index or COLLECT are involved that make it necessary to process all documents before a partial result can be returned. It is advisable to only use this option for queries without exclusive locks.
  Remarks:
  The query will hold resources until it ends (such as RocksDB snapshots, which prevents compaction to some degree). Writes will be in memory until the query is committed.
  If existing documents are modified, then write locks are held on these documents and other queries trying to modify the same documents will fail because of this conflict.
  A streaming query may fail late because of a conflict or for other reasons after some batches were already returned successfully, possibly rendering the results up to that point meaningless.
  The query options cache, count and fullCount are not supported for streaming queries.
  Query statistics, profiling data and warnings are delivered as part of the last batch.
  If the stream option is false (default), then the complete result of the query is calculated before any of it is returned to the client. The server stores the full result in memory (on the contacted Coordinator if in a cluster). All other resources are freed immediately (locks, RocksDB snapshots). The query will fail before it returns results in case of a conflict.
query* string
contains the query string to be executed
ttl integer
The time-to-live for the cursor (in seconds). If the result set is small enough (less than or equal to batchSize) then results are returned right away. Otherwise they are stored in memory and will be accessible via the cursor with respect to the ttl. The cursor will be removed on the server automatically after the specified amount of time. This is useful to ensure garbage collection of cursors that are not fully fetched by clients. If not set, a server-defined value will be used (default: 30 seconds). The time-to-live is renewed upon every access to the cursor.

Responses

201 Created
is returned if the result set can be created by the server.
- cached* boolean
  A boolean flag indicating whether the query result was served from the query cache or not. If the query result is served from the query cache, the extra return attribute will not contain any stats sub-attribute and no profile sub-attribute.
- code* integer
  The HTTP status code.
- count integer
  The total number of result documents available (only available if the query was executed with the count attribute set).
- error* boolean
  A flag to indicate that an error occurred (false in this case).
- extra object
  An optional JSON object with extra information about the query result.
  Only delivered as part of the first batch, or the last batch in case of a cursor with the stream option enabled.
  plan object
  The execution plan.
  collections* array of objects
  A list of the collections involved in the query. The list only includes the collections that can statically be determined at query compile time.
  name* string
  The collection name.
  type* string
  How the collection is used. Can be "read", "write", or "exclusive".
  estimatedCost* number
  The estimated cost of the query.
  estimatedNrItems* integer
  The estimated number of results.
  isModificationQuery* boolean
  Whether the query contains write operations.
  nodes* array of objects
  A nested list of the execution plan nodes.
  rules* array of strings
  A list with the names of the applied optimizer rules.
  variables* array of objects
  All of the query variables, including user-created and internal ones.
  profile object
  The duration of the different query execution phases in seconds.
  executing* number
  finalizing* number
  initializing* number
  instantiating executors* number
  instantiating plan* number
  loading collections* number
  optimizing ast* number
  optimizing plan* number
  parsing* number
  stats* object
  An object with query statistics.
  cacheHits* integer
  The total number of index entries read from in-memory caches for indexes of type edge or persistent. This value is only non-zero when reading from indexes that have an in-memory cache enabled, and when the query allows using the in-memory cache (i.e. using equality lookups on all index attributes).
  cacheMisses* integer
  The total number of cache read attempts for index entries that could not be served from in-memory caches for indexes of type edge or persistent. This value is only non-zero when reading from indexes that have an in-memory cache enabled, the query allows using the in-memory cache (i.e. using equality lookups on all index attributes) and the looked up values are not present in the cache.
  cursorsCreated* integer
  The total number of cursor objects created during query execution. Cursor objects are created for index lookups.
  cursorsRearmed* integer
  The total number of times an existing cursor object was repurposed. Repurposing an existing cursor object is normally more efficient compared to destroying an existing cursor object and creating a new one from scratch.
  documentLookups* integer
  The number of real document lookups caused by late materialization as well as IndexNodes that had to load document attributes not covered by the index. This is how many documents had to be fetched from storage after an index scan that initially covered the attribute access for these documents.
  executionTime* number
  The query execution time (wall-clock time) in seconds.
  filtered* integer
  The total number of documents removed after executing a filter condition in a FilterNode or another node that post-filters data. Note that nodes of the IndexNode type can also filter documents by selecting only the required index range from a collection, and the filtered value only indicates how much filtering was done by a post filter in the IndexNode itself or following FilterNode nodes. Nodes of the EnumerateCollectionNode and TraversalNode types can also apply filter conditions and can report the number of filtered documents.
  fullCount integer
  The total number of documents that matched the search condition if the query’s final top-level LIMIT operation were not present. This attribute may only be returned if the fullCount option was set when starting the query and only contains a sensible value if the query contains a LIMIT operation on the top level.
  httpRequests* integer
  The total number of cluster-internal HTTP requests performed.
  intermediateCommits* integer
  The number of intermediate commits performed by the query. This is only non-zero for write queries, and only for queries that reached either the intermediateCommitSize or intermediateCommitCount thresholds. Note: in a cluster, intermediate commits can happen on each participating DB-Server.
  nodes array of objects
  When the query is executed with the profile option set to at least 2, then this attribute contains runtime statistics per query execution node. For a human readable output, you can execute db._profileQuery(<query>, <bind-vars>) in arangosh.
  calls* integer
  The number of calls to this node.
  id* integer
  The execution node ID to correlate the statistics with the plan returned in the extra attribute.
  items* integer
  The number of items returned by this node. Items are the temporary results returned at this stage.
  runtime* number
  The execution time of this node in seconds.
  peakMemoryUsage* integer
  The maximum memory usage of the query while it was running. In a cluster, the memory accounting is done per shard, and the memory usage reported is the peak memory usage value from the individual shards. Note that to keep things lightweight, the per-query memory usage is tracked on a relatively high level, not including any memory allocator overhead nor any memory used for temporary results calculations (e.g. memory allocated/deallocated inside AQL expressions and function calls).
  scannedFull* integer
  The total number of documents iterated over when scanning a collection without an index. Documents scanned by subqueries are included in the result, but operations triggered by built-in or user-defined AQL functions are not.
  scannedIndex* integer
  The total number of documents iterated over when scanning a collection using an index. Documents scanned by subqueries are included in the result, but operations triggered by built-in or user-defined AQL functions are not.
  seeks* integer
  The number of seek calls done by RocksDB iterators for merge joins (JoinNode in the execution plan).
  writesExecuted* integer
  The total number of data-modification operations successfully executed.
  writesIgnored* integer
  The total number of data-modification operations that were unsuccessful, but have been ignored because of the ignoreErrors query option.
  warnings* array of objects
  A list of query warnings.
  code* integer
  An error code.
  message* string
  A description of the problem.
- hasMore* boolean
  A boolean indicator whether there are more results available for the cursor on the server.
  Note that even if hasMore returns true, the next call might still return no documents. Once hasMore is false, the cursor is exhausted and the client can stop asking for more results.
- id string
  The ID of the cursor for fetching more result batches.
- nextBatchId string
  Only set if the allowRetry query option is enabled in v3.11.0. From v3.11.1 onward, this attribute is always set, except in the last batch.
  The ID of the batch after the current one. The first batch has an ID of 1 and the value is incremented by 1 with every batch. You can remember and use this batch ID should retrieving the next batch fail. Use the POST /_api/cursor/<cursor-id>/<batch-id> endpoint to ask for the batch again. You can also request the next batch.
- result array
  An array of result documents for the current batch (might be empty if the query has no results).
400 Bad Request
is returned if the JSON representation is malformed, the query specification is missing from the request, or if the query is invalid.
The body of the response contains a JSON object with additional error details. The object has the following attributes:
- code* integer
  the HTTP status code
- error* boolean
  boolean flag to indicate that an error occurred (true in this case)
- errorMessage* string
  A descriptive error message.
  If the query specification is complete, the server will process the query. If an error occurs during query processing, the server will respond with HTTP 400. Again, the body of the response will contain details about the error.
- errorNum* integer
  the server error number
404 Not Found
The server will respond with HTTP 404 in case a non-existing collection is accessed in the query.
405 Method Not Allowed
The server will respond with HTTP 405 if an unsupported HTTP method is used.
410 Gone
The server will respond with HTTP 410 if a server which processes the query or is the leader for a shard which is used in the query stops responding, but the connection has not been closed.
503 Service Unavailable
The server will respond with HTTP 503 if a server which processes the query or is the leader for a shard which is used in the query is down, either for going through a restart, a failure or connectivity issues.

Examples

Execute a query and extract the result in a single go

curl -X POST --header 'accept: application/json' --data-binary @- --dump - 'http://localhost:8529/_api/cursor' <<'EOF'
{
  "query": "FOR p IN products LIMIT 2 RETURN p",
  "count": true,
  "batchSize": 2
}
EOF

HTTP interfaces for AQL queries

Cursors

Single roundtrip

Using a cursor

Execute AQL queries

Create a cursor

Read the next batch from a cursor

Read the next batch from a cursor (deprecated)

Read a batch from the cursor again

Delete a cursor

Track queries

Get the AQL query tracking configuration

Update the AQL query tracking configuration

List the running AQL queries

List the slow AQL queries

Clear the list of slow AQL queries

Kill queries

Kill a running AQL query

Explain and parse AQL queries

Explain an AQL query

Parse an AQL query

List all AQL optimizer rules