ArangoDB Module

    This module should not be confused with thewhich can be used to access ArangoDB from outside the database. Although theAPIs share similarities and the functionality overlaps, the two are notcompatible with each other and can not be used interchangeably.

    arangodb.db

    The db object represents the current database and lets you access collections and run queries. For more information see the db object reference.

    Examples

    The aql template tag

    arangodb.aql

    The aql function is a JavaScript template string handler (or template tag).It can be used to write complex AQL queries as multi-line strings withouthaving to worry about bindVars and the distinction between collectionsand regular parameters.

    To use it just prefix a JavaScript template string (the ones with backticksinstead of quotes) with its import name (e.g. aql) and pass in variableslike you would with a regular template string. The string will automaticallybe converted into an object with query and bindVars attributes which youcan pass directly to db._query to execute. If you pass in a collection itwill be automatically recognized as a collection referenceand handled accordingly.

    Starting with ArangoDB 3.4 queries generated using the aql template tag canbe used inside other aql template strings, allowing arbitrary nesting. Bindparameters of nested queries will be merged automatically.

    Examples

    2. const filterValue = 23;
    3. const mydata = db._collection('mydata');
    4. const result = db._query(aql`
    5.   FOR d IN ${mydata}
    6.   FILTER d.num > ${filterValue}
    7.   RETURN d
    8. `).toArray();
    10. // nested queries
    12. const color = "green";
    13. const filterByColor = aql`FILTER d.color == ${color}'`;
    14. const result2 = db._query(aql`
    15.   FOR d IN ${mydata}
    16.   ${filterByColor}
    17.   RETURN d
    18. `).toArray();

    arangodb.aql.literal

    The aql.literal helper can be used to mark strings to be inlined into an AQLquery when using the aql template tag, rather than being treated as a bindparameter.

    Any value passed to aql.literal will be treated as part of the AQL query.To avoid becoming vulnerable to AQL injection attacks you should always prefernested queries if possible.

    Examples

    The aql.join helper

    arangodb.aql.join

    The aql.join helper takes an array of queries generated using the aql tagand combines them into a single query. The optional second argument will beused as literal string to combine the queries.

    2. // Basic usage
    3. const parts = [aql`FILTER`, aql`x`, aql`%`, aql`2`];
    4. const joined = aql.join(parts); // aql`FILTER x % 2`
    6. // Merge without the extra space
    7. const parts = [aql`FIL`, aql`TER`];
    8. const joined = aql.join(parts, ''); // aql`FILTER`;
    10. // Real world example: translate keys into document lookups
    11. const users = db._collection("users");
    12. const keys = ["abc123", "def456"];
    13. const docs = keys.map(key => aql`DOCUMENT(${users}, ${key})`);
    14. const aqlArray = aql`[${aql.join(docs, ", ")}]`;
    15. const result = db._query(aql`
    16.   FOR d IN ${aqlArray}
    17.   RETURN d
    18. `).toArray();
    19. // Query:
    20. //   FOR d IN [DOCUMENT(@@value0, @value1), DOCUMENT(@@value0, @value2)]
    21. //   RETURN d
    22. // Bind parameters:
    23. //   @value0: "users"
    24. //   value1: "abc123"
    25. //   value2: "def456"
    26. // Alternative without `aql.join`
    27. const users = db._collection("users");
    28. const keys = ["abc123", "def456"];
    30.   FOR key IN ${keys}
    31.   LET d = DOCUMENT(${users}, key)
    32.   RETURN d
    33. `).toArray();
    34. // Query:
    35. //   FOR key IN @value0
    36. //   LET d = DOCUMENT(@@value1, key)
    37. //   RETURN d
    38. // Bind parameters:
    39. //   value0: ["abc123", "def456"]
    40. //   @value1: "users"

    arangodb.query

    The errors object

    arangodb.errors

    This object provides useful objects for each error code ArangoDB might use in ArangoError errors. This is helpful when trying to catch specific errors raised by ArangoDB, e.g. when trying to access a document that does not exist. Each object has a code property corresponding to the errorNum found on ArangoError errors.

    For a complete list of the error names and codes you may encounter see the .

    Examples

    1. const errors = require('@arangodb').errors;
    3. try {
    4.   someCollection.document('does-not-exist');
    5. } catch (e) {
    6.   if (e.isArangoError && e.errorNum === errors.ERROR_ARANGO_DOCUMENT_NOT_FOUND.code) {
    7.     throw new Error('Document does not exist');
    8.   }
    9.   throw new Error('Something went wrong');
    10. }

    arangodb.time

    This function provides the current time in seconds as a floating point value with microsecond precisison.

    This function can be used instead of Date.now() when additional precision is needed.

    Examples