ArangoDB Changelog

What's new in ArangoDB 3.11.4

Oct 19, 2023

LZ4 compression for values in the in-memory edge cache:
LZ4 compression of edge index cache values allows to store more data in main memory than without compression, so the available memory can be used more efficiently. The compression is transparent and does not require any change to queries or applications. The compression can add CPU overhead for compressing values when storing them in the cache, and for decompressing values when fetching them from the cache.
The new startup option --cache.min-value-size-for-edge-compression can be used to set a threshold value size for compression edge index cache payload values. The default value is 1GB, which effectively turns compression off. Setting the option to a lower value (i.e. 100) turns on the compression for any payloads whose size exceeds this value.
The new startup option --cache.acceleration-factor-for-edge-compression can be used to fine-tune the compression. The default value is 1. Higher values typically mean less compression but faster speeds.
The following new metrics can be used to determine the usefulness of compression:
rocksdb_cache_edge_inserts_effective_entries_size_total: returns the total number of bytes of all entries that were ever stored in the in-memory edge cache, after compression was attempted/applied. This metric is populated regardless of whether compression is used or not.
rocksdb_cache_edge_inserts_uncompressed_entries_size_total: returns the total number of bytes of all entries that were ever stored in the in-memory edge cache, before compression was applied. This metric is populated regardless of whether compression is used or not.
rocksdb_cache_edge_compression_ratio: returns the effective compression ratio for all edge cache entries ever stored in the cache.
Note that these metrics are increased upon every insertion into the edge cache, but not decreased when data gets evicted from the cache.

New in ArangoDB 3.11.2 (Jul 27, 2023)

Bug fixes:
Fix SEARCH-465: Truncate on ArangoSearch index could release a WAL if commit passed.
Updated ArangoDB Starter to 0.16.0.
Avoid recursive lock during agency startup.
Fixed issue with lock starvation when an AQL insert operation with multiple static documents was executed as part of a streaming transaction.
Added startup option `--database.max-databases` to limit the maximum number of databases that can exist in parallel on a deployment. This option can be used to limit resources used by database objects. If the option is used and there already exist as many databases as configured by this option, any attempt to create an additional database will fail with error 32 (`ERROR_RESOURCE_LIMIT`). Additional databases can then only be created if other databases are dropped first. The default value for this option is unlimited, so technically an arbitrary amount of databases can be created (although effectively the number of databases is limited by memory and processing resources).
FE-304, FE-305: use navigator.onLine for checking internet connection, correct path for running/slow queries.
Enforce that server always returns an empty body if the return code is 204.
Arangodump retries dump requests in more cases: read, write and connection errors.
Whenever there is a query request timeout in AQL (e.g., a server died) which causes the query to fail, the DBServers will now all directly kill their potentially ongoing parts of the query and not wait for garbage collection.
Use libunwind in jemalloc profiling to make it available with libmusl and static binaries.
BTS-1331: Reduced the amount of required network calls when using traversals combined with FILTER and/or PRUNE statements in a GeneralGraph in combination with a clustered environment.
Added transparent LZ4 compression for values in the in-memory edge cache if their size exceeds a configurable threshold. This is configurable as an opt-in functionality.
LZ4 compression of edge index cache values allows to store more data in mai memory than without compression, so the available memory can be used more efficiently. The compression is transparent and does not require any change to
queries or applications. The compression can add CPU overhead for compressing values when storing them in the cache, and for decompressing values when fetching them from the cache.
The new startup option `--cache.min-value-size-for-edge-compression` can be used to set a threshold value size for compression edge index cache payload values. The default value is `1GB`, which will effectively turn compression off. Setting the option to a lower value (e.g. `100`) will turn on the compression for any payloads whose size exceeds this value.
The new startup option `--cache.acceleration-factor-for-edge-compression` can be used to fine-tune the compression. It controls the LZ4-internal "acceleration" factor used for the compression. The default value is `1`. Higher values typically mean less compression but faster speeds.
The following new metrics can be used to determine the usefulness of compression:
`rocksdb_cache_edge_effective_entries_size`: will return the total number of bytes of all entries that were stored in the in-memory edge cache, after compression was attempted/applied. This metric will be populated regardless of whether compression is used or not.
`rocksdb_cache_edge_uncompressed_entries_size`: will return the total number of bytes of all entries that were ever stored in the in-memory edge cache, before compression was applied. This metric will be populated regardless of whether compression is used or not.
`rocksdb_cache_edge_compression_ratio`: will return the effective compression ratio for all edge cache entries ever stored in the cache.
Note that these metrics will be increased upon every insertion into the edge cache, but not decreased when data gets evicted from the cache.
Optimize runtime performance of exclusive locks.
Added startup option `--replication.active-failover-leader-grace-period`. This startup option can be used to set the amount of time (in seconds) for which the current leader in an active failover setup will continue to assume its leadership even if it lost connection to the agency.
In case the leader cannot contact the agency anymore, the agency will elect a new leader after the supervision grace period has elapsed. In order to avoid a split-brain situation with multiple servers assuming leadership, this option can be used to make a disconnected leader refuse any incoming write operations after the grace period controled by this option has elapsed. Ideally the startup option should be given a value greater than the value of the supervision grace period, in order to avoid a temporarily disconnected leader giving up leadership too early and unnecessarily.
The default value is 120 seconds. Setting the option to a value of 0 will keep the existing behavior, in which a disconnected leader will not refuse incoming write operations.
Added new startup options `--cache.ideal-lower-fill-ratio` and `--cache.ideal-upper-fill-ratio` to control the minimum and maximum fill ratios for cache tables that trigger shrinking and growing of the table by the cache rebalancer. The default values are:
`0.04` (i.e. 4%) for the lower bound that triggers shrinking
`0.25` (i.e. 25%) for the upper bound that triggers growing
These values were hard-coded in previous versions of ArangoDB.
Remove temporary `CREATING_{number}` directories from hot backup in case a hot backup runs into an error.
BTS-1490: Allow performing AQL updates locally without using DISTRIBUTE in case the update AQL is of the pattern
FOR doc IN collection
UPDATE <doc> IN collection
Previously the optimization was only possible if the update AQL was of the pattern
FOR doc IN collection
UPDATE <key> WITH <doc> IN collection
Both <key> and <doc> refer to data from the collection enumeration variable `doc` here.
Also fix the optimization in case a shard key attribute is updated with a value from a different attribute, e.g.
FOR doc IN collection
UPDATE { _key: doc.abc, abc: doc._key } IN collection
In this case the optimization was previously applied although it shouldn't.
BTS-1490: query can use a lot more memory when using COLLECT WITH COUNT.
Attempt to avoid busy looping when locking collections with a timeout.
Add a `description` field to OptimizerRule and dump the explanations via the `GET /_api/query/rules` endpoint.
FE-20: fix UI placeholder format for locale when creating analyzers.
FE-240: disable JSON editor when viewing inverted index.
FE-287: fix number validation for replicationFactor and writeConcern.
FE-285: Fix query download - use post request for query.
Fixed Github issue #19175. This fixes a problem in traversal query optimization that was introduced in 3.11 and that can lead to traversal queries being aborted with an error `AQL: cannot and-combine normalized condition`.
Fixed two possible deadlocks which could occur if all medium priority threads are busy. One is that in this case the AgencyCache could no longer received updates from the agency and another that queries could no longer be finished. This fixes BTS-1475 and BTS-1486.

New in ArangoDB 3.11.1 (Jun 16, 2023)

Updated arangosync to v2.18.1.
SEARCH-480: Speedup ArangoSearch recovery.
SEARCH-476: Fix bug in fst builder.
BTS-1325: AQL: Fixed a possible deadlock with multiple parallel traversals.
Updated OpenSSL to 3.0.9.
BTS-1435: fixed invalid AQL optimization and added a safeguard.
APM-766, SEARCH-479: Reduce memory overhead for ArangoSearch removes.
Improve precision for ArangoSearch GEO_IN_RANGE function.
Updated ArangoDB Starter to 0.15.8.
OASIS-25262: Fixed undefined behavior in IN lookup in unique indexes when the
lookup array had to be rebuilt in memory.
Invalid keys are now reported as individual errors for batch insert operations
and no longer abort the whole batch.
BTS-1255: Fix sporadic memory usage accounting underflows in in-memory cache
subsystem.
Also turn the algorithm for freeing memory from a cache's buckets from a
non-deterministic one that did not guarantee progress into a bounded algorithm
with guaranteed progress.
ECONNABORTED is treated as a ConnectionClosed error in fuerte.
Database drop operation no longer fails if we cannot remove the corresponding
permissions from the _users collection.
Added startup option `--query.max-collections-per-query` to adjust the limit
for the maximum number of collections/shards per query. The option defaults to
`2048`, which is equivalent to the previous hardcoded value.
BTS-1261 For some named graphs in cluster, when creating a debugDump for a
traversal query that would use the graph's name, the graph wouldn't be able to
be recreated because the info gathered in the process of creating a debugDump
was broken. It uses the result form an aql explain to get the graph info and
use in the debugDump, but this wouldn't be available because, instead of
having the name of the graph as key in the graph object of the explain, there
would be an array with edge collection names. It was changed for the case when
there's a named graph, but maintained when there's no access to the graph's
name.
When trying to read multiple documents, the coordinator will now handle empty
lists gracefully and return an empty result set instead of an error.
Added metric "rocksdb_total_sst_files" to count the number of sst files,
aggregated over all levels of the LSM tree.
Increase too short timeouts for requests made from coordinators to DB-servers
when retrieving the number of documents or the index selectivity estimates for
SmartGraph edge collection parts. These parts were treated like system
collections because of their naming convention, and the requests were run with
a timeout of only 5s.
In batched query results, when executing requests for
`/_api/cursor/<cursorId>/<batchId>`, removed the restriction that the user
would only be able to fetch the next batch using the next batch id in
<batchId> if the query option `allowRetry` was set to true, but maintained the
restriction that the user can only retrieve the latest batch if the query
option `allowRetry` is set to true.
Add a startup parameter `--rclone.argument` which can be utilised to enable
debugging with logfiles in hot backup RClone upload operacions:
`--rclone.argument=--log-level=DEBUG`
`--rclone.argument=-log-file=/tmp/rclone.log`
Fix issue #18982: query editor null/undefined check filters out bindParams
with value 0.

New in ArangoDB 3.10.5 (Mar 23, 2023)

Stabilized resilience tests. The assumption that an AQL query can run without error directly after a leader has been stopped, is wrong.
Auto-flush RocksDB WAL files and in-memory column family data if the number of live WAL files exceeds a certain threshold. This is to make sure that WAL files are moved to the archive when there are a lot of live WAL files presen (e.g. after a restart; in this case RocksDB does not count any previously existing WAL files when calculating the size of WAL files and comparing it `max_total_wal_size`.
The feature can be configured via the following startup options: - `--rocksdb.auto-flush-min-live-wal-files`: minimum number of live WAL files that triggers an auto-flush. Defaults to `10`.
`--rocksdb.auto-flush-check-interval`: interval (in seconds) in which auto-flushes are executed. Defaults to `3600`.
Note that an auto-flush is only executed if the number of live WAL files exceeds the configured threshold and the last auto-flush is longer ago than the configured auto-flush check interval. That way too frequent auto-flushes can be avoided.
Fix potential memory under-accounting on cache shutdown for in-memory caches for edge indexes.
Added the following metrics for WAL file tracking:
`rocksdb_live_wal_files`: number of alive WAL files (not archived)
`rocksdb_wal_released_tick_flush`: lower bound sequence number from which onwards WAL files will be kept (i.e. not deleted from the archive) because of external flushing needs. Candidates for these are arangosearch links and background index creation.
`rocksdb_wal_released_tick_replication`: lower bound sequence number from which onwards WAL files will be kept because they may be needed by the replication.
`arangodb_flush_subscriptions`: number of currently active flush subscriptions.
Updated internal JavaScript dependencies:
@xmldom/xmldom: 0.8.0 -> 0.8.6
accepts: 1.3.7 -> 1.3.8
ajv: 8.10.0 -> 8.12.0
ansi_up: 5.0.1 -> 5.1.0
content-disposition: 0.5.3 -> 0.5.4
content-type: 1.0.4 -> 1.0.5
error-stack-parser: 2.0.6 -> 2.1.4
mime-types: 2.1.31 -> 2.1.35
semver: 7.3.5 -> 7.3.8
Updated transitive JS dependency hoek to @hapi/[email protected] to resolve CVE-2020-36604 in joi.
Updated JS dependency minimatch to 3.1.2 to resolve CVE-2022-3517.
Updated JS dependency qs to 6.11.0 to resolve CVE-2022-24999.
Updated arangosync to v2.15.0.
Allow usage of projections and covering indexes in more cases. Previously, projections were not used if there were complex filter conditions on the index attribute(s) that contained the `[*]` expansion operator with inline FILTERs or RETURNs, e.g. `FILTER doc.addrs[* FILTER CURRENT.country == 'US'].zip`.
PRESUPP-546: make AQL optimizer rule `simplify-conditions` correctly report that it was triggered. Previously that rule never reported that it was triggered although even though it actually was.
Added startup option `--rocksdb.auto-refill-index-caches-on-followers` to control whether automatic refilling of in-memory caches should happen on followers or just leaders. The default value is `true`, i.e. refilling happens on followers too.
Added new geo_s2 ArangoSearch analyzer (Enterprise Only).
GORDO-1554: Fixes invalid document insertion with invalid user-specified keys (e.g. numeric values) into EnterpriseGraph related vertices.
Added metric `arangodb_replication_clients` showing the number of currently active/connected replication clients for a server.
BTS-1249: Add startup option `--foxx.enable`. This startup option determines whether access to user-defined Foxx services is possible for the instance. It defaults to `true`. If the option is set to `false`, access to Foxx services is forbidden and will be responded with an HTTP 403 Forbidden error. Access to ArangoDB's built-i web interface, which is also a Foxx service, is still possible even with the option set to `false`.When setting the option to `false`, access to the management APIs for Foxx services will also be disabled. This is the same as manually setting the option `--foxx.api false`.
Fixed a bug in the API used by `arangorestore`: On restore, a new _rev value is generated for each imported document to avoid clashes with previously present data. This must be created on the shard leader rather than the coordinator. The bug happened, when two coordinators were creating the same _rev value for two different documents concurrently.
ES-1428: make the maximum number of V8 contexts depend on the maximum number of server threads, if `--javascript.v8-contexts` is not set explicitly. Previously the maximum number of V8 contexts was hard-coded to 16 when th option `--javascript.v8-contexts` option was not set explicitly. Now the maximum number defaults to 7/8 of the value of the startup option `--server.maximal-threads`, regardless of if it is explicitly configured or the default value is used. Only 7/8 are used to leave some headroom for other important maintenance tasks.
A server with default configuration should now not block waiting for V8 contexts to become available, but it may use more memory for the additional V8 contexts if there are many concurrent requests that invoke JavaScript actions(e.g. requests using the web UI or Foxx).
Improve memory usage of in-memory edge index cache if most of the edges in an index refer to a single or mostly the same collection. Previously the full edge ids, consisting of the the referred-to collection name and the referred-to key of the edge were stored in full. Now, the first edge inserted into an edge index' in-memory cache will determine the collection name for which all corresponding edges can be prefix-compressed. For example, when inserting an edge pointing to `the-collection/abc` into the empty cache, the collection name `the-collection` will be noted for that cache as a prefix. The edge will be stored in memory as only `/abc`. Further edges that are inserted into the cache and that point to the same collection will also be stored prefix-compressed. The prefix compression is transparent and does not require configuration or setup. Compression is done separately for each cache, i.e. a separate prefix can be used for each individual edge index, and separately for the `_from` and `_to` parts. Lookups from the in-memory edge cache will not return compressed values but the full-length edge ids. The compressed values will also be used in memory only and will not be persisted on disk.

New in ArangoDB 3.8.4 (Dec 3, 2021)

New in ArangoDB 3.8.3 (Nov 20, 2021)

In the shards overview the list of servers to move the leader shard to, now also contains the current followers. This means that from now on also active follower servers can be nominated as the leading server for that specific shard.
Fixed an issue in old incremental sync protocol with document keys that contained special characters (`%`). These keys could be send unencoded in the incremental sync protocol, leading to wrong key ranges being transfered between leader and follower, and thus causing follow-up errors and preventing getting in sync.
Extend Windows minidumps with memory regions referenced from CPU registers or the stack to provide more contextual information in case of crashes.
When using Indexes within traversals (e.g. [_from, date]) and filter based on a function (e.g. FILTER path.edges[0].date <= DATE_ADD(@now, 5, "day")) this function was passed through to the index. The index cannot evaluate this function and returned incorrect results. Now all functions are evaluted before looking into the index. Fixes BTS-407.
Fixed arangodump not overwriting dump directory when flags `--all-databases` and `--overwrite` are set to true.
Fix issues during rolling upgrades from 3.8.0 to 3.8.x (x >= 1) and from 3.7.x (x <= 12) to 3.8.3. The problem was that older versions did not handle following term ids that are sent from newer versions during synchronous replication operations.
Close a potential gap during shard synchronization when moving from the initial sync step to the WAL tailing step. In this small gap the leader could purge some of the WAL files that would be required by the following WAL tailing step. This was possible because at the end of the initial sync step, the snapshot on the leader is released, and there is a small window of time before the follower will issue its first WAL tailing request.
Improve Shards overview in web UI: the number of currently syncing shards is now displayed per collection. Additionally, shards on failed servers are now displayed in a different color.
Fixed BTS-637: Slow SynchronizeShard jobs which need to copy data could block quick SynchronizeShard jobs which have the data and only need to resync.
When enabling the cluster supervision maintenance mode via the web UI, there is now the possibility to select a duration for the maintenance mode. Previous versions of ArangoDB always enabled the maintenance mode for one hour, without allowing any choice here.
Fixed SEARCH-261: Fix possible race between file creation and directory cleaner (ArangoSearch).
Fixed SEARCH-260: Fix invalid sorting order of stored features in presence of primary sort (ArangoSearch).
DEVSUP-899: Fixed Subquery execution in a very rare case a subquery, nested in another subquery, was not executed, which is fixed now.
Technical details:
If we have two subqueries: `Outer` and `Nested` the Outer will define the input for Nested. And Outer has the pattern: 1 input, subqueryDone, 1 input, subqueryDone [...] and our internal batching did cut a batch like this:
[<...>, input (A)] | [subqueryDone, input (B), subqueryDone, <...>] than Nested on input (B) was not executed. As soon as we have more than 1 input per Outer, or a different cutting position, all was good.
Fixed potential undefined behavior in edge cache during cache migration tasks. There was a short window of time in which an already freed Table could be used by concurrently running edge lookups.
Improve performance of getting-in-sync protocol when using revision trees (for collections created with 3.8). The protocol optimization allows skipping the unused parts of the revision trees in the data transfer, which can substantially reduce the amount of data to be transfered for small and medium collections when trying to get back into sync.
Change error message for queries that use too much memory from "resource limit exceeded" to "query would use more memory than allowed".
arangorestore: Fix the order (regarding distributeShardsLike) in which collections are being created during restore, which could result in an error and make manual intervention necessary.

New in ArangoDB 3.7.13 (Jul 23, 2021)

New in ArangoDB 3.7.10 (Mar 19, 2021)

New in ArangoDB 3.7.9 (Mar 5, 2021)

Fix issue #13476: The Java driver v6.9.0 (and older) has bad performance when iterating over AQL cursor results in certain cases. This works around this.
This workaround will no longer be available in 3.8.
Enable statistics in web UI in non-`_system` databases in cluster mode.
In cluster mode, the web UI dashboard did not display statistics properly when not being logged in to the `_system` database. For all other databases than `_system`, no statistics were displayed but just some "No data..." placeholders.
Statistics for non-`_system` databases were not properly displayed since 3.7.6 due to an internal change in the statistics processing.
In addition, a new startup option `--server.statistics-all-databases` controls whether cluster statistics are displayed in the web interface for all databases (if the option is set to `true`) or just for the system database (if the option is set to `false`).
The default value for the option is `true`, meaning statistics will be displayed in the web interface for all databases.
Updated OpenSSL to 1.1.1j and OpenLDAP to 2.4.57.
Cleanup old HotBackup transfer jobs in agency.
Added logging of elapsed time of ArangoSearch commit/consolidation/cleanup jobs.
Fix too early stop of replication, when waiting for keys in large collections/shards.
Fixed issue BTS-268: fix a flaky Foxx self-heal procedure.
Fixed issue DEVSUP-720: Within an AQL query, the "COLLECT WITH COUNT INTO" statement could lead to a wrong count output when used in combination with an index which has been created with an array index attribute.
Fix profiling of AQL queries with the `silent` and `stream` options sets in combination. Using the `silent` option makes a query execute, but discard all its results instantly. This led to some confusion in streaming queries, which can return the first query results once they are available, but don't necessarily execute the full query.
Now, `silent` correctly discards all results even in streaming queries, but this has the effect that a streaming query will likely be executed completely when the `silent` option is set. This is not the default however, and the `silent` option is normally not set. There is no change for streaming queries if the `silent` option is not set.
As a side-effect of this change, this makes profiling (i.e. using
`db._profileQuery(...)` work for streaming queries as well. Previously, profiling a streaming query could have led to some internal errors, and even query results being returned, even though profiling a query should not return any query results.
Improved the wording for sharding options displayed in the web interface.
Instead of offering `flexible` and `single`, now use the more intuitive `Sharded` and `OneShard` options, and update the help text for them.
EE only bugfix: On DisjointSmartGraphs that are used in anonymous way, there was a chance that the query could fail, if non-disjoint collections were part of the query. Named DisjointSmartGraphs have been save to this bug.
Example:
DisjointSmartGraph (graph) on vertices -edges-> vertices
Query:
WITH vertices, unrelated
FOR out IN 1 OUTBOUND "v/1:1" edges
FOR u IN unrelated
RETURN [out, u]
The "unrelated" collection was pulled into the DisjointSmartGraph, causing the
AQL setup to create erroneous state.
This is now fixed and the above query works.
This query:
WITH vertices, unrelated
FOR out IN 1 OUTBOUND "v/1:1" GRAPH "graph"
FOR u IN unrelated
RETURN [out, u] was not affected by this bug.
Avoid a potential deadlock when dropping indexes.
A deadlock could theoretically happen for a thread that is attempting to dro an index in case there was another thread that tried to create or drop an index in the very same collection at the very same time. We haven't managed to trigger the deadlock with concurrency tests, so it may have been a theoretical issue only. The underlying code was changed anyway to make sure this will not cause problems in reality.
Make dropping of indexes in cluster retry in case of precondition failed.
When dropping an indexes of a collection in the cluster, the operation could fail with a "precondition failed" error in case there were simultaneous index creation or drop actions running for the same collection. The error was returned properly internally, but got lost at the point when `<collection>.dropIndex()` simply converted any error to just `false`.
We can't make `dropIndex()` throw an exception for any error, because that would affect downwards-compatibility. But in case there is a simultaneous change to the collection indexes, we can just retry our own operation and check if it succeeds then. This is what `dropIndex()` will do now.
Improve incremental sync replication for single server and cluster to cope with multiple secondary index unique constraint violations (before this was limited to a failure in a single unique secondary index). This allows replicating the leader state to the follower in basically any order, as any *other* conflicting documents in unique secondary indexes will be detected and removed on the follower.
Fix potential undefined behavior when iterating over connected nodes in an execution plan and calling callbacks for each of the nodes: if the callbacks modified the list of connected nodes of the current that they were called from, this could lead to potentially undefined behavior due to iterator invalidation. The issue occurred when using a debug STL via `_GLIBCXX_DEBUG`.
Fixed a RocksDB bug which could lead to an assertion failure when compiling with STL debug mode -D_GLIBCXX_DEBUG.
Fixed a rare internal buffer overflow around ridBuffers.
Issue #13141: The `move-filters-into-enumerate` optimization, when applied to an EnumerateCollectionNode (i.e. full collection scan), did not do regular checks for the query being killed during the filtering of documents, resulting in the maxRuntime option and manual kill of a query not working timely.
Do not create index estimator objects for proxy collection objects on coordinators and DB servers. Proxy objects are created on coordinators and DB servers for all shards, and they also make index objects available. In order to reduce the memory usage by these objects, we don't create any index estimator objects for indexes in those proxy objects. Index estimators usually take several KB of memory each, so not creating them will pay out for higher numbers of collections/shards.
Improvements for logging. This adds the following startup options to arangod:
`--log.max-entry-length`: controls the maximum line length for individual log messages that are written into normal logfiles by arangod (note: this does not include audit log messages).
Any log messages longer than the specified value will be truncated and the suffix '...' will be added to them. The purpose of this parameter is to shorten long log messages in case there is not a lot of space for logfiles, and to keep rogue log messages from overusing resources.
The default value is 128 MB, which is very high and should effectively mean downwards-compatiblity with previous arangod versions, which did not restrict the maximum size of log messages.
`--audit.max-entry-length`: controls the maximum line length for individual audit log messages that are written into audit logs by arangod. Any audit log messages longer than the specified value will be truncated and the suffix '...' will be added to them.
The default value is 128 MB, which is very high and should effectively mean downwards-compatiblity with previous arangod versions, which did not restrict the maximum size of log messages.
`--log.in-memory-level`: controls which log messages are preserved in memory. The default value is `info`, meaning all log messages of types `info`, `warning`, `error` and `fatal` will be stored by an instance in memory (this was also the behavior in previous versions of ArangoDB).
By setting this option to `warning`, only `warning` log messages will be preserved in memory, and by setting the option to `error` only error messages will be kept.
This option is useful because the number of in-memory log messages is limited to the latest 2048 messages, and these slots are by default shared between informational, warning and error messages.
Honor the value of startup option `--log.api-enabled` when set to `false`.
The desired behavior in this case is to turn off the REST API for logging, but was not implemented. The default value for the option is `true`, so the REST
API is enabled. This behavior did not change, and neither did the behavior when setting the option to a value of `jwt` (meaning the REST API for logging is only available for superusers with a valid JWT token).
Fix error reporting in the reloadTLS route.
Split the update operations for the _fishbowl system collection with Foxx apps into separate insert/replace and remove operations. This makes the overall update not atomic, but as removes are unlikely here, we can now get away with a simple multi-document insert-replace operation instead of a truncate and an exclusive transaction, which was used before.

New in ArangoDB 3.7.8 (Feb 18, 2021)

New in ArangoDB 3.7.7 (Feb 12, 2021)

Features and Improvements:
Wildcard search:
ArangoSearch was extended to support the LIKE() function and LIKE operator in AQL. This allows to check whether the given search pattern is contained in specified attribute using wildcard matching (_ for any single character and % for any sequence of characters including none)
Covering Indexes:
It is possible to directly store the values of document attributes in View indexes now via a new View property storedValues (not to be confused with the existing storeValues).
View indexes may fully cover SEARCH queries for improved performance. While late document materialization reduces the amount of fetched documents, this new optimization can avoid to access the storage engine entirely.
Stemming support for more languages:
The Snowball library was updated to the latest version 2
Create a custom Analyzer and set the locale accordingly in the properties, e.g. "el.utf-8" for Greek.
Condition Optimization Option:
The SEARCH operation in AQL accepts a new option conditionOptimization to give users control over the search criteria optimization
By default, all conditions get converted into disjunctive normal form (DNF). Numerous optimizations can be applied, like removing redundant or overlapping conditions (such as doc.val > 10 which is included by doc.val > 5). However, converting to DNF and optimizing the conditions can take quite some time even for a low number of nested conditions which produce dozens of conjunctions / disjunctions. It can be faster to just search the index without optimizations.
Primary Sort Compression Option:
There is a new option primarySortCompression which can be set on View creation to enable or disable the compression of the primary sort data
SatelliteGraphs:
When doing joins involving graph traversals, shortest path or k-shortest paths computation in an ArangoDB cluster, data has to be exchanged between different servers. In particular graph traversals are usually executed on a Coordinator, because they need global information. This results in a lot of network traffic and potentially slow query execution.
SatelliteGraphs are the natural extension of the concept of SatelliteCollections to graphs. All of the usual benefits and caveats apply. SatelliteGraphs are synchronously replicated to all DB-Servers that are part of a cluster, which enables DB-Servers to execute graph traversals locally. This includes (k-)shortest path(s) computation and possibly joins with traversals and greatly improves performance for such queries.
Disjoint SmartGraphs:
SmartGraphs have been extended with a new option isDisjoint. A Disjoint SmartGraph prohibits edges connecting different SmartGraph components. If your graph doesn’t need edges between vertices with different SmartGraph attribute values, then you should enable this option. This topology restriction allows the query optimizer to improve traversal execution times, because in many cases the execution can be pushed down to a single DB-Server.
AQL:
Subquery optimizations:
The execution process of AQL has been refactored internally. This especially pays off in subqueries. It will allow for more optimizations and better batching of requests.
The first stage of this refactoring has been part of 3.6 already where some subqueries have gained a significant performance boost. 3.7 takes the next step in this direction. AQL can now combine skipping and producing of outputs in a single call, so all queries with a LIMIT offset or the fullCount option enabled will benefit from this change straight away. This also holds true for subqueries, hence the existing AQL optimizer rule splice-subqueries is now able to optimize all subqueries and is enabled by default.
The query planner can now also reuse internal registers that were allocated for storing temporary results inside subqueries, but not outside of subqueries.
Count optimizations:
Subqueries can now use an optimized code path for counting documents if they are supposed to only return the number of matching documents. The optimization will be triggered for read-only subqueries that use a full collection scan or an index scan, without any additional filtering on document attributes (early pruning or document post-filtering) and without using LIMIT.
Traversal optimizations:
Graph traversal performance is improved via some internal code refactoring:
Traversal cursors are reused instead of recreated from scratch, if possible. This can save lots of calls to the memory management subsystem.
Unnecessary checks have been removed from the cursors, by ensuring some invariants beforehand.
Each vertex lookup needs to perform slightly less work.
The traversal speedups observed by these changes alone were around 8 to 10% for single-server traversals and traversals in OneShard setups. Cluster traversals will also benefit from these changes, but to a lesser extent. This is because the network roundtrips have a higher share of the total query execution times there.
Syntax enhancements:
AQL now supports trailing commas in array and object definitions.
This is especially convenient for editing multi-line array/object definitions, since there doesn’t need to be a distinction between the last element and all others just for the comma.
AQL datetime parsing:
The performance of parsing ISO 8601 date/time string values in AQL has improved significantly thanks to a specialized parser, replacing a regular expression.
Ternary operator:
Improved the lazy evaluation capabilities of the ternary operator. If the second operand is left out, the expression of the condition is only evaluated once now, instead of once more for the true branch.
Cluster:
Incremental Plan Updates:
In ArangoDB clusters, the Agency is the single source of truth for data definition (databases, collections, shards, indexes, views), the cluster configuration and the current cluster setup (e.g. shard distribution, shard leadership).
Coordinators and DB-Servers in the cluster maintain a local cache of the Agency’s information, in order to access it in a performant way whenever they need any information about the setup. However, any change that was applied to the Plan and Current sections in the Agency led to the server-local caches being invalidated, which triggered a full reload of either Plan or Current by all Coordinators and DB-Servers. The size of Plan and Current is proportional to the number of database objects, so fully reloading the data from the Agency is an expensive operation for deployments which have a high number of databases, collections, or shards.
In ArangoDB 3.7 the mechanism for filling the local caches on Coordinators and DB-Servers with Agency data has changed fundamentally. Instead of invalidating the entire cache and reloading the full Plan or Current section on every change, each server is now using a permanent connection to the Agency and uses it to poll for changes. Changes to the Agency data are sent over these connections as soon as they are applied in the Agency, meaning that Coordinators and DB-Servers can apply them immediately and incrementally. This removes the need for full reloads. As a consequence, a significant reduction of overall network traffic between Agents and other cluster nodes is expected, plus a significant reduction in CPU usage on Agents for assembling and sending the Plan or Current parts. Another positive side effect of this modification is that changes made to Agency data should propagate faster in the cluster.
Parallel Move Shard:
Shards can now move in parallel. The old locking mechanism was replaced by a read-write lock and thus allows multiple jobs for the same destination server. The actual transfer rates are still limited on DB-Server side but there is a huge overall speedup. This also affects CleanOutServer and ResignLeadership jobs.
General:
Schema Validation for Documents:
ArangoDB now supports validating documents on collection level using JSON Schema (draft-4).
In order to enforce a certain document structure in a collection we have introduced the schema collection property. It expects an object comprised of a rule (JSON Schema object), a level and a message that will be used when validation fails. When documents are validated is controlled by the validation level, which can be none (off), new (insert only), moderate (on insert and modification, but existing documents can remain invalid) or strict (always).
The server now supports upgrading connections from HTTP 1.1 to HTTP 2. This should improve ArangoDBs compatibility with various L7 load balancers and modern cloud platforms like Kubernetes.
We also expect improved request throughput in cases where there are many concurrent requests.
Sometimes it is desirable to have the same server use different server keys and certificates when it is contacted under different names. This is possible with the Server Name Indication (SNI) TLS extension. It is now supported by ArangoDB using a new startup option --ssl.server-name-indication.
Pregel:
A new algorithm "wcc" has been added to Pregel to find connected components.
There are now three algorithms to find connected components in a graph:
If your graph is effectively undirected (you have edges in both directions between vertices) then the simple connected components algorithm named "connectedcomponents" is suitable.
It is a very simple and fast algorithm, but will only work correctly on undirected graphs. Your results on directed graphs may vary, depending on how connected your components are.
To find weakly connected components (WCC) you can now use the new algorithm named "wcc". Weakly connected means that there exists a path from every vertex pair in that component.
This algorithm will work on directed graphs but requires a greater amount of traffic between your DB-Servers.
To find strongly connected components (SCC) you can use the algorithm named "scc". Strongly connected means every vertex is reachable from any other vertex in the same component.
The algorithm is more complex than the WCC algorithm and requires more memory, because each vertex needs to store much more state.
Foxx:
Foxx endpoints now provide the methods securityScheme, securityScope and security to allow defining Swagger security schemes.
Foxx routes now always have a Swagger operationId. If the route is unnamed, a distinct operationId will be generated based on the HTTP method and URL.
JavaScript:
V8 and ICU library upgrades
The bundled V8 JavaScript engine was upgraded to version 7.9.317. The bundled Unicode character handling library ICU was upgraded to version 64.2.
The resource usage of V8 has improved a lot. Memory usage is down by 15%, spawning a new Isolate has become almost 10 times faster.
Web UI:
The interactive description of ArangoDB’s HTTP API (Swagger UI) shows the endpoint and model entries collapsed by default now for a better overview.
The bundled version of Swagger has been upgraded to 3.25.1. This change has also been backported to ArangoDB v3.6.4.
Metrics:
The amount of exported metrics for monitoring has been extended and is now available in a format compatible with Prometheus. You can now easily scrape on /_admin/metrics. See Metrics HTTP API.
Client tools:
Arangodump and arangorestore will now fail when using the --collection option and none of the specified collections actually exist in the database (on dump) or in the dump to restore (on restore). In case only some of the specified collections exist, arangodump / arangorestore will issue warnings about the invalid collections, but will continue to work for the valid collections.
These change were made to make end users more aware of that the executed commands for dumping or restoring data refer to non-existing collections and that backup or restore operations are potentially incomplete.
MMFiles storage engine:
ArangoDB 3.7 does not contain the MMFiles storage engine anymore. In ArangoDB 3.7, the only available storage engine is the RocksDB storage engine, which is the default storage engine in ArangoDB since version 3.4. The MMFiles storage engine had been deprecated since the release of ArangoDB 3.6.
Any deployments that use the MMFiles storage engine will need to be migrated to the RocksDB storage engine using ArangoDB 3.6 (or earlier versions) in order to upgrade to ArangoDB 3.7.
All storage engine selection functionality has also been removed from the ArangoDB package installers. The RocksDB storage engine will be selected automatically for any new deployments created with ArangoDB 3.7.
This change simplifies the installation procedures and internal code paths.
Internal changes:
Upgraded bundled RocksDB library version:
The bundled version of the RocksDB library has been upgraded from 6.2 to 6.8.
Upgraded bundled OpenLDAP library version:
The OpenLDAP version used for the LDAP integration in the ArangoDB Enterprise Edition has been upgraded to 2.4.50. This change has been backported to ArangoDB v3.6.5 as well.
Added libunwind library dependency:
The Linux builds of ArangoDB now use the third-party library libunwind to get backtraces and to symbolize stack frames.
Building with libunwind can be turned off at compile time using the -DUSE_LIBUNWIND CMake variable.
Removed libcurl library dependency
The compile-time dependency on libcurl was removed. Cluster-internal communication is now performed using fuerte instead of libcurl.

New in ArangoDB 3.7.2.1 (Sep 17, 2020)

New in ArangoDB 3.7.2 (Aug 27, 2020)

Fixed internal issue #744: LIMIT with only offset and constrained heap optimization will use estimation value for ArangoSearch views.
Make UPSERT statement with collection bind parameter behave identical to its non-bind parameter counterpart.
For example, the query
FOR d IN ["key_1", "key_2", "key_3", "key_1"] UPSERT d INSERT d UPDATE d IN @@collection
would fail with "unique constraint violation" when used with a collection bind parameter, but the equivalent query
FOR d IN ["key_1", "key_2", "key_3", "key_1"] UPSERT d INSERT d UPDATE d IN collectionName
with a hard-coded collection name would succeed. This is now fixed so both queries have the same behavior (no failure) in single server.
Updated arangosync to 0.7.10.
Fixed internal issue #742: Add tick storage in index meta payload for ArangoSearch view links after collection truncate operation.
Fixed issue #12304: insert in transaction causing com.arangodb.ArangoDBException: Response: 500, Error: 4 - Builder value not
yet sealed.
This happened when too deeply-nested documents (more than 63 levels of nesting) were inserted. While indefinite nesting is still not supported, the error message has been corrected from the internal HTTP 500 error "Builder value not yet sealed" to the correct HTTP 400 "Bad parameter".
Fixed: During a move-shard job which moves the leader there is a situation in which the old owner of a shard can reclaim ownership (after having resigned already), with a small race where it allows to write documents only locally, but then continue the move-shard to a server without those documents. An additional bug in the MoveShard Supervision job would then leave the shard in a bad configuration with a resigned leader permanently in charge.
Fixed a problem with potentially lost updates because a failover could happen at a wrong time or a restarted leader could come back at an unlucky time.
Fixed BTS-167: Lingering Queries - Canceled from the UI. This fixes queries not vanishing from the list of running queries in the web UI in case the query was canceled using the "Cancel" button in web UI's query editor.
Fixed bad behaviour in agency supervision in some corner cases involving already resigned leaders in Current.
Fixed issue ES-664: the optimizer rule `inline-subqueries` must not pull out subqueries that contain a COLLECT statement if the subquery is itself called from within a loop. Otherwise the COLLECT will be applied to the values in the outer FOR loop, which can produce a different result.
Fixed that dropping a vanished follower works again. An exception response to the replication request is now handled properly.
Make AQL user-defined functions (UDFs) work in a cluster in case the UDF runs an AQL query inside its own function code (BTS-159).
Fixed hotbackup S3 credentials validation and error reporting for upload and download.
Fixed a blockage on hotbackup when writes are happening concurrently, since followers could no longer replicate leader transactions.
Fix: The 'sorted' COLLECT variant would return undefined instead of null when grouping by a null value.
Fix: writeConcern is now honored correctly (ES-655).
Fixed internal issue #739: ArangoSearch filter volatility takes into account calculation nodes dependencies.
Fixed OASIS-278 issue: Added proper sort/calc nodes cleanup for late materialzation after OneShard optimization.
Slightly improve the performance of cluster DDL maintenance operations.
Added AQL functions `IS_IPV4`, `IPV4_TO_NUMBER`, `IPV4_FROM_NUMBER` for IPv4 address checks and conversions.
Added AQL function `PRODUCT` to calculate the product of an array.
Improve performance of internal cluster Plan and Current reload operations.
Fixed issue #12349: arangosh compact Arangoerror 404.
Improve performance of many non-subquery AQL queries, by optimizing away some storage overhead for subquery context data.
Always fetch data for /_api/cluster/agency-dump from leader of the agency. Add option "redirectToLeader=true" to internal /_api/agency/state API.
Fixed regression with view use-after-create in cluster (BTS-137).
Slightly improved the performance of some k-shortest-path queries.

New in ArangoDB 3.7.1 (Aug 12, 2020)

New in ArangoDB 3.6.5 (Jul 17, 2020)

Updated arangosync to 0.7.8.
Added missing state rollback for failed attempt-based write locking of spin locks.
Fixed a sleeping barber in Fuerte HTTPConnection. It was possible that sendRequest calls were started but never completed due to the fact that the idle connection close triggered at exactly the same time.
Fixed potentially undefined behavior in syslog logger, with ident string going out of scope after `openlog` was called.
Fix cluster-internal request forwarding for VST requests that do not have any Content-Type header set. Such requests could have been caused by the Java driver (ES-635).
Added vertex validation in case of a SmartGraph edge definition update.
Fix untenable ultra precondition for removeServer.
Fixed that the hotbackup agency lock is released under all circumstances using scope guards. This addresses a rare case in which the lock was left behind.
Internal issue BTS-71: Added a precondition to prevent creating a collection with an invalid `distributeShardsLike` property.
Reinstate longer retention period for agency history (step size back to 1000, keep size back to 50000).
Internal issue BTS-71: In a cluster, for collections in creation, suspend supervision jobs concerning replication factor until creation is completed. Previously, it could cause collection creation to fail (e.g. when a server failed during creation), even when it didn't have to.
Internal issue BTS-71: Fixed error handling regarding communication with the agency. This could in a specific case cause collection creation in a cluster report success when it failed.
Fixed a document parsing bug in the Web UI. This issue occured in the document list view in case a document had an attribute called `length`. The result was an incorrect representation of the document preview.
The Web UI now displays an error message inside the node information view in case the user has no access to retreive the neccessary information.
Fixed a potential agency crash if trace logging is on.
Add more context error messages in certain agency failure situations in debug/trace mode.
Fixed issue OASIS-252: Hotbackup agency locks without clientId.
Correct some log entries.
Fixed BTS-110: Fulltext index with minLength <= 0 not allowed.
Web UI: Removed unnecessary menubar entry in case of database node inspection.
The `_from` and `_to` attributes of an edge document can now be edited from within the UI.
Disallow using V8 dependent functions in SEARCH statement.
Fixed issue ES-609: "Transaction already in use" error when running transaction. Added option `--transaction.streaming-lock-timeout` to control the timeout in seconds in case of parallel access to a streaming transaction.
Removed the edge id's hover styling in case of embedded document editor in the Web UI as this functionality is disabled. This was misleading because the elements are not clickable.
In case a document got requested via the UI of a collection which does not exist, the UI now properly displays an error view instead of having a bad display state.
The Web UI is not disabling the query import button after file upload takes place.
In case of a graph deletion failure, the Web UI displays now the correct error message.
Fix undistribute-remove-after-enum-coll which would allow calculations to be pushed to a DBServer which are not allowed to run there.
Returned `AQL_WARNING()` to emit warnings from UDFs.
The Web UI is now reporting errors properly in case of editing ArangoSearch Views with invalid properties.
Allow restoring collections from v3.3.0 with their all-numeric collection GUID values, by creating a new, unambiguous collection GUID for them. v3.3.0 had a bug because it created all-numeric GUID values, which can be confused with numeric collection ids in lookups. v3.3.1 already changed the GUID routine to produce something non-numeric already, but collections created with v3.3.0 can still have an ambiguous GUID. This fix adjusts the restore routine to drop such GUID values, so it only changes something if v3.3.0 collections are dumped, dropped on the server and then restored with the flawed GUIDs.
The Web UI's replication view is now checking the replication state automatically without the need of a manual reload.
Fixed that, when performing a graph AQL query while a (graceful) failover for the leader of the system collections is in progress, ArangoDB would report a "Graph not found error". The real error, namely that an agency transaction failed, was swallowed in the graph lookup code due to a wrong error code being used from Fuerte. We now generate a more appropriate 503 - Service Unavailable error
Changing the current users profile icon in the Web UI now renders the new icon directly without the need of a full UI browser reload.
Fixed hotbackup agency lock cleanup.
Web UI now shows correct permissions in case wildcard database level and wildcard collection level permissions are both set.
Fixed unintentional connection re-use for cluster-internal communications.
Fixed internal issue #701: Dangling readers in ArangoSearch index_writer cache.
Fix internal test helper function `removeCost` to really remove costs.
Pass through AQL query errors to UI graph viewer without turning them into "Internal Server Error"s.
Remove unnecessary console log in web UI.
Pick up selected "write concern" value entered in web UI when creating a collection in the cluster. Previously, the "write concern" value was not picked up correctly and collections were created with the default write concern.
Fixed the creation of edges in the web UI, which did not work due to a JavaScript error.
Make the reboot tracker catch a failed server and permanently removed servers. This allows other servers in the cluster to move on more quickly, when a server fails and does not immediately come back.
Modified the exception handling in the RestHandler. Asynchronous communication could lead to less detailed failure information.
Fixed velocypack validator for proper check of keys.
Handle missing "shardingStrategy" in Plan agency entries for collections. "shardingStrategy" entries can be missing for collections created with ArangoDB clusters in version 3.3 or earlier. A missing "shardingStrategy" entry can cause issues for certain queries that need to check the shard distribution on the DB-Servers. This change transparently handles missing "shardingStrategy" entries.
Take DropCollection off FAST_TRACK. This prevents blocking fast track maintenance threads if a shard cannot be dropped immediately due to some lock.
Added missing mutex to ConnectionPool::cancelConnections().
Updated ArangoDB Starter to 0.14.15.
Foxx API now respects "idiomatic" flag being explicitly set to false.
Fixed a bug in the internal `recalculateCount()` method for adjusting collection counts. The bug could have led to count adjustments being applied with the wrong sign.
Optimized Web UI styling for ArangoSearch Views when in read-only mode.
Pimped up network send request robustness.
Fixed issue ES-600: log out of LDAP automatically.
Option `--ldap.allow-offline` was added with `false` value by default to let server use cached offline credentials in case of LDAP server communication was lost and ArangoDB can't prolong cache online.
Fixed issue #11104 case with complex condition on second branch of OR operator.
Fixed issue ES-564: Opening a VST connection would leave an extra HttpCommTask object lying around for the life of the server. This accumulation was effectively a memory leak. Additionally, it led to inaccurate reporting of the number of open HTTP connections in the dashboard.
Added exceptions catching in agency callbacks.
Usability improvements for arangodump and arangorestore: - when a dump is restricted to one or multiple collections using the `--collection` option of arangodump, warnings are issued for all specified collections that are not present in the database. Previously there were no warnings, so missing a collection by misspelling its name could easily go unnoticed.
when a restore is restricted to one or multiple collections using the `--collection` option of arangorestore, warnings are issued for all specified collections that are not present in the dump. Previously there were no warnings, so missing a collection by misspelling its name could easily go unnoticed.
when a dump was taken using the `--overwrite` option, there was no check that validated whether the encryption mode used in the existing dump directory was the same as the requested encryption mode. This could have led to dump directories with both encrypted and unencrypted files. This was only the case when using `--overwrite true`, which is not the default.
when a restore was performed using the `--encryption.keyfile` option, there was no check whether the to-be-restored files were actually encrypted. Now this check is enforced and arangorestore will bail out with an error if the requested encryption mode for restore is not the same as for the stored dump files.
Fixed bad behaviour when dropping followers. A follower should be dropped immediately when it is officially FAILED, not only after a longish timeout.
Fixed a bug in CollectionNameResolver which could lead to an extended busy spin on a core when a collection was dropped, but documents of it still remained in the WAL.
Removed external file loading in a used 3rd party library (Web UI).
Include all requests to the web interface at endpoint `/_admin/aardvark` in a node's requests statistics. Previously, requests going to `/_admin/aardvark` were excluded from the request statistics if and only if the requested database was the `_system` database.

New in ArangoDB 3.6.4 (Jun 1, 2020)

Web UI is now using pre-compiled templates.
Fixed an issue with truncate of a collection after a dbserver was restarted very quickly. This could block arangosync from making progress because the jobs collection could no longer be truncated.
Fixed issue #11652: Error: AQL: missing variable #2 (1) for node #6 FilterNode) while planning registers.
Update OpenLDAP to 2.4.50.
Fixed issue ES-545: failing modification operations led to random crashes with "Index out of bound" error message.
Fixed edge cases in RocksDB primary index range lookups for operators >= and <.
Fixed issue #11525: Address security vulnerability by updating Swagger-UI dependency (upgraded Swagger UI to 3.25.1).
Updated arangosync to 0.7.5.
Fixed ability to edit graph edge in Graph Viewer of web UI.
Fixed issue #10371: For k-shortest-paths queries on certain graphs a condition to abort search was too eager and hence missed the shortest path between two vertices and returned a longer one.
Fixed issue ES-605: arangodump broken when using encryption.
Added a forgotten Plan/Version increment in cleanup code in createCollection.
Do not loadPlan from agency whenever all collections of a database are listed.
This is particularly important for arangosync.
Properly forward requests based on the transaction header.
Fixed issue #11590: Querying for document by _key returning only a single seemingly random property on entity ("old", in this case).
This fixes single-key document lookups in the cluster for simple by-key AQL queries, such as `FOR doc IN collection FILTER doc._key == @key RETURN doc` in case the document has either an "old" or a "new" attribute.
Fix a bad deadlock because transaction cleanup was pushed with too low priority.
Fix a dead-lock situation in hot-backup case.
If the cluster is under high write load, then a hot-backup is requested, and for some reason the coordinator loses connection to one DBServer there is a small chance that this DBServer dead-locks itself. Will not happen if the DBServer has enough threads. This dead-lock can no longer be triggered.
Fix spurious bugs in `resilience_move` tests due to replication context of to-be-dropped collections lingering around until timeout.
Fixed issue 11243: `db._isSystem()` returns true for a non-system DB.
Added option `--rocksdb.edge-cache` to toggle in-memory caching for edges. The option is turned on by default. This normally helps with performance in read-only and read-mostly workloads.
Fix potential undefined behavior in some operations issued to the REST handler at `/_api/collection` in cluster mode.
Fix creation of example graphs when `--cluster.min-replication-factor` is set and no replication factor was specified for a graph. In this case, the new graph will use the configured minimum replication factor.

New in ArangoDB 3.6.3.1 (May 7, 2020)

New in ArangoDB 3.6.2 (Mar 11, 2020)

Legacy behaviour for maintenance mode in supervision.
Fix the usage of the AQL functions `CALL` and `APPLY` for calling user-defined AQL functions when invoking an AQL query from the arangosh or a client application.
Previously, invoking an AQL query and using the `CALL` or `APPLY` AQL functions
to call user-defined AQL function caused undefined behavior.
Fix nullptr deference in index skipping mode, which produced an address sanitizer (ASan) warning.
Fix supervision mode detection while unlocking agency in cluster hot backups.
Clear backups from DB servers and agency, when plan unchanged not met and not allowing for inconsistency.
Fix arangorestore:
If a smartGraphAttribute value was changed after document creation, the _key of the document becomes inconsistent with the smartGraphAttribute entry. However, the sharding of documents stays intact.
When restoring data from a dump that contains a document with inconsistent _key and smartGraphAttribute this would cause an error and the document would not be inserted. This is fixed by ignoring this inconsistency in the case of restore.
Honor `cacheEnabled` attribute when updating the properties of a collection in case of the cluster. Previously, this attribute was ignored in the cluster, but it shouldn't have been.
Fixed issue #11137: http-proxy can't pass delete method req.body to foxx.
Fixed a memory leak in ModificationExecutors.
Updated rclone to 1.51.1.
Fixed queries having the following structure:
FOR doc IN collection
FILTER doc.nonIndexedAttribute // expression
FOR sub IN doc.nonIndexedAttribute // same expression
For such queries, the FILTER was moved into the first FOR loop for early pruning. Afterwards, the leftover CalculationNode that evaluated `doc.nonIndexedAttribute` was removed. This was wrong however, because
the same expression was reused in the second FOR loop. There was code considering this, but due to a bug it did not work if the expression in the FILTER was reused in the directly following node.
Updated arangosync to 0.7.3.
Updated ArangoDB Starter to 0.14.14.
Fixed handling of `geometry` attributes in query editor of the web UI.
Previously, document attributes named `geometry` were treated in a special
way, assuming they were JSON objects. In case a document contained a
`geometry` attribute that had a non-object value (e.g. `null`) the web UI
threw a JavaScript exception and would not display AQL query results properly.
Disable "collect-in-cluster" AQL optimizer rule in case a LIMIT node is between
the COLLECT and the source data. In this case it is not safe to apply the
distributed collect, as it may alter the results.
Fixed internal issue #4932: COLLECT WITH COUNT together with FILTER yields
zero.
This bugfix fixes an issue when skipping over documents in an index scan using a covering index and also at the same time using an early-pruning filter.
In this case wrong document data may have been injected into the filter condition for filtering, with the filter wrongfully deciding which documents to filter out.
Improved usability in arangorestore:
Fixed misleading error message when database creation fails for option`--create-database option`. Now the correct error is displayed.
Pass the specified replication factor from the `--replication-factor`option when creating a database.
Fixed issue #11051: AQL query wrongfully returning no results on 3.6.1.
This bugfix prevents the "late-document-materialization" optimizer rule from kicking in in cases when an index scan also uses early pruning of index entries. In this case, the late document materialization will lead to the filter condition used in early pruning not being applied correctly, potentially producing wrong results.
Fixed `console.log(...)` not logging when called inside arangosh.
Curiously, `require("console").log(...)` still worked from arangosh. This bugfix makes both versions work again.
Fixed internal issue #596: Added ability to disable DNF conversion in SEARCH condition for ArangoSearch views. As this conversion might result in overcomplicated disjunction and heavily slowdown execution.
Fixed a bug where a single host agency could log too early.
Cluster collection creation preconditioned on involved db server not in process of being cleaned and beyond.
Supervision maintenance mode from "on" and TTL to expiry string.
Clean out server job checks preconditions plan version unchanged for start.
Make sure heartbeats are actually sent out and received once per second.
Make active failover integration tests more stable.
Include collections "_queues" and "_jobs" in dumps created by arangodump in case the option `--include-system-collections` was set to true. Previously these collections were always excluded from dumps.
Fix bug in collection creation with distributeShardsLike.
Fixed issue #10949: k shortest paths behaviour wrong with zero weights.

New in ArangoDB 3.5.3 (Jan 8, 2020)

New in ArangoDB 3.5.3 (Nov 29, 2019)

Fixed GET _api/gharial to also include the name property in every returned graph. This is a consistency fix within the API as all other APIs include the name. As a work around the returned _key can be used, which is identical to the name.
The _users collection is now properly restored when using arangorestore.
Allow the optimizer to use indexes when a collection attribute is compared to an expansion followed by an attribute name, e.g.`doc.value IN something[*].name`.
Updated arangosync to 0.7.0.
Fixed issue #10470: The WebUI now shows potential errors and details which occured using _api/import (e.g. unique constraint violated).
Fixed issue #10440: Incorrect sorting with sort criteria partially covered by index.
Make the timeouts for replication requests (for active failover and master-slave replication configurable via startup options.
Fixed internal issue #4647: dead Coordinators are not removed for agency.
Fixed UPSERT matching.
Fixed undefined behaviour with creation of ArangoSearch links with custom analyzers in cluster environment.
Fixed internal issue #651: analyzer duplication in _analyzers collection.
Fixed internal issue #4597: rebalanceShards API cannot work on any database other than the _system database.
Stop putting system services in _apps on single server, this has never worked on cluster and was not needed.
Fixed issue #10371: K_SHORTEST_PATHS LIMIT 1 can not return the shortest path. Now the shortest path is returned as the first one in such queries.
Improve killability of some types of cluster AQL queries. Previously, several cluster queries, especially those containing a `DistributeNode` in their execution plans, did not respond to a kill instruction.
This change also introduces a new query status "killed", which may now be returned by the REST APIs at `/_api/query/current` and `/_api/query/slow` in the `state` attribute of each query.
Improve shutdown of some cluster AQL queries on the coordinator in case the query has multiple coordinator snippets (true for queries involving more than one collection) and the database server(s) cannot be reached on query shutdown. In this case the proper shutdown of the coordinator parts of the query previously was deferred until the coordinator snippets were removed by the automatic garbage collection. Now, the cleanup of the coordinator snippets will happen much more quickly, which reduces the chances of the queries blocking resources.
Fixed ArangoSearch index removes being discarded on commiting consolidation results with pending removes after some segments under consolidation were already committed.
Assertion fail when no timestamp in agency's persistence.
Fixed internal issue #647: custom analyzer provokes errors on Active Failover deployment.
Upgraded bundled version of libcurl to 7.66.0.
When starting a coordinator, wait up to 15 seconds for it to appear in the agency under key `Supervision/Health` before reporting as "ready". This is necessary because if the coordinator reports ready beforehand and is used to create databases etc., the supervision may remove all of the jobs started by non-ready coordinators, considering them to be from a failed coordinator. To avoid huge startup delays, the startup will proceed after waiting futilely for 15 seconds and log a message.
Fixed issue #10270: Query: Expecting type Array or Object (while executing).
Fix a problem with AQL constrained sort in the cluster, which might abort queries. The AQL sort-limit optimization rule may now also speed up fullCount with sorted indexes and a limit in the cluster.
Prevent spurious log message "Scheduler queue is filled more than 50% in last x s" from occurring when this is not the case. Due to a data race, the message could previously also occur if the queue was empty.
The General Graph document API is now consistent with the document API in its error messages. When attempting to create / modify edges pointing to non existing vertex collections HTTP 400 is returned instead of 404.
Disallow the usage of subqueries inside AQL traversal PRUNE conditions. Using subqueries inside PRUNE conditions causes undefined behavior, so such queries will now be aborted early on with a parse error instead of running into undefined behavior.
Fixed available flag for hotbackup.
Fixed list with id for partially available hotbackups.
Fixed agency TTL bug happening under certain rare conditions.
Improved performance of some agency helper functions.
Fixed search not working in document view while in code mode.
Fixed issue #10090: fix repeatable seek to the same document in SEARCH operations for ArangoSearch views.
Fixed issue #10193: Arangoexport does not handle line feeds when exporting as csv.
Removed debug log messages "found comm task ..." that could be logged on server shutdown.
Fixed issue #10183: Arangoimport imports on _system when you try to create a new database. This bugfix fixes the output of arangoimport, which could display a wrong target database for the import if the option `--create-database` was used.
Fixed issue #10158: Invalid Query Crashes ArangoDB. This fixes traversal queries that are run on a static empty start vertex string.

New in ArangoDB 3.5.2 (Nov 7, 2019)

New in ArangoDB 3.5.1 (Oct 9, 2019)

Properly report parse errors for extraneous unterminated string literals at the end of AQL query strings. For example, in the query `RETURN 1 "abc`, the `RETURN 1` part was parsed fully, and the `"abc` part at the end was parsed until the EOF and then forgotten. But as the fully parsed tokens `RETURN 1` already form a proper query, the unterminated string literal at the end was not reported as a parse error.
This is now fixed for unterminated string literals in double and single quotes as well as unterminated multi-line comments at the end of the query string.
Fix config directory handling, so we don't trap into UNC path lookups on Windows.
Ignore symlinks when copying JavaScript files at startup via the option `--javascript.copy-installation`. This potentially fixes the following error message at startup:
Error copying JS installation files to '...': failed to open source file ...: No such file or directory
Added startup option `--cluster.max-number-of-shards` for restricting the maximum number of shards when creating new collections. The default value for this setting is `1000`, hich is also the previously hard-coded built-in limit. A value of `0` for this option means "unrestricted". When the setting is adjusted, it will not affect already existing collections, but only collections that are created or restored afterwards.
Added startup options for managing the replication factor for newly created collections:
- `--cluster.min-replication-factor`: this settings controls the minimum replication factor value that is permitted when creating new collections. No collections can be created which have a replication factor value below this setting's value. The default value is 1.
- `--cluster.max-replication-factor`: this settings controls the maximum replication factor value that is permitted when creating new collections. No collections can be created which have a replication factor value above this setting's value. The default value is 10.
- `--cluster.default-replication-factor`: this settings controls the default replication factor value that is used when creating new collections and no value of replication factor has been specified. If no value is set for this option, the value of the option
`--cluster.min-replication-factor` will be used.
Fixed unintended multiple unlock commands from coordinator to transaction locked db servers.
DB server locking / unlocking for hot backup revisited and enhanced.
Rely on reboot ids for declaring end of cluster hot restore on coordinators.
Obtain new unique IDs via a background thread.
Fixed issue #10078: FULLTEXT with sort on same field not working.
Fixed issue #10062: AQL: could not extract custom attribute.
Fix compilation issue with clang 10.
Fixed error message for error 1928 ("not in orphan") to "collection is not in list of orphan collections".
Fix strange shutdown hanger which came from the fact that currently libgcc/libmusl wrongly detect multi-threadedness in statically linked executables.
Fixed a shutdown bug coming from a read/write lock race.
Fixed a bug in the edge cache's internal memory accounting, which led to the edge cache underreporting its current memory usage.
Fixed "ArangoDB is not running in cluster mode" errors in active failover setups. This affected at least /_admin/cluster/health.
Made the mechanism in the Web UI of replacing and upgrading a foxx app more clear.
Fixed the AQL sort-limit optimization which was applied in some cases it should not, resulting in undefined behaviour.
Add --server.statistics-history flag to allow disabling of only the historical statistics. Also added rocksdbengine.write.amplification.x100 statistics for measurement of compaction option impact. Enabled non-historical statistics for agents.
Fixed AQL constrained-heap sort in conjunction with fullCount.
Added support for AQL expressions such as `a NOT LIKE b`, `a NOT =~ b` and `a NOT !~ b`. Previous versions of ArangoDB did not support these expressions, and using them in an AQL query resulted in a parse error.
Disallow creation of TTL indexes on sub-attributes. Creation of such indexes was not caught before, but the resulting indexes were defunct. From now on the creation of TTL indexes on sub-attributes is disallowed.
Added HotBackup feature.
Improved database creation within the cluster. In the case of coordinator outages during the creation of the database there was a chance that not all relevant system collections had been created. Although this database was accessible now some features did not work as expected (e.g. creation of graphs). We modified creation of a new database as an all or nothing operation and only allow access to the database after all system collections are properly perpared to avoid the above inconsistencies. Also creation of databases are now secured against coordinator outages, they will either be fully created or not visible and eventually dropped. This does not require any change on the client code.
Added UI support to create documents in a collection using smartGraphAttribute and/or smartJoinAttribute.
Add count of objects to latency reporting in arangoimport.
Harden database creation against spurious "duplicate name" errors that were caused by other parallel operations lazily creating required system collections in the same database.
Fixed internal issue #633: made ArangoSearch functions BOOST, ANALYZER, MIN_MATCH callable with constant arguments. This will allow running queries where all arguments for these functions are deterministic and do not depend on loop variables.
Automatically turn values for deprecated startup option parameters `--log.use-microtime` and `--log.use-local-time` into equivalent option values of the new, preferred option `--log.time-format`.
Drop collection action to timeout more quickly to stay on fast lane.
Make arangorestore restore data into the `_users` collection last. This is to ensure that arangorestore does not overwrite the credentials of its invoker while the restore is running, but only at the very end of the process. This change also makes arangorestore restore the `_system` database last if it is started with the `--all-databases` option.
Fixed the removal (including a collection drop) of an orphanCollection from a graph definition when using the arango shell. The boolean flag whether to drop the collection or not was not transferred properly.
Check for duplicate server endpoints registered in the agency in sub-keys of `/Current/ServersRegistered`. Duplicate endpoints will be registered if more than one arangod instance is started with the same value for startup option `--cluster.my-address`. This can happen unintentionally due to typos in the configuration, copy&paste remainders etc. In case a duplicate endpoint is detected on startup, a warning will be written to the log, indicating which other server has already "acquired" the same endpoint.
Make graph operations in general-graph transaction-aware.
Fixed adding an orphan collections as the first collection in a SmartGraph.
Fixed non-deterministic occurrences of "document not found" errors in sharded collections with custom shard keys (i.e. non-`_key`) and multi-document lookups.
Fixed issue #9862: ServerException: RestHandler/RestCursorHandler.cpp:279 This fixes an issue with the RocksDB primary index IN iterator not resetting its internal iterator after being rearmed with new lookup values (which only happens if the IN iterator is called from an inner FOR loop).
Geo functions will now have better error reporting on invalid input.
The graph viewer of the web interface now tries to find a vertex document of all available vertex collections before it aborts.
Fixed issue #9795: fix AQL `NOT IN` clause in SEARCH operations for ArangoSearch views.
Make minimum timeout for synchronous replication configurable via parameter (--cluster.synchronous-replication-timeout-minimum) and increase default value to prevent dropping followers unnecessarily.
Added support for TLS 1.3 for the arangod server and the client tools. The default TLS protocol for the arangod server is still TLS 1.2 however, in order to keep compatibility with previous versions of ArangoDB. The arangod server and any of the client tools can be started with option `--ssl.protocol 6` to make use of TLS 1.3. To configure the TLS version for arangod instances started by the ArangoDB starter, one can use the `--all.ssl.protocol=VALUE` startup option for the ArangoDB starter, where VALUE is one of the following:
- 4 = TLSv1
- 5 = TLSv1.2
- 6 = TLSv1.3
Fixed parsing of "NOT IN" in AQL, which previously didn't correctly parse "NOT IN_RANGE(...)" because it checked if the "NOT" token was followed by whitespace and then the two letters "IN".
Changed log level for message "keep alive timeout - closing stream!" from INFO to DEBUG.
Don't create temporary directories named "arangosh_XXXXXX" anymore.
Add TransactionStatistics to ServerStatistics (transactions started / aborted / committed and number of intermediate commits).
Upgraded version of bundled curl library to 7.65.3.
Don't retry persisting follower information for collections/shards already dropped. The previous implementation retried (unsuccessfully in this case) for up to 2 hours, occupying one scheduler thread.
Fixed internal issue #4407: remove storage engine warning.
Agents to remove callback entries when responded to with code 404.
Fixed internal issue #622: Analyzer cache is now invalidated for dropped database.
Show query string length and cacheability information in query explain output.
The AQL functions `FULLTEXT`, `NEAR`, `WITHIN` and `WITHIN_RECTANGLE` are now marked as cacheable, so they can be used in conjunction with the AQL query results cache on a single server.
Fixed issue #9612: fix ArangoSearch views getting out of sync with collection.
Fix an issue with potential spurious wakeups in the internal scheduler code.
Changes the _idle_ timeout of stream transactions to 10 seconds and the total per DB server size of stream transaction data to 128 MB. The idle timer is restarted after every operation in a stream transaction, so it is not the total timeout for the transaction.
These limits were documented in the manual for stream transactions since 3.5.0, but are enforced only as of 3.5.1. Enforcing the limits is useful to free up resources from abandoned transactions.
Consistently honor the return value of all attempts to queue tasks in the internal scheduler. Previously some call sites did not check the return value of internal queueing operations, and if the scheduler queue was full, operations that were thought to be requeued were silently dropped. Now, there will be reactions on such failures. Requeuing an important task with a time offset (Scheduler::queueDelay) is now also retried on failure (queue full) up to at most five minutes. If after five minutes such a task still cannot be queued, a fatal error will be logged and the server process will be aborted.
Made index selection much more deterministic in case there are multiple competing indexes.
Fixed issue #9654: honor value of `--rocksdb.max-write-buffer-number` if it is set to at least 9 (which is the recommended value). Ignore it if it is set to a lower value than 9, and warn the end user about it. Previous versions of ArangoDB always silently ignored the value of this setting and effectively hard-coded the value to 9.
Fixed internal issue #4378: fix bug in MoveShard::abort which causes a duplicate entry in the follower list.
Fixed cut'n'pasting code from the documentation into arangosh.
Fixed issue #9652: fix ArangoSearch wrong name collision and raising "Name collision detected" error during creation of a custom analyzer with stopwords.
Fixed an agency bug found in Windows tests.
Added initial support for wgs84 reference ellipsoid in GEO_DISTANCE through third optional parameter to AQL function.
Added support for area calculations with GEO_AREA AQL function.
Correct RocksDB statistics to report sums from column families instead of single value from default column family.
Fixed agency nodes to not create bogus keys on delete / observe / unobserve.
Fixed issue #9660: fix multiple plans processing during optimization of AQL query which uses ArangoSearch scorers.
Fixed issue #9679: improved error message for FULLTEXT function invocation failures.
Fixed error message "Invalid argument: assume_tracked is set but it is not tracked yet" when trying to write to the same keys in concurrent RocksDB transactions. This error will now be reported as a "Lock timeout" error, with error code 1200.
Added resign leadership job to supervision.
Hide MMFiles-specific information in web UI (in detail view of a collection) when the storage engine is not MMFiles or when the information is not available.
Keep followers in sync if the old leader resigned and stopped writes.
Abort a FailedLeader job when its _to_ server fails.
Decreased unnecessary wait times for agency callbacks in case they were called earlier than expected by main thread.
Make arangosh not close the connection after the user aborts an operation. This restores the same behavior as in previous versions of ArangoDB, which also left the connection open.
Refactor maintenance to use a TakeoverShardLeadership job. This fixes a bug that a shard follower could have set the wrong leader for the shard locally.

New in ArangoDB 3.5.0 (Aug 21, 2019)

New in ArangoDB 3.4.7 (Jul 5, 2019)

Updated arangosync to 0.6.4
Bug-fix for a very rare race condition on cluster collection creation process. It can only occur in the following situation:
1) DBServer sucessfully creates all shards for collections, and reports it back
2) DBServer dies
3) Agency recognized death and reorganizes shards
4) Coordinator receives (1) but not (3) and decided everything was good
5) => Coordinator reverts (3) only on this collection
6) Coordinator receives (3) now
The bugfix disallows (5) if (3) is run in Agency.
Fixed internal issue #4040: gharial api is now checking existence of `_from` and `_to` vertices during edge replacements and edge updates
Fix timeout-response in case of simultaneous index create/drop in cluster
Fixed editing a user within the web UI if the user added a gravatar profile picture
Fixed internal issue #4172: on agent servers the RocksDB WAL files in the archive directory were retained due to an error. Now they are removed, eventually
Fix error reporting in arangorestore. previously, when the server returned an HTTP 404 error, arangorestore unconditionally translated this into a "collection not found" error, which may have masked an actually different server-side error. Instead, make arangorestore return the server's actual error message as is.
Allow pregel to select the shard key via `shardKeyAttribute` in pregel start parameters
Speed up collection creation process in cluster, if not all agency callbacks are
Delivered successfully.
Fixed parsing of ArangoDB config files with inlined comments. Previous versions didn't handle line comments properly if they were appended to an otherwise valid option value.
For example, the comment in the line
Max-total-wal-size = 1024000 # 1M
Was not ignored and made part of the value. In the end, the value was interpreted as if max-total-wal-size = 10240001000000
This version fixes the handling of comments in the config files so that they behave as intended.
Fixed AQL query tracing for traversals, this lead to wrong "calls" count in query profiles
Pregel algorithms can be run with the option "useMemoryMaps: true" to be able to run algorithms on data that is bigger than the available RAM.
Bugfix for smart graph traversals with uniqueVertices: path, which could
Sometimes lead to erroneous traversal results
The system-collection '_jobs' will from now on use non-unique, non-sparse indexes.
Fixed internal issue #3919: The web UI is now using precompiled ejs templates.
Properly create VERSION files for any newly created databases again, as it has been the case in 3.3 and before. If no VERSION files are created, this may cause problems on upgrade to 3.5. The 3.5 branch was also modified to handle this problem gracefully.
Fixed "collection not found" exception during setup of 3-way smart join queries in the cluster
Fixed an edge case of handling `null` values in the AQL function `MIN` for input sequences that started with a `null` value. In this case, `null` was always returned as the minimum value even though other non-null values may have followed, and `MIN` was supposed to return `null` only if there are no input values or all input values are `null`.
Fix client id lookup table in agency
Fix agency's handling of object assignments with TTL
Reduce resident memory usage when creating non-unique indexes with the RocksDB storage engine
Fix agency election bug.

New in ArangoDB 3.4.5 (Apr 9, 2019)

Fixed a shutdown issue when the server was shut down while there were active Pregel jobs executing
Fixed internal issue #3815: fixed the removal of connected edges when removing a vertex graph node in a smart graph environment.
Added AQL functions CRC32 and FNV64 for hashing data
Internal issue #2276: fixed the sorting of the databases in the database selection dropdown in the web ui. The sort order differed based on whether authentication was enabled or disabled.
Fixed internal issue #3789: restricted the allowed query names for user- defined custom queries within the web ui.
Fixed internal issuel #3546: improved the shards view in the web ui if there is only one shard to display.
Fixed a display issues when editing a graph within the web ui
Fixed internal-issue #3787: Let user know about conflicting attribute in AQL queries if information is available.
Fixed issue #8294: wrong equals behaviour on arrays with ArangoSearch
Fixed internal issue #528: ArangoSearch range query sometimes doesn't work correctly with numeric values
Fixed internal issue #3757: when restarting a follower in active failover mode, try an incremental sync instead of a full resync. Fixed also the case where a double resync was made
Don't check for the presence of ArangoDB upgrades available when firing up an arangosh enterprise edition build
Added startup option `--rocksdb.allow-fallocate`
When set to true, allows RocksDB to use the fallocate call. If false, allocate calls are bypassed and no preallocation is done. Preallocation is turned on by default, but can be turned off for operating system versions that are known to have issues with it.
This option only has an effect on operating systems that support fallocate.
Added startup option `--rocksdb.limit-open-files-at-startup`
If set to true, this will limit the amount of .sst files RocksDB will inspect at startup, which can reduce the number of IO operations performed at start.
Don't run compact() on a collection after a truncate() was done in the same transaction
Running compact() in the same transaction will only increase the data size on disk due to RocksDB not being able to remove any documents physically due to the snapshot that is taken at transaction start.
This change also exposes db.<collection>.compact() in the arangosh, in order to manually run a compaction on the data range of a collection should it be needed for maintenance.
Don't attempt to remove non-existing WAL files, because such attempt will trigger unnecessary error log messages in the RocksDB library
Updated arangosync to 0.6.3
Added --log.file-mode to specify a file mode of newly created log files
Added --log.file-group to specify the group of newly created log files
Fixed some escaping issues within the web ui.
Fixed issue #8359: How to update a document with unique index (constraints)?
When restarting a follower in active failover mode, try an incremental sync instead of a full resync
Add "PRUNE <condition>" to AQL Traversals (internal issue #3068). This allows to early abort searching of unnecessary branches within a traversal. PRUNE is only allowed in the Traversal statement and only between the graphdefinition and the options of the traversal.
Added option `--console.history` to arangosh for controlling whether the command-line history should be loaded from and persisted in a file.
The default value for this option is `true`. Setting it to `false` will make arangosh not load any command-line history from the history file, and not store the current session's history when the shell is exited. The command-line history will then only be available in the current shell session.
Display the server role when connecting arangosh against a server
Added replication applier state figures `totalDocuments` and `totalRemovals` to access the number of document insert/replace operations and the number of document removals operations separately. Also added figures `totalApplyTime` and
`totalFetchTime` for determining the total time the replication spent for applying changes or fetching new data from the master. Also added are the figures `averageApplyTime` and `averageFetchTime`, which show the average time spent for applying a batch or for fetching data from the master, resp.
Fixed race condition in which the value of the informational replication applier figure `ticksBehind` could underflow and thus show a very huge number of ticks.
Always clear all ongoing replication transactions on the slave if the slave discovers the data it has asked for is not present anymore on the master and the `requireFromPresent` value for the applier is set to `false`.
In this case aborting the ongoing transactions on the slave is necessary because they may have held exclusive locks on collections, which may otherwise not be released.
Added option `--rocksdb.wal-archive-size-limit` for controlling the maximum total size (in bytes) of archived WAL files. The default is 0 (meaning: unlimited).
When setting the value to a size bigger than 0, the RocksDB storage engine will force a removal of archived WAL files if the total size of the archive
exceeds the configured size. The option can be used to get rid of archived WAL files in a disk size-constrained environment.
Note that archived WAL files are normally deleted automatically after a short while when there is no follower attached that may read from the archive. However, in case when there are followers attached that may read from the archive, WAL files normally remain in the archive until their contents have been streamed to the followers. In case there are slow followers that cannot catch up this will cause a growth of the WAL files archive over time.
The option `--rocksdb.wal-archive-size-limit` can now be used to force a deletion of WAL files from the archive even if there are followers attached that may want to read the archive. In case the option is set and a leader deletes files from the archive that followers want to read, this will abort the replication on the followers. Followers can however restart the replication doing a resync.
Agents need to be able to overwrite a compacted state with same _key
In case of resigned leader, set isReady=false in clusterInventory
Abort RemoveFollower job if not enough in-sync followers or leader failure
Fix shrinkCluster for satelliteCollections
Fix crash in agency supervision when leadership is lost
Speed up supervision in agency for large numbers of jobs
Fix log spamming after leader resignation in agency
Make AddFollower less aggressive
Fix cases, where invalid json could be generated in agents' store dumps
Coordinator route for full agency dumps contains compactions and time stamps
Lots of agency performance improvements, mostly avoiding copying
Priority queue for maintenance jobs
Do not wait for replication after each job execution in Supervision
Fix a blockage in MoveShard if a failover happens during the operation
Check health of servers in Current before scheduling removeFollower jobs
Wait for statistics collections to be created before running resilience tests
Fix ttl values in agency when key overwritten with no ttl

New in ArangoDB 3.4.3 (Feb 21, 2019)

New in ArangoDB 3.4.2-1 (Feb 1, 2019)

New in ArangoDB 3.4.2 (Jan 25, 2019)

fixed an issue with AQL query IN index lookup conditions being converted into
empty arrays when they were shared between multiple nodes of a lookup condition
that used an IN array lookup in an OR that was multiplied due to DNF transformations
This issue affected queries such as the following
FILTER (... && ...) || doc.indexAttribute IN non-empty-array
upgraded arangodb starter version to 0.14.0
upgraded arangosync version to 0.6.2
fixed an issue where a crashed coordinator can lead to some Foxx queue jobs
erroneously either left hanging or being restarted
fix issue #7903: Regression on ISO8601 string compatibility in AQL
millisecond parts of AQL date values were limited to up to 3 digits.
Now the length of the millisecond part is unrestricted, but the
millisecond precision is still limited to up to 3 digits.
fix issue #7900: Bind values of `null` are not replaced by
empty string anymore, when toggling between json and table
view in the web-ui.
Use base64url to encode and decode JWT parts.
added AQL function `CHECK_DOCUMENT` for document validity checks
when detecting parse errors in the JSON input sent to the restore API, now
abort with a proper error containing the problem description instead of aborting
but hiding there was a problem.
do not respond with an internal error in case of JSON parse errors detected
in incoming HTTP requests
added arangorestore option `--cleanup-duplicate-attributes` to clean up input documents
with redundant attribute names
Importing such documents without the option set will make arangorestore fail with an
error, and setting the option will make the restore process clean up the input by using
just the first specified value for each redundant attribute.
the arangorestore options `--default-number-of-shards` and `--default-replication-factor`
are now deprecated in favor of the much more powerful options `--number-of-shards`
and `--replication-factor`
The new options `--number-of-shards` and `--replication-factor` allow specifying
default values for the number of shards and the replication factor, resp. for all
restored collections. If specified, these default values will be used regardless
of whether the number of shards or the replication factor values are already present
in the metadata of the dumped collections.
It is also possible to override the values on a per-collection level by specifying
the options multiple times, e.g.
number-of-shards 2 --number-of-shards mycollection=3 --number-of-shards test=4
The above will create all collections with 2 shards, except the collection "mycollection"
3 shards) and "test" (4 shards).
By omitting the default value, it is also possible to use the number of shards/replication
factor values from the dump for all collections but the explicitly specified ones, e.g.
number-of-shards mycollection=3 --number-of-shards test=4
This will use the number of shards as specified in the dump, except for the collections
"mycollection" and "test".
The `--replication-factor` option works similarly.
validate uniqueness of attribute names in AQL in cases in which it was not
done before. When constructing AQL objects via object literals, there was
no validation about object attribute names being unique. For example, it was
possible to create objects with duplicate attribute names as follows:
INSERT { a: 1, a: 2 } INTO collection
This resulted in a document having two "a" attributes, which is obviously
undesired. Now, when an attribute value is used multiple times, only the first
assigned value will be used for that attribute in AQL. It is not possible to
specify the same attribute multiple times and overwrite the attribute's value
with by that. That means in the above example, the value of "a" will be 1,
and not 2.
This changes the behavior for overriding attribute values in AQL compared to
previous versions of ArangoDB, as previous versions in some cases allowed
duplicate attribute names in objects/documents (which is undesired) and in
other cases used the _last_ value assigned to an attribute instead of the _first_
value. In order to explicitly override a value in an existing object, use the
AQL MERGE function.
To avoid all these issues, users are encouraged to use unambiguous attribute
names in objects/documents in AQL. Outside of AQL, specifying the same attribute
multiple times may even result in a parse error, e.g. when sending such data
to ArangoDB's HTTP REST API.
fixed issue #7834: AQL Query crashes instance
Added --server.jwt-secret-keyfile option.
Improve single threaded performance by scheduler optimization.
Releveling logging in maintenance

New in ArangoDB 3.4.1 (Jan 25, 2019)

fixed issue #7757: Using multiple filters on nested objects produces wrong results
fixed issue #7763: Collect after update does not execute updates
fixed issue #7586: a running query within the user interface was not shown
if the active view was `Running Queries` or `Slow Query History`.
fixed issue #7749: AQL Query result changed for COLLECT used on empty data/array
fixed a rare thread local dead lock situation in replication:
If a follower tries to get in sync in the last steps it requires
a lock on the leader. If the follower cancels the lock before the leader
has succeeded with locking we can end up with one thread being deadlocked.
fix thread shutdown in _WIN32 builds
Previous versions used a wrong comparison logic to determine the current
thread id when shutting down a thread, leading to threads hanging in their
destructors on thread shutdown
reverted accidental change to error handling in geo index
In previous versions, if non-valid geo coordinates were contained in the
indexed field of a document, the document was simply ignored an not indexed.
In 3.4.0, this was accidentally changed to generate an error, which caused
the upgrade procedure to break in some cases.
fixed TypeError being thrown instead of validation errors when Foxx manifest
validation fails
make AQL REMOVE operations use less memory with the RocksDB storage engine
the previous implementation of batch removals read everything to remove into
memory first before carrying out the first remove operation. The new version
will only read in about 1000 documents each time and then remove these. Queries
such as
FOR doc IN collection FILTER ... REMOVE doc IN collection
will benefit from this change in terms of memory usage.
make `--help-all` now also show all hidden program options
Previously hidden program options were only returned when invoking arangod or
a client tool with the cryptic `--help-.` option. Now `--help-all` simply
retuns them as well.
The program options JSON description returned by `--dump-options` was also
improved as follows:
the new boolean attribute "dynamic" indicates whether the option has a dynamic
default value, i.e. a value that depends on the target host capabilities or
configuration
the new boolean attribute "requiresValue" indicates whether a boolean option
requires a value of "true" or "false" when specified. If "requiresValue" is
false, then the option can be specified without a boolean value following it,
and the option will still be set to true, e.g. `--server.authentication` is
identical to `--server.authentication true`.
the new "category" attribute will contain a value of "command" for command-like
options, such as `--version`, `--dump-options`, `--dump-dependencies` etc.,
and "option" for all others.
Fixed a bug in synchroneous replication intialisation for, where a
shard's db server is rebooted during that period

New in ArangoDB 3.4.0 (Dec 14, 2018)

New in ArangoDB 3.3.20 (Dec 6, 2018)

Added RocksDB option `--rocksdb.total-write-buffer-size` to limit total memory
Usage across all RocksDB in-memory write buffers
The total amount of data to build up in all in-memory buffers (backed by log files). This option, together with the block cache size configuration option,
Can be used to limit memory usage. If set to 0, the memory usage is not limited. This is the default setting in 3.3. The default setting may be adjusted in Future versions of ArangoDB.
If set to a value greater than 0, this will cap the memory usage for write buffers, But may have an effect on write performance.
Added RocksDB configuration option `--rocksdb.enforce-block-cache-size limit`
Whether or not the maximum size of the RocksDB block cache is strictly enforced. This option can be set to limit the memory usage of the block cache to at most the Specified size. If then inserting a data block into the cache would exceed the Cache's capacity, the data block will not be inserted. If the flag is not set, A data block may still get inserted into the cache. It is evicted later, but the Cache may temporarily grow beyond its capacity limit.
Export version and storage engine in cluster health
Potential fix for issue #7407: arangorestore very slow converting from
Mmfiles to rocksdb
Updated joi library (Web UI), improved foxx mount path validation
Fix internal issue #2786: improved confirmation dialog when clicking the
Truncate button in the Web UI
Fix for supervision, which started failing servers using old transient store
Fixed Foxx queues not retrying jobs with infinite `maxFailures`
Fixed a race condition in a coordinator, it could happen in rare cases and only with the maintainer mode enabled if the creation of a collection is in Progress and at the same time a deletion is forced.
Disable startup warning for Linux kernel variable `vm.overcommit_memory` settings Values of 0 or 1.
Effectively `overcommit_memory` settings value of 0 or 1 fix two memory-allocation Related issues with the default memory allocator used in ArangoDB release builds on 64bit Linux.
The issues will remain when running with an `overcommit_memory` settings value of 2, So this is now discouraged. Setting `overcommit_memory` to 0 or 1 (0 is the Linux kernel's default) fixes issues With increasing numbers of memory mappings for the arangod process (which may lead To an out-of-memory situation if the kernel's maximum number of mappings threshold
Is hit) and an increasing amount of memory that the kernel counts as "committed".
With an `overcommit_memory` setting of 0 or 1, an arangod process may either be killed by the kernel's OOM killer or will die with a segfault when accessing memory
It has allocated before but the kernel could not provide later on. This is still more acceptable than the kernel not providing any more memory to the process when there is still physical memory left, which may have occurred with an `overcommit_memory` Setting of 2 after the arangod process had done lots of allocations.
In summary, the recommendation for the `overcommit_memory` setting is now to set it To 0 or 1 (0 is kernel default) and not use 2.
Force connection timeout to be 7 seconds to allow libcurl time to retry lost DNS
Queries.
Increase maximum number of collections/shards in an AQL query from 256 to 2048
Don't rely on `_modules` collection being present and usable for arangod startup
Optimizes the web ui's routing which could possibly led to unwanted events.
Fixes some graph data parsing issues in the ui, e.g. cleaning up duplicate edges inside the graph viewer.
In a cluster environment, the arangod process now exits if wrong credentials are used during the startup process.
Fixed an AQL bug where the optimize-traversals rule was falsely applied to extensions with inline expressions and thereby ignoring them
Fix side-effects of sorting larger arrays (>= 16 members) of constant literal
Values in AQL, when the array was not used only for IN-value filtering but also later in the query. The array values were sorted so the IN-value lookup could use a binary search instead of a linear search, but this did not take into account that the array could have been used elsewhere in the query, e.g. as a return value. The fix will create a copy of the array and sort the copy, leaving the original array untouched.
Fixed a bug when cluster indexes were usable for queries, while still being built on db servers
Fix move leader shard: wait until all but the old leader are in sync. This fixes some unstable tests.
Cluster health features more elaborate agent records

New in ArangoDB 3.3.19 (Oct 24, 2018)

fixes validation of allowed or not allowed foxx service mount paths within the Web UI
The single database or single coordinator statistics in a cluster environment within the Web UI sometimes got called way too often. This caused artifacts in the graphs, which is now fixed.
An aardvark statistics route could not collect and sum up the statistics of all coordinators if one of them was ahead and had more results than the others
upgraded arangodb starter version to 0.13.6
turn on intermediate commits in replication applier in order to decrease the size of transactional operations on replication (issue #6821)
fixed issue #6770: document update: ignoreRevs parameter ignored
when returning memory to the OS, use the same memory protection flags as when initializing the memory. this prevents "hole punching" and keeps the OS from splitting one memory mapping into multiple mappings with different memory protection settings
fix internal issue #2770: the Query Profiling modal dialog in the Web UI was slightly malformed.
fix internal issue #2035: the Web UI now updates its indices view to check whether new indices exist or not.
fix internal issue #6808: newly created databases within the Web UI did not appear when used Internet Explorer 11 as a browser.
fix internal issue #2688: the Web UI's graph viewer created malformed node labels if a node was expanded multiple times.
fix internal issue #2957: the Web UI was not able to display more than 1000 documents, even when it was set to a higher amount.
fix internal issue #2785: web ui's sort dialog sometimes got rendered, even if it should not.
fix internal issue #2764: the waitForSync property of a satellite collection could not be changed via the Web UI
improved logging in case of replication errors
recover short server id from agency after a restart of a cluster node
this fixes problems with short server ids being set to 0 after a node restart, which then prevented cursor result load-forwarding between multiple coordinators to work properly. this should fix arangojs#573
increased default timeouts in replication. this decreases the chances of followers not getting in sync with leaders because of replication operations timing out
fixed internal issue #1983: the Web UI was showing a deletion confirmation multiple times.
fixed agents busy looping gossip
handle missing `_frontend` collections gracefully the `_frontend` system collection is not required for normal ArangoDB operations, so if it is missing for whatever reason, ensure that normal operations can go on.

New in ArangoDB 3.3.17 (Oct 8, 2018)

upgraded arangosync version to 0.6.0
added several advanced options for configuring and debugging LDAP connections.
Please note that some of the following options are platform-specific and may not
work on all platforms or with all LDAP servers reliably:
`--ldap.serialized`: whether or not calls into the underlying LDAP library
should be serialized.
This option can be used to work around thread-unsafe LDAP library functionality.
`--ldap.serialize-timeout`: sets the timeout value that is used when waiting to
enter the LDAP library call serialization lock. This is only meaningful when
`--ldap.serialized` has been set to `true`.
`--ldap.retries`: number of tries to attempt a connection. Setting this to values
greater than one will make ArangoDB retry to contact the LDAP server in case no
connection can be made initially.
`--ldap.restart`: whether or not the LDAP library should implicitly restart
connections
`--ldap.referrals`: whether or not the LDAP library should implicitly chase
referrals
`--ldap.debug`: turn on internal OpenLDAP library output (warning: will print
to stdout).
`--ldap.timeout`: timeout value (in seconds) for synchronous LDAP API calls
(a value of 0 means default timeout).
`--ldap.network-timeout`: timeout value (in seconds) after which network operations
following the initial connection return in case of no activity (a value of 0 means
default timeout).
`--ldap.async-connect`: whether or not the connection to the LDAP library will
be done asynchronously.
fixed a shutdown race in ArangoDB's logger, which could have led to some buffered
log messages being discarded on shutdown
display shard synchronization progress for collections outside of the
`_system` database
fixed issue #6611: Properly display JSON properties of user defined foxx services
configuration within the web UI
fixed issue #6583: Agency node segfaults if sent an authenticated HTTP request is sent to its port
when cleaning out a leader it could happen that it became follower instead of
being removed completely
make synchronous replication detect more error cases when followers cannot
apply the changes from the leader
fix some TLS errors that occurred when combining HTTPS/TLS transport with the
VelocyStream protocol (VST)
That combination could have led to spurious errors such as "TLS padding error"
or "Tag mismatch" and connections being closed
agency endpoint updates now go through RAFT

New in ArangoDB 3.3.16 (Sep 24, 2018)

New in ArangoDB 3.3.15 (Sep 13, 2018)

Fixed an issue in the "sorted" AQL COLLECT variant, that may have led to producing
an incorrect number of results
Upgraded arangodb starter version to 0.13.3
Fixed issue #5941 if using breadth-first search in traversals uniqueness checks
on path (vertices and edges) have not been applied. In SmartGraphs the checks
have been executed properly.
Added more detailed progress output to arangorestore, showing the percentage of
how much data is restored for bigger collections plus a set of overview statistics
after each processed collection
Added option `--rocksdb.use-file-logging` to enable writing of RocksDB's own
informational LOG files into RocksDB's database directory.
This option is turned off by default, but can be enabled for debugging RocksDB
internals and performance.
Improved error messages when managing Foxx services
Install/replace/upgrade will now provide additional information when an error
is encountered during setup. Errors encountered during a `require` call will
also include information about the underlying cause in the error message.
Fixed some Foxx script names being displayed incorrectly in web UI and Foxx CLI
Added startup option `--query.optimizer-max-plans value`
This option allows limiting the number of query execution plans created by the
AQL optimizer for any incoming queries. The default value is `128`.
By adjusting this value it can be controlled how many different query execution
plans the AQL query optimizer will generate at most for any given AQL query.
Normally the AQL query optimizer will generate a single execution plan per AQL query,
but there are some cases in which it creates multiple competing plans. More plans
can lead to better optimized queries, however, plan creation has its costs. The
more plans are created and shipped through the optimization pipeline, the more time
will be spent in the optimizer.
Lowering this option's value will make the optimizer stop creating additional plans
when it has already created enough plans.
Note that this setting controls the default maximum number of plans to create. The
value can still be adjusted on a per-query basis by setting the *maxNumberOfPlans*
attribute when running a query.
This change also lowers the default maximum number of query plans from 192 to 128.
Bug fix: facilitate faster shutdown of coordinators and db servers
Upgraded arangodb starter version to 0.13.2
Cluster nodes should retry registering in agency until successful
Fixed some web ui action events related to Running Queries view and Slow
Queries History view
Create a default pacing algorithm for arangoimport to avoid TimeoutErrors
on VMs with limited disk throughput
Backport PR 6150: establish unique function to indicate when
application is terminating and therefore network retries should not occur
Backport PR #5201: eliminate race scenario where handlePlanChange
could run infinite times after an execution exceeded 7.4 second time span

New in ArangoDB 3.3.14 (Aug 17, 2018)

New in ArangoDB 3.3.11 (Jun 28, 2018)

New in ArangoDB 3.3.10 (Jun 6, 2018)

New in ArangoDB 3.3.9 (May 22, 2018)

Added `/_admin/repair/distributeShardsLike` that repairs collections with
distributeShardsLike where the shards aren't actually distributed like in the
prototype collection, as could happen due to internal issue #1770
Fixed Foxx queues bug when queues are created in a request handler with an
ArangoDB authentication header
Upgraded arangosync version to 0.5.1
Upgraded arangodb starter version to 0.11.3
Fix cluster upgrading issue introduced in 3.3.8
the issue made arangod crash when starting a DB server with option
`--database.auto-upgrade true`
Fix C++ implementation of AQL ZIP function to return each distinct attribute
name only once. The previous implementation added non-unique attribute names
multiple times, which led to follow-up issues.
Now if an attribute name occurs multiple times in the input list of attribute
names, it will only be incorporated once into the result object, with the
value that corresponds to the first occurrence.
This fix also changes the V8 implementation of the ZIP function, which now
will always return the first value for non-unique attribute names and not the
last occurring value.
Self heal during a Foxx service install, upgrade or replace no longer breaks
the respective operation
Make /_api/index, /_api/database and /_api/user REST handlers use the scheduler's
internal queue, so they do not run in an I/O handling thread
Fixed issue #4919: C++ implementation of LIKE function now matches the old and
correct behavior of the JavaScript implementation.
Added REST API endpoint /_admin/server/availability for monitoring purposes
UI: fixed an unreasonable event bug within the modal view engine
Fixed issue #3811: gharial api is now checking existence of _from and _to vertices
during edge creation
Fixed internal issue #2149: number of documents in the UI is not adjusted after
moving them
Fixed internal issue #2150: UI - loading a saved query does not update the list
of bind parameters
Fixed internal issue #2147 - fixed database filter in UI
Fixed issue #4934: Wrong used GeoIndex depending on FILTER order
Added `query` and `aql.literal` helpers to `@arangodb` module.
Remove post-sort from GatherNode in cluster AQL queries that do use indexes
for filtering but that do not require a sorted result
This optimization can speed up gathering data from multiple shards, because
it allows to remove a merge sort of the individual shards' results.
Extend the already existing "reduce-extraction-to-projection" AQL optimizer
rule for RocksDB to provide projections of up to 5 document attributes. The
previous implementation only supported a projection for a single document
attribute. The new implementation will extract up to 5 document attributes from
a document while scanning a collection via an EnumerateCollectionNode.
Additionally the new version of the optimizer rule can also produce projections
when scanning an index via an IndexNode.
The optimization is benefial especially for huge documents because it will copy
out only the projected attributes from the document instead of copying the entire
document data from the storage engine.
When applied, the explainer will show the projected attributes in a `projections`
remark for an EnumerateCollectionNode or IndexNode. The optimization is limited
to the RocksDB storage engine.
Added index-only optimization for AQL queries that can satisfy the retrieval of
all required document attributes directly from an index.
This optimization will be triggered for the RocksDB engine if an index is used
that covers all required attributes of the document used later on in the query.
If applied, it will save retrieving the actual document data (which would require
an extra lookup in RocksDB), but will instead build the document data solely
from the index values found. It will only be applied when using up to 5 attributes
from the document, and only if the rest of the document data is not used later
on in the query.
The optimization is currently available for the RocksDB engine for the index types
primary, edge, hash, skiplist and persistent.
If the optimization is applied, it will show up as "index only" in an AQL
query's execution plan for an IndexNode.
Added scan-only optimization for AQL queries that iterate over collections or
indexes and that do not need to return the actual document values.
Not fetching the document values from the storage engine will provide a
considerable speedup when using the RocksDB engine, but may also help a bit
in case of the MMFiles engine. The optimization will only be applied when
full-scanning or index-scanning a collection without refering to any of its
documents later on, and, for an IndexNode, if all filter conditions for the
documents of the collection are covered by the index.
If the optimization is applied, it will show up as "scan only" in an AQL
query's execution plan for an EnumerateCollectionNode or an IndexNode.
Extend existing "collect-in-cluster" optimizer rule to run grouping, counting
and deduplication on the DB servers in several cases, so that the coordinator
will only need to sum up the potentially smaller results from the individual shards.
The following types of COLLECT queries are covered now:
RETURN DISTINCT expr
COLLECT WITH COUNT INTO ...
COLLECT var1 = expr1, ..., varn = exprn (WITH COUNT INTO ...), without INTO or KEEP
COLLECT var1 = expr1, ..., varn = exprn AGGREGATE ..., without INTO or KEEP, for
aggregate functions COUNT/LENGTH, SUM, MIN and MAX.
Honor specified COLLECT method in AQL COLLECT options
for example, when the user explicitly asks for the COLLECT method
to be `sorted`, the optimizer will now not produce an alternative
version of the plan using the hash method.
additionally, if the user explcitly asks for the COLLECT method to
be `hash`, the optimizer will now change the existing plan to use
the hash method if possible instead of just creating an alternative
plan.
`COLLECT ... OPTIONS { method: 'sorted' }` => always use sorted method
`COLLECT ... OPTIONS { method: 'hash' }` => use hash if this is technically possible
`COLLECT ...` (no options) => create a plan using sorted, and another plan using hash method

New in ArangoDB 3.3.8 (Apr 28, 2018)

New in ArangoDB 3.3.7 (Apr 13, 2018)

New in ArangoDB 3.3.5 (Mar 29, 2018)

Fixed issue #4934: Wrong used GeoIndex depending on FILTER order
Make build id appear in startup log message alongside with other version info
Make AQL data modification operations that are sent to all shards and that are supposed to return values (i.e. `RETURN OLD` or `RETURN NEW`) not return fake empty result rows if the document to be updated/replaced/removed was not present on the target shard
Added AQL optimizer rule `restrict-to-single-shard` This rule will kick in if a collection operation (index lookup or data modification operation) will only affect a single shard, and the operation can be restricted to the single shard and is not applied for all shards. This optimization can be applied for queries that access a collection only once in the query, and that do not use traversals, shortest path queries and that do not access collection data dynamically using the `DOCUMENT`, `FULLTEXT`, `NEAR` or `WITHIN` AQL functions. Additionally, the optimizer will only pull off this optimization if can safely determine the values of all the collection's shard keys from the query, and when the shard keys are covered by a single index (this is always true if the shard key is the default `_key`)
Display missing attributes of GatherNodes in AQL explain output
Make AQL optimizer rule `undistribute-remove-after-enum-coll` fire in a few more cases in which it is possible
Slightly improve index selection for the RocksDB engine when there are multiple competing indexes with the same attribute prefixes, but different amount of attributes covered. In this case, the more specialized index will be preferred now
Fix issue #4924: removeFollower now prefers to remove the last follower(s)
Added "collect-in-cluster" optimizer rule to have COLLECT WITH COUNT queries without grouping being executed on the DB servers and the coordinator only summing up the counts from the individual shards
Fixed issue #4900: Nested FOR query uses index but ignores other filters
Properly exit v8::Context in one place where it was missing before
Added hidden option `--cluster.index-create-timeout` for controlling the default value of the index creation timeout in cluster under normal circumstances, this option does not need to be adjusted
Increase default timeout for index creation in cluster to 3600s
Fixed issue #4843: Query-Result has more Docs than the Collection itself
Fixed the behavior of ClusterInfo when waiting for current to catch up with plan in create collection.
Fixed issue #4827: COLLECT on edge _to field doesn't group distinct values as expected (MMFiles)

New in ArangoDB 3.3.4 (Mar 7, 2018)

fix AQL `fullCount` result value in some cluster cases when it was off a bit
fix issue #4651: Simple query taking forever until a request timeout error
fix issue #4657: fixed incomplete content type header
Vastly improved the Foxx Store UI
fix issue #4677: AQL WITH with bind parameters results in "access after data-modification"
for two independent UPSERTs
remove unused startup option `--ldap.permissions-attribute-name`
fix issue #4457: create /var/tmp/arangod with correct user in supervisor mode
remove long disfunctional admin/long_echo handler
fixed Foxx API:
PUT /_api/foxx/service: Respect force flag
PATCH /_api/foxx/service: Check whether a service under given mount exists
internal issue #1726: supervision failed to remove multiple servers
from health monitoring at once.
more information from inception, why agent is activated
fixed a bug where supervision tried to deal with shards of virtual collections
Behaviour of permissions for databases and collections changed:
The new fallback rule for databases for which an access level is not explicitly specified:
Choose the higher access level of:
A wildcard database grant
A database grant on the `_system` database
The new fallback rule for collections for which an access level is not explicitly specified:
Choose the higher access level of:
Any wildcard access grant in the same database, or on "*/*"
The access level for the current database
The access level for the `_system` database
fix internal issue 1770: collection creation using distributeShardsLike yields
errors and did not distribute shards correctly in the following cases:
1. If numberOfShards * replicationFactor % nrDBServers != 0
(shards * replication is not divisible by DBServers).
2. If there was failover / move shard case on the leading collection
and creating the follower collection afterwards.
fix timeout issues in replication client expiration
added missing edge filter to neighbors-only traversals
in case a filter condition was moved into the traverser and the traversal was
executed in breadth-first mode and was returning each visited vertex exactly
once, and there was a filter on the edges of the path and the resulting vertices
and edges were not used later, the edge filter was not applied
fixed issue #4160: Run arangod with "--database.auto-upgrade" option always crash silently without error log
fix internal issue #1848: AQL optimizer was trying to resolve attribute accesses
to attributes of constant object values at query compile time, but only did so far
the very first attribute in each object
this fixes https://stackoverflow.com/questions/48648737/beginner-bug-in-for-loops-from-objects
fix inconvenience: If we want to start server with a non-existing
javascript.app-path it will now be created (if possible)
fixed: REST API `POST _api/foxx` now returns HTTP code 201 on success, as documented.
returned 200 before.
fixed: REST API `PATCH _api/foxx/dependencies` now updates the existing dependencies
instead of replacing them.
fixed: Foxx upload of single javascript file. You now can upload via http-url pointing
to a javascript file.
fixed issue #4395: If your foxx app includes an `APP` folder it got
accidently removed by selfhealing this is not the case anymore.
fixed internal issue #1969 - command apt-get purge/remove arangodb3e was failing

New in ArangoDB 3.3.2 (Jan 8, 2018)

New in ArangoDB 3.3.1 (Dec 29, 2017)

New in ArangoDB 3.3.0 (Dec 21, 2017)

New in ArangoDB 3.2.9 (Dec 5, 2017)

New in ArangoDB 3.2.8 (Nov 20, 2017)

New in ArangoDB 3.2.7 (Nov 16, 2017)

Cluster customers, which have upgraded from 3.1 to 3.2 need to upgrade
to 3.2.7. The cluster supervision is otherwise not operational.
Fixed issue #3597: AQL with path filters returns unexpected results
In some cases breadth first search in combination with vertex filters
yields wrong result, the filter was not applied correctly.
enable JEMalloc background thread for purging and returning unused memory
back to the operating system (Linux only)
fixed some undefined behavior in some internal value caches for AQL GatherNodes
and SortNodes, which could have led to sorted results being effectively not
correctly sorted.
make the replication applier for the RocksDB engine start automatically after a
restart of the server if the applier was configured with its `autoStart` property
set to `true`. previously the replication appliers were only automatically restarted
at server start for the MMFiles engine.
fixed arangodump batch size adaptivity in cluster mode and upped default batch size
for arangodump
these changes speed up arangodump in cluster context
smart graphs now return a proper inventory in response to replication inventory
requests
fixed issue #3618: Inconsistent behavior of OR statement with object bind parameters
only users with read/write rights on the "_system" database can now execute
"_admin/shutdown" as well as modify properties of the write-ahead log (WAL)
increase default maximum number of V8 contexts to at least 16 if not explicitly
configured otherwise.
the procedure for determining the actual maximum value of V8 contexts is unchanged
apart from the value `16` and works as follows:
if explicitly set, the value of the configuration option `--javascript.v8-contexts`
is used as the maximum number of V8 contexts
when the option is not set, the maximum number of V8 contexts is determined
by the configuration option `--server.threads` if that option is set. if
`--server.threads` is not set, then the maximum number of V8 contexts is the
server's reported hardware concurrency (number of processors visible
to the arangod process). if that would result in a maximum value of less than 16
in any of these two cases, then the maximum value will be increased to 16.
fixed issue #3447: ArangoError 1202: AQL: NotFound: (while executing) when
updating collection
potential fix for issue #3581: Unexpected "rocksdb unique constraint
violated" with unique hash index
fixed geo index optimizer rule for geo indexes with a single (array of coordinates)
attribute.
improved the speed of the shards overview in cluster (API endpoint /_api/cluster/shardDistribution API)
It is now guaranteed to return after ~2 seconds even if the entire cluster is unresponsive.
fix agency precondition check for complex objects
this fixes issues with several CAS operations in the agency
several fixes for agency restart and shutdown
the cluster-internal representation of planned collection objects is now more
lightweight than before, using less memory and not allocating any cache for indexes
etc.
fixed issue #3403: How to kill long running AQL queries with the browser console's
AQL (display issue)
fixed issue #3549: server reading ENGINE config file fails on common standard
newline character
UI: fixed error notifications for collection modifications
several improvements for the truncate operation on collections:
the timeout for the truncate operation was increased in cluster mode in
order to prevent too frequent "could not truncate collection" errors
after a truncate operation, collections in MMFiles still used disk space.
to reclaim disk space used by truncated collection, the truncate actions
in the web interface and from the ArangoShell now issue an extra WAL flush
command (in cluster mode, this command is also propagated to all servers).
the WAL flush allows all servers to write out any pending operations into the
datafiles of the truncated collection. afterwards, a final journal rotate
command is sent, which enables the compaction to entirely remove all datafiles
and journals for the truncated collection, so that all disk space can be
reclaimed
for MMFiles a special method will be called after a truncate operation so that
all indexes of the collection can free most of their memory. previously some
indexes (hash and skiplist indexes) partially kept already allocated memory
in order to avoid future memory allocations
after a truncate operation in the RocksDB engine, an additional compaction
will be triggered for the truncated collection. this compaction removes all
deletions from the key space so that follow-up scans over the collection's key
range do not have to filter out lots of already-removed values
These changes make truncate operations potentially more time-consuming than before,
but allow for memory/disk space savings afterwards.
enable JEMalloc background threads for purging and returning unused memory
back to the operating system (Linux only)
JEMalloc will create its background threads on demand. The number of background
threads is capped by the number of CPUs or active arenas. The background threads run
periodically and purge unused memory pages, allowing memory to be returned to the
operating system.
This change will make the arangod process create several additional threads.
It is accompanied by an increased `TasksMax` value in the systemd service configuration
file for the arangodb3 service.
upgraded bundled V8 engine to bugfix version v5.7.492.77
this upgrade fixes a memory leak in upstream V8 described in
https://bugs.chromium.org/p/v8/issues/detail?id=5945 that will result in memory
chunks only getting uncommitted but not unmapped

New in ArangoDB 3.2.6 (Oct 27, 2017)

New in ArangoDB 3.2.5 (Oct 18, 2017)

New in ArangoDB 3.2.4 (Sep 27, 2017)

UI: added replicationFactor option during SmartGraph creation
Make the MMFiles compactor perform less writes during normal compaction
Operation
This partially fixes issue #3144
Make the MMFiles compactor configurable
The following options have been added:
`--compaction.db-sleep-time`: sleep interval between two compaction runs
(in s)
`--compaction.min-interval"`: minimum sleep time between two compaction
Runs (in s)
`--compaction.min-small-data-file-size`: minimal filesize threshold
Original datafiles have to be below for a compaction
`--compaction.dead-documents-threshold`: minimum unused count of documents
In a datafile
`--compaction.dead-size-threshold`: how many bytes of the source data file
Are allowed to be unused at most
`--compaction.dead-size-percent-threshold`: how many percent of the source
Datafile should be unused at least
`--compaction.max-files`: Maximum number of files to merge to one file
`--compaction.max-result-file-size`: how large may the compaction result
File become (in bytes)
`--compaction.max-file-size-factor`: how large the resulting file may
Be in comparison to the collection's `--database.maximal-journal-size' setting`
See https://docs.arangodb.com/3.2/Manual/Administration/Configuration/Compaction.html
For more details.
Fix downwards-incompatibility in /_api/explain REST handler
Fix Windows implementation for fs.getTempPath() to also create a
Sub-directory as we do on linux
Fixed a multi-threading issue in cluster-internal communication
Performance improvements for traversals and edge lookups
Removed internal memory zone handling code. the memory zones were a leftover
From the early ArangoDB days and did not provide any value in the current
Implementation.
(Enterprise only) added `skipInaccessibleCollections` option for AQL queries:
If set, AQL queries (especially graph traversals) will treat collections to
Which a user has no access rights to as if these collections were empty.
Adjusted scheduler thread handling to start and stop less threads in
Normal operations
Leader-follower replication catchup code has been rewritten in C++
Early stage AQL optimization now also uses the C++ implementations of
AQL functions if present. Previously it always referred to the JavaScript
Implementations and ignored the C++ implementations. This change gives
More flexibility to the AQL optimizer.
ArangoDB tty log output is now colored for log messages with levels
FATAL, ERR and WARN.
Changed the return values of AQL functions `REGEX_TEST` and `REGEX_REPLACE`
To `null` when the input regex is invalid. Previous versions of ArangoDB
Partly returned `false` for invalid regexes and partly `null`.
Added `--log.role` option for arangod
When set to `true`, this option will make the ArangoDB logger print a single
Character with the server's role into each logged message. The roles are:
U: undefined/unclear (used at startup)
S: single server
C: coordinator
P: primary
A: agent
The default value for this option is `false`, so no roles will be logged.

New in ArangoDB 3.2.3 (Sep 11, 2017)

New in ArangoDB 3.2.2 (Aug 24, 2017)

Fixed issue #2847: adjust the response of the DELETE `/_api/users/database/*` calls
Fixed issue #3075: Error when upgrading arangoDB on linux ubuntu 16.04
Fixed a buffer overrun in linenoise console input library for long input strings
Increase size of the linenoise input buffer to 8 KB
Abort compilation if the detected GCC or CLANG isn't in the range of compilers
We support
Fixed spurious cluster hangups by always sending AQL-query related requests
To the correct servers, even after failover or when a follower drops
The problem with the previous shard-based approach was that responsibilities
For shards may change from one server to another at runtime, after the query
Was already instanciated. The coordinator and other parts of the query then
Sent further requests for the query to the servers now responsible for the
Shards.
However, an AQL query must send all further requests to the same servers on
Which the query was originally instanciated, even in case of failover.
Otherwise this would potentially send requests to servers that do not know
About the query, and would also send query shutdown requests to the wrong
Servers, leading to abandoned queries piling up and using resources until
They automatically time out.
Fixed issue with RocksDB engine acquiring the collection count values too
Early, leading to the collection count values potentially being slightly off
Even in exclusive transactions (for which the exclusive access should provide
An always-correct count value)
Fixed some issues in leader-follower catch-up code, specifically for the
RocksDB engine
Make V8 log fatal errors to syslog before it terminates the process.
This change is effective on Linux only.
Fixed issue with MMFiles engine creating superfluous collection journals
On shutdown
Fixed issue #3067: Upgrade from 3.2 to 3.2.1 reset autoincrement keys
Fixed issue #3044: ArangoDB server shutdown unexpectedly
Fixed issue #3039: Incorrect filter interpretation
Fixed issue #3037: Foxx, internal server error when I try to add a new service
Improved MMFiles fulltext index document removal performance
And fulltext index query performance for bigger result sets
Ui: fixed a display bug within the slow and running queries view
Ui: fixed a bug when success event triggers twice in a modal
Ui: fixed the appearance of the documents filter
Ui: graph vertex collections not restricted to 10 anymore
Fixed issue #2835: UI detection of JWT token in case of server restart or upgrade
Upgrade jemalloc version to 5.0.1
This fixes problems with the memory allocator returing "out of memory" when
Calling munmap to free memory in order to return it to the OS.
It seems that calling munmap on Linux can increase the number of mappings, at least
When a region is partially unmapped. This can lead to the process exceeding its
Maximum number of mappings, and munmap and future calls to mmap returning errors.
Jemalloc version 5.0.1 does not have the `--enable-munmap` configure option anymore,
So the problem is avoided. To return memory to the OS eventually, jemalloc 5's
Background purge threads are used on Linux.
Fixed issue #2978: log something more obvious when you log a Buffer
Fixed issue #2982: AQL parse error?

New in ArangoDB 3.2.1 (Aug 11, 2017)

Fixed issue #3011: Optimizer rule reduce-extraction-to-projection breaks queries
Now allowing to restore users in a sharded environment as well
It is still not possible to restore collections that are sharded
Differently than by _key.
Fixed an isse with restoring of system collections and user rights.
It was not possible to restore users into an authenticated server.
Fixed issue #2977: Documentation for db._createDatabase is wrong
Ui: added bind parameters to slow query history view
Fixed issue #1751: Slow Query API should provide bind parameters, webui should display them
Ui: fixed a bug when moving multiple documents was not possible
Fixed docs for issue #2968: Collection _key autoincrement value increases on error
AQL CHAR_LENGTH(null) returns now 0. Since AQL TO_STRING(null) is '' (string of length 0)
Ui: now supports single js file upload for Foxx services in addition to zip files
Fixed a multi-threading issue in the agency when callElection was called
While the Supervision was calling updateSnapshot
Added startup option `--query.tracking-with-bindvars`
This option controls whether the list of currently running queries
And the list of slow queries should contain the bind variables used
In the queries or not.
The option can be changed at runtime using the commands
// enables tracking of bind variables
// set to false to turn tracking of bind variables off
Var value = true;
Require("@arangodb/aql/queries").properties({
TrackBindVars: value
});
Index selectivity estimates are now available in the cluster as well
Fixed issue #2943: loadIndexesIntoMemory not returning the same structure
As the rest of the collection APIs
Fixed issue #2949: ArangoError 1208: illegal name
Fixed issue #2874: Collection properties do not return `isVolatile`
Attribute
Potential fix for issue #2939: Segmentation fault when starting
Coordinator node
Fixed issue #2810: out of memory error when running UPDATE/REPLACE
On medium-size collection
Fix potential deadlock errors in collector thread
Disallow the usage of volatile collections in the RocksDB engine
By throwing an error when a collection is created with attribute
`isVolatile` set to `true`.
Volatile collections are unsupported by the RocksDB engine, so
Creating them should not succeed and silently create a non-volatile
Collection
Prevent V8 from issuing SIGILL instructions when it runs out of memory
Now arangod will attempt to log a FATAL error into its logfile in case V8
Runs out of memory. In case V8 runs out of memory, it will still terminate the
Entire process. But at least there should be something in the ArangoDB logs
Indicating what the problem was. Apart from that, the arangod process should
Now be exited with SIGABRT rather than SIGILL as it shouldn't return into the
V8 code that aborted the process with `__builtin_trap`.
This potentially fixes issue #2920: DBServer crashing automatically post upgrade to 3.2
Foxx queues and tasks now ensure that the scripts in them run with the same
Permissions as the Foxx code who started the task / queue
Fixed issue #2928: Offset problems
Fixed issue #2876: wrong skiplist index usage in edge collection
Fixed issue #2868: cname missing from logger-follow results in rocksdb
Fixed issue #2889: Traversal query using incorrect collection id
Fixed issue #2884: AQL traversal uniqueness constraints "propagating" to other traversals? Weird results
Arangoexport: added `--query` option for passing an AQL query to export the result
Fixed issue #2879: No result when querying for the last record of a query
Ui: allows now to edit default access level for collections in database
_system for all users except the root user.
Added new option "--rocksdb.max-background-jobs"
Removed options "--rocksdb.max-background-compactions", "--rocksdb.base-background-compactions" and "--rocksdb.max-background-flushes"
Option "--rocksdb.compaction-read-ahead-size" now defaults to 2MB
Change Windows build so that RocksDB doesn't enforce AVX optimizations by default
Speed up RocksDB secondary index creation and dropping
Removed RocksDB note in Geo index docs

New in ArangoDB 3.2.0 (Jul 20, 2017)

New in ArangoDB 3.1.25 (Jul 17, 2017)

New in ArangoDB 3.1.24 (Jul 17, 2017)

New in ArangoDB 3.1.23 (Jul 17, 2017)

New in ArangoDB 3.1.22 (Jul 17, 2017)

New in ArangoDB 3.1.21 (Jul 17, 2017)

New in ArangoDB 3.1.20 (Jul 17, 2017)

New in ArangoDB 3.1.19 (May 3, 2017)

New in ArangoDB 3.1.18 (Apr 20, 2017)

New in ArangoDB 3.1.17 (Apr 5, 2017)

New in ArangoDB 3.1.16 (Mar 28, 2017)

New in ArangoDB 3.1.15 (Mar 28, 2017)

New in ArangoDB 3.1.14 (Mar 13, 2017)

New in ArangoDB 3.1.13 (Mar 13, 2017)

New in ArangoDB 3.1.12 (Mar 1, 2017)

New in ArangoDB 3.1.11 (Feb 15, 2017)

New in ArangoDB 3.1.10 (Feb 8, 2017)

updated versions of bundled node modules: joi: from 8.4.2 to 9.2.0 / joi-to-json-schema: from 2.2.0 to 2.3.0 / sinon: from 1.17.4 to 1.17.6 / lodash: from 4.13.1 to 4.16.6
added shortcut for AQL ternary operator instead of `condition ? true-part : false-part` it is now possible to also use a shortcut variant `condition ? : false-part`
fixed wrong sorting order in cluster, if an index was used to sort with many shards.
added --replication-factor, --number-of-shards and --wait-for-sync to arangobench
turn on UTF-8 string validation for VelocyPack values received via VST connections
fixed issue #2257
added optional detail flag for db.<collection>.count() setting the flag to `true` will make the count operation returned the per-shard counts for the collection
added optional memory limit for AQL queries: db._query("FOR i IN 1..100000 SORT i RETURN i", {}, { options: { memoryLimit: 100000 } });
This option limits the default maximum amount of memory (in bytes) that a single AQL query can use. When a single AQL query reaches the specified limit value, the query will be aborted with a *resource limit exceeded* exception. In a cluster, the memory accounting is done per shard, so the limit value is effectively a memory limit per query per shard. The global limit value can be overriden per query by setting the *memoryLimit* option value for individual queries when running an AQL query.
added server startup option `--query.memory-limit`
added convenience function to create vertex-centric indexes.
added option -D to define a configuration file environment key=value
changed encoding behavior for URLs encoded in the C++ code of ArangoDB: previously the special characters `-`, `_`, `~` and `.` were returned as-is after URL-encoding, now `.` will be encoded to be `%2e`. This also changes the behavior of how incoming URIs are processed: previously occurrences of `..` in incoming request URIs were collapsed (e.g. `a/../b/` was collapsed to a plain `b/`). Now `..` in incoming request URIs are not collapsed.
improved cluster stability in various ways

New in ArangoDB 3.1.9 (Jan 25, 2017)

New in ArangoDB 3.1.8 (Jan 11, 2017)

New in ArangoDB 3.1.7 (Dec 30, 2016)

New in ArangoDB 3.0.10 (Oct 6, 2016)

New in ArangoDB 3.0.9 (Oct 6, 2016)

New in ArangoDB 3.0.8 (Oct 6, 2016)

New in ArangoDB 3.0.7 (Oct 6, 2016)

New in ArangoDB 3.0.6 (Oct 6, 2016)

New in ArangoDB 3.0.5 (Aug 22, 2016)

New in ArangoDB 3.0.4 (Aug 22, 2016)

New in ArangoDB 3.0.3 (Aug 22, 2016)

New in ArangoDB 3.0.2 (Aug 22, 2016)

New in ArangoDB 3.0.1 (Aug 22, 2016)

New in ArangoDB 3.0.0 (Aug 22, 2016)

New in ArangoDB 3.0.0 RC3 (Aug 22, 2016)

New in ArangoDB 3.0.0 RC2 (Aug 22, 2016)

New in ArangoDB 3.0.0 RC1 (Aug 22, 2016)

the user management has changed: it now has users that are independent of databases. A user can have one or more database assigned to the user.
forward ported V8 Comparator bugfix for inline heuristics
changed to-string conversion for AQL objects and arrays, used by the AQL function `TO_STRING()` and implicit to-string casts in AQL
added C++ implementations for AQL functions `SLICE()`, `CONTAINS()` and `RANDOM_TOKEN()`
as a consequence of the upgrade to V8 version 5, the implementation of the JavaScript `Buffer` object had to be changed. JavaScript `Buffer` objects in ArangoDB now always store their data on the heap. There is no shared pool for small Buffer values, and no pointing into existing Buffer data when extracting slices. This change may increase the cost of creating Buffers with short contents or when peeking into existing Buffers, but was required for safer memory management and to prevent leaks.
the `db` object's function `_listDatabases()` was renamed to just `_databases()` in order to make it more consistent with the existing `_collections()` function. Additionally the `db` object's `_listEndpoints()` function was renamed to just `_endpoints()`.
changed default value of `--server.authentication` from `false` to `true` in configuration files etc/relative/arangod.conf and etc/arangodb/arangod.conf.in. This means the server will be started with authentication enabled by default, requiring all client connections to provide authentication data when connecting to ArangoDB. Authentication can still be turned off via setting the value of `--server.authentication` to `false` in ArangoDB's configuration files or by specifying the option on the command-line.
Changed result format for querying all collections via the API GET `/_api/collection`.
added AQL functions `TYPENAME()` and `HASH()`
renamed arangob tool to arangobench
added AQL string comparison operator `LIKE`
make AQL optimizer rule "remove-unnecessary-calculations" fire in more cases
renamed AQL optimizer rule "merge-traversal-filter" to "optimize-traversals"
added AQL optimizer rule "inline-subqueries"
added new endpoint "srv://" for DNS service records
The result order of the AQL functions VALUES and ATTRIBUTES has never been guaranteed and it only had the "correct" ordering by accident when iterating over objects that were not loaded from the database. This accidental behavior is now changed by introduction of VelocyPack. No ordering is guaranteed unless you specify the sort parameter.
removed configure option `--enable-logger`
added AQL array comparison operators
improved AQL optimizer to remove unnecessary sort operations in more cases
allow enclosing AQL identifiers in forward ticks in addition to using backward ticks
allow to set `print.limitString` to configure the number of characters to output before truncating
make logging configurable per log "topic"
the option `--log.requests-file` is now deprecated
the option `--log.facility` is now deprecated
the option `--log.performance` is now deprecated
removed option `--log.source-filter`
removed configure option `--enable-logger`
change collection directory names to include a random id component at the end
removed mostly unused internal spin-lock implementation
removed support for pre-Windows 7-style locks. This removes compatibility for Windows versions older than Windows 7 (e.g. Windows Vista, Windows XP) and Windows 2008R2 (e.g. Windows 2008).
changed names of sub-threads started by arangod
added option `--default-number-of-shards` to arangorestore, allowing creating collections with a specifiable number of shards from a non-cluster dump
removed support for CoffeeScript source files
removed undocumented SleepAndRequeue
added WorkMonitor to inspect server threads
when downloading a Foxx service from the web interface the suggested filename is now based on the service's mount path instead of simply "app.zip"
the `@arangodb/request` response object now stores the parsed JSON response body in a property `json` instead of `body` when the request was made using the `json` option. The `body` instead contains the response body as a string.
the Foxx API has changed significantly, 2.8 services are still supported using a backwards-compatible "legacy mode"

New in ArangoDB 2.8.10 (Aug 22, 2016)

New in ArangoDB 2.8.9 (Aug 22, 2016)

New in ArangoDB 2.8.8 (Aug 22, 2016)

New in ArangoDB 2.8.7 (Aug 22, 2016)

New in ArangoDB 2.8.6 (Aug 22, 2016)

New in ArangoDB 2.8.5 (Aug 22, 2016)

New in ArangoDB 2.8.4 (Mar 3, 2016)

New in ArangoDB 2.8.3 (Mar 3, 2016)

New in ArangoDB 2.8.2 (Mar 3, 2016)

the continuous replication applier will now prevent the master's WAL logfiles from being removed if they are still needed by the applier on the slave. This should help slaves that suffered from masters garbage collection WAL logfiles which would have been needed by the slave later.
The initial synchronization will block removal of still needed WAL logfiles on the master for 10 minutes initially, and will extend this period when further requests are made to the master. Initial synchronization hands over its handle for blocking logfile removal to the continuous replication when started via the *setupReplication* function. In this case, continuous replication will extend the logfile removal blocking period for the required WAL logfiles when the slave makes additional requests.
All handles that block logfile removal will time out automatically after at most 5 minutes should a master not be contacted by the slave anymore (e.g. in case the slave's replication is turned off, the slaves loses the connection to the master or the slave goes down).
added all-in-one function *setupReplication* to synchronize data from master to slave and start the continuous replication:
require("org/arangodb/replication").setupReplication(configuration);
The command will return when the initial synchronization is finished and the continuous replication has been started, or in case the initial synchronization has failed.
If the initial synchronization is successful, the command will store the given configuration on the slave. It also configures the continuous replication to start automatically if the slave is restarted, i.e. *autoStart* is set to *true*.
If the command is run while the slave's replication applier is already running, it will first stop the running applier, drop its configuration and do a resynchronization of data with the master. It will then use the provided configration, overwriting any previously existing replication configuration on the slave.
The following example demonstrates how to use the command for setting up replication for the *_system* database. Note that it should be run on the slave and not the master:
db._useDatabase("_system");
require("org/arangodb/replication").setupReplication({
endpoint: "tcp://master.domain.org:8529",
username: "myuser",
password: "mypasswd",
verbose: false,
includeSystem: false,
incremental: true,
autoResync: true
the *sync* and *syncCollection* functions now always start the data synchronization as an asynchronous server job. The call to *sync* or *syncCollection* will block until synchronization is either complete or has failed with an error. The functions will automatically poll the slave periodically for status updates.
The main benefit is that the connection to the slave does not need to stay open permanently and is thus not affected by timeout issues. Additionally the caller does not need to query the synchronization status from the slave manually as this is now performed automatically by these functions.
fixed undefined behavior when explaining some types of AQL traversals, fixed display of some types of traversals in AQL explain output

New in ArangoDB 2.8.1 (Feb 1, 2016)

New in ArangoDB 2.8.0 (Jan 28, 2016)

New in ArangoDB 2.7.3 (Dec 21, 2015)

New in ArangoDB 2.7.2 (Dec 21, 2015)

replication improvements
added `autoResync` configuration parameter for continuous replication.
When set to `true`, a replication slave will automatically trigger a full data re-synchronization with the master when the master cannot provide the log data the slave had asked for. Note that `autoResync` will only work when the option `requireFromPresent` is also set to `true` for the continuous replication, or when the continuous syncer is started and detects that no start tick is present.
Automatic re-synchronization may transfer a lot of data from the master to the slave and may be expensive. It is therefore turned off by default. When turned off, the slave will never perform an automatic re-synchronization with the master.
added `idleMinWaitTime` and `idleMaxWaitTime` configuration parameters for continuous replication.
These parameters can be used to control the minimum and maximum wait time the slave will (intentionally) idle and not poll for master log changes in case the master had sent the full logs already. The `idleMaxWaitTime` value will only be used when `adapativePolling` is set to `true`. When `adaptivePolling` is disable, only `idleMinWaitTime` will be used as a constant time span in which the slave will not poll the master for further changes. The default values are 0.5 seconds for `idleMinWaitTime` and 2.5 seconds for `idleMaxWaitTime`, which correspond to the hard-coded values used in previous versions of ArangoDB.
added `initialSyncMaxWaitTime` configuration parameter for initial and continuous replication
This option controls the maximum wait time (in seconds) that the initial synchronization will wait for a response from the master when fetching initial collection data. If no response is received within this time period, the initial synchronization will give up and fail. This option is also relevant for continuous replication in case *autoResync* is set to *true*, as then the continuous replication may trigger a full data re-synchronization in case the master cannot the log data the slave had asked for.
HTTP requests sent from the slave to the master during initial synchronization will now be retried if they fail with connection problems.
the initial synchronization now logs its progress so it can be queried using the regular replication status check APIs.
fixed non-deterministic query results in some cluster queries
added missing lock instruction for primary index in compactor size calculation
fixed issue #1589
fixed issue #1583
fixed undefined behavior when accessing the top level of a document with the `[*]`operator
fixed potentially invalid pointer access in shaper when the currently accessed document got re-located by the WAL collector at the very same time
Foxx: optional configuration options no longer log validation errors when assigned empty values (#1495)
Foxx: constructors provided to Repository and Model sub-classes via extend are now correctly called (#1592)
Foxx: services generated with the admin frontend now use unambiguous require paths.

New in ArangoDB 2.7.1 (Dec 21, 2015)

New in ArangoDB 2.7.0 (Dec 21, 2015)

New in ArangoDB 2.6.10 (Dec 21, 2015)

New in ArangoDB 2.6.9 (Dec 21, 2015)

New in ArangoDB 2.6.7 (Dec 21, 2015)

New in ArangoDB 2.6.6 (Dec 21, 2015)

New in ArangoDB 2.6.5 (Dec 21, 2015)

New in ArangoDB 2.6.4 (Aug 15, 2015)

New in ArangoDB 2.6.3 (Aug 15, 2015)

New in ArangoDB 2.6.2 (Aug 15, 2015)

New in ArangoDB 2.6.1 (Aug 15, 2015)

New in ArangoDB 2.6.0 (Jun 22, 2015)

using negative values for `SimpleQuery.skip()` is deprecated.
This functionality will be removed in future versions of ArangoDB.
The following simple query functions are now deprecated:
collection.near
collection.within
collection.geo
collection.fulltext
collection.range
collection.closedRange
This also lead to the following REST API methods being deprecated from now on:
PUT /_api/simple/near
PUT /_api/simple/within
PUT /_api/simple/fulltext
PUT /_api/simple/range
It is recommended to replace calls to these functions or APIs with equivalent AQL queries, which are more flexible because they can be combined with other operations:
FOR doc IN NEAR(@@collection, @latitude, @longitude, @limit) - RETURN doc
FOR doc IN WITHIN(@@collection, @latitude, @longitude, @radius, @distanceAttributeName) - RETURN doc
FOR doc IN FULLTEXT(@@collection, @attributeName, @queryString, @limit) - RETURN doc
FOR doc IN @@collection - FILTER doc.value >= @left && doc.value < @right
LIMIT @skip, @limit - RETURN doc`
The above simple query functions and REST API methods may be removed in future versions of ArangoDB.
deprecated now-obsolete AQL `SKIPLIST` function:
The function was introduced in older versions of ArangoDB with a less powerful query optimizer to retrieve data from a skiplist index using a `LIMIT` clause. Since 2.3 the same goal can be achieved by using regular AQL constructs, e.g. FOR doc IN collection FILTER doc.value >= @value SORT doc.value DESC LIMIT 1 RETURN doc
fixed issues when switching the database inside tasks and during shutdown of database cursors:
These features were added during 2.6 alpha stage so the fixes affect devel/2.6-alpha builds only; issue #1360: improved foxx-manager help
added `--enable-tcmalloc` configure option:
When this option is set, arangod and the client tools will be linked against tcmalloc, which replaces
the system allocator. When the option is set, a tcmalloc library must be present on the system under one of the names `libtcmalloc`, `libtcmalloc_minimal` or `libtcmalloc_debug`.
As this is a configure option, it is supported for manual builds on Linux-like systems only. tcmalloc; support is currently experimental.
issue #1353: Windows: HTTP API - incorrect path in errorMessage
issue #1347: added option `--create-database` for arangorestore.
Setting this option to `true` will now create the target database if it does not exist. When creating the target database, the username and passwords passed to arangorestore will be used to create an initial user for the new database.
issue #1345: advanced debug information for User Functions
issue #1341: Can't use bindvars in UPSERT
fixed vulnerability in JWT implementation.
changed default value of option `--database.ignore-datafile-errors` from `true` to `false`
If the new default value of `false` is used, then arangod will refuse loading collections that contain datafiles with CRC mismatches or other errors. A collection with datafile errors will then become unavailable. This prevents follow up errors from happening.
The only way to access such collection is to use the datafile debugger (arango-dfdb) and try to repair or truncate the datafile with it.
If `--database.ignore-datafile-errors` is set to `true`, then collections will become available even if parts of their data cannot be loaded. This helps availability, but may cause (partial) data loss and follow up errors.
added server startup option `--server.session-timeout` for controlling the timeout of user sessions in the web interface
add sessions and cookie authentication for ArangoDB's web interface
ArangoDB's built-in web interface now uses sessions. Session information ids are stored in cookies, so clients using the web interface must accept cookies in order to use it
web interface: display query execution time in AQL editor
web interface: renamed AQL query *submit* button to *execute*
web interface: added query explain feature in AQL editor
web interface: demo page added. only working if demo data is available, hidden otherwise
web interface: added support for custom app scripts with optional arguments and results
web interface: mounted apps that need to be configured are now indicated in the app overview
web interface: added button for running tests to app details
web interface: added button for configuring app dependencies to app details
web interface: upgraded API documentation to use Swagger 2
INCOMPATIBLE CHANGE:
removed startup option `--log.severity`
The docs for `--log.severity` mentioned lots of severities (e.g. `exception`, `technical`, `functional`, `development`) but only a few severities (e.g. `all`, `human`) were actually used, with `human` being the default and `all` enabling the additional logging of requests. So the option pretended to control a lot of things which it actually didn't. Additionally, the option `--log.requests-file` was around for a long time already, also controlling request logging.
Because the `--log.severity` option effectively did not control that much, it was removed. A side effect of removing the option is that 2.5 installations which used `--log.severity all` will not log requests after the upgrade to 2.6. This can be adjusted by setting the `--log.requests-file` option.
add backtrace to fatal log events
added optional `limit` parameter for AQL function `FULLTEXT`
make fulltext index also index text values contained in direct sub-objects of the indexed attribute.
Previous versions of ArangoDB only indexed the attribute value if it was a string. Sub-attributes of the index attribute were ignored when fulltext indexing.
Now, if the index attribute value is an object, the object's values will each be included in the fulltext index if they are strings. If the index attribute value is an array, the array's values will each be included in the fulltext index if they are strings. For example, with a fulltext index present on the `translations` attribute, the following text values will now be indexed:
var c = db._create("example");
c.ensureFulltextIndex("translations");
c.insert({ translations: { en: "fox", de: "Fuchs", fr: "renard", ru: "????" } });
c.insert({ translations: "Fox is the English translation of the German word Fuchs" });
c.insert({ translations: [ "ArangoDB", "document", "database", "Foxx" ] });
c.fulltext("translations", "????").toArray(); // returns only first document
c.fulltext("translations", "Fox").toArray(); // returns first and second documents
c.fulltext("translations", "prefix:Fox").toArray(); // returns all three documents
added batch document removal and lookup commands:
collection.lookupByKeys(keys)
collection.removeByKeys(keys)
These commands can be used to perform multi-document lookup and removal operations efficiently from the ArangoShell. The argument to these operations is an array of document keys.
Also added HTTP APIs for batch document commands:
PUT /_api/simple/lookup-by-keys
PUT /_api/simple/remove-by-keys
properly prefix document address URLs with the current database name for calls to the REST
API method GET `/_api/document?collection=...` (that method will return partial URLs to all
documents in the collection).
Previous versions of ArangoDB returned the URLs starting with `/_api/` but without the current database name, e.g. `/_api/document/mycollection/mykey`. Starting with 2.6, the response URLs will include the database name as well, e.g. `/_db/_system/_api/document/mycollection/mykey`.
added dedicated collection export HTTP REST API
ArangoDB now provides a dedicated collection export API, which can take snapshots of entire collections more efficiently than the general-purpose cursor API. The export API is useful to transfer the contents of an entire collection to a client application. It provides optional filtering on specific attributes.
The export API is available at endpoint `POST /_api/export?collection=...`. The API has the same return value structure as the already established cursor API (`POST /_api/cursor`).
An introduction to the export API is given in this blog post:
http://jsteemann.github.io/blog/2015/04/04/more-efficient-data-exports/
subquery optimizations for AQL queries
This optimization avoids copying intermediate results into subqueries that are not required by the subquery.
return value optimization for AQL queries
This optimization avoids copying the final query result inside the query's main `ReturnNode`.
speed up AQL queries containing big `IN` lists for index lookups
IN` lists used for index lookups had performance issues in previous versions of ArangoDB.
These issues have been addressed in 2.6 so using bigger `IN` lists for filtering is much faster.
allow `@` and `.` characters in document keys, too
This change also leads to document keys being URL-encoded when returned in HTTP `location` response headers.
added alternative implementation for AQL COLLECT
The alternative method uses a hash table for grouping and does not require its input elements to be sorted. It will be taken into account by the optimizer for `COLLECT` statements that do not use an `INTO` clause.
In case a `COLLECT` statement can use the hash table variant, the optimizer will create an extra plan for it at the beginning of the planning phase. In this plan, no extra `SORT` node will be added in front of the `COLLECT` because the hash table variant of `COLLECT` does not require
sorted input. Instead, a `SORT` node will be added after it to sort its output. This `SORT` node may be optimized away again in later stages. If the sort order of the result is irrelevant to the user, adding an extra `SORT null` after a hash `COLLECT` operation will allow the optimizer to remove the sorts altogether.
In addition to the hash table variant of `COLLECT`, the optimizer will modify the original plan to use the regular `COLLECT` implementation. As this implementation requires sorted input, the optimizer will insert a `SORT` node in front of the `COLLECT`. This `SORT` node may be optimized
away in later stages.
The created plans will then be shipped through the regular optimization pipeline. In the end, the optimizer will pick the plan with the lowest estimated total cost as usual. The hash table variant does not require an up-front sort of the input, and will thus be preferred over the regular `COLLECT` if the optimizer estimates many input elements for the `COLLECT` node and cannot use an index to sort them.
The optimizer can be explicitly told to use the regular *sorted* variant of `COLLECT` by suffixing a `COLLECT` statement with `OPTIONS { "method" : "sorted" }`. This will override the optimizer guesswork and only produce the *sorted* variant of `COLLECT`.
A blog post on the new `COLLECT` implementation can be found here:
http://jsteemann.github.io/blog/2015/04/22/collecting-with-a-hash-table/
refactored HTTP REST API for cursors
The HTTP REST API for cursors (`/_api/cursor`) has been refactored to improve its performance and use less memory.
simplified return value syntax for data-modification AQL queries
ArangoDB 2.4 since version allows to return results from data-modification AQL queries. The syntax for this was quite limited and verbose:
FOR i IN 1..10
INSERT { value: i } IN test
LET inserted = NEW
RETURN inserted
The `LET inserted = NEW RETURN inserted` was required literally to return the inserted documents. No calculations could be made using the inserted documents.
This is now more flexible. After a data-modification clause (e.g. `INSERT`, `UPDATE`, `REPLACE`, REMOVE`, `UPSERT`) there can follow any number of `LET` calculations. These calculations can refer to the pseudo-values `OLD` and `NEW` that are created by the data-modification statements.
This allows returning projections of inserted or updated documents, e.g.:
FOR i IN 1..10
INSERT { value: i } IN test
RETURN { _key: NEW._key, value: i }
Still not every construct is allowed after a data-modification clause. For example, no functions can be called that may access documents.
added AQL `UPSERT` statement
This adds an `UPSERT` statement to AQL that is a combination of both `INSERT` and `UPDATE` /
REPLACE`. The `UPSERT` will search for a matching document using a user-provided example.
If no document matches the example, the *insert* part of the `UPSERT` statement will be executed. If there is a match, the *update* / *replace* part will be carried out:
UPSERT { page: 'index.html' } /* search example */
INSERT { page: 'index.html', pageViews: 1 } /* insert part */
UPDATE { pageViews: OLD.pageViews + 1 } /* update part */
IN pageViews
UPSERT` can be used with an `UPDATE` or `REPLACE` clause. The `UPDATE` clause will perform a partial update of the found document, whereas the `REPLACE` clause will replace the found document entirely. The `UPDATE` or `REPLACE` parts can refer to the pseudo-value `OLD`, which
contains all attributes of the found document.
UPSERT` statements can optionally return values. In the following query, the return attribute `found` will return the found document before the `UPDATE` was applied. If no document was found, `found` will contain a value of `null`. The `updated` result attribute will contain the inserted / updated document:
UPSERT { page: 'index.html' } /* search example */
INSERT { page: 'index.html', pageViews: 1 } /* insert part */
UPDATE { pageViews: OLD.pageViews + 1 } /* update part */
IN pageViews
RETURN { found: OLD, updated: NEW }
adjusted default configuration value for `--server.backlog-size` from 10 to 64.
issue #1231: bug xor feature in AQL: LENGTH(null) == 4
This changes the behavior of the AQL `LENGTH` function as follows:
if the single argument to `LENGTH()` is `null`, then the result will now be `0`. In previous
versions of ArangoDB, the result of `LENGTH(null)` was `4`.
if the single argument to `LENGTH()` is `true`, then the result will now be `1`. In previous
versions of ArangoDB, the result of `LENGTH(true)` was `4`.
if the single argument to `LENGTH()` is `false`, then the result will now be `0`. In previous
versions of ArangoDB, the result of `LENGTH(false)` was `5`.
The results of `LENGTH()` with string, numeric, array object argument values do not change.
issue #1298: Bulk import if data already exists (#1298)
This change extends the HTTP REST API for bulk imports as follows:
When documents are imported and the `_key` attribute is specified for them, the import can be used for inserting and updating/replacing documents. Previously, the import could be used for inserting new documents only, and re-inserting a document with an existing key would have failed
with a *unique key constraint violated* error.
The above behavior is still the default. However, the API now allows controlling the behavior in case of a unique key constraint error via the optional URL parameter `onDuplicate`.
This parameter can have one of the following values:
error`: when a unique key constraint error occurs, do not import or update the document but report an error. This is the default.
update`: when a unique key constraint error occurs, try to (partially) update the existing document with the data specified in the import. This may still fail if the document would violate secondary unique indexes. Only the attributes present in the import data will be updated and other attributes already present will be preserved. The number of updated documents
will be reported in the `updated` attribute of the HTTP API result.
replace`: when a unique key constraint error occurs, try to fully replace the existing document with the data specified in the import. This may still fail if the document would violate secondary unique indexes. The number of replaced documents will be reported in the updated` attribute of the HTTP API result.
ignore`: when a unique key constraint error occurs, ignore this error. There will be no insert, update or replace for the particular document. Ignored documents will be reported separately in the `ignored` attribute of the HTTP API result.
The result of the HTTP import API will now contain the attributes `ignored` and `updated`, which contain the number of ignored and updated documents respectively. These attributes will contain a value of zero unless the `onDuplicate` URL parameter is set to either `update` or `replace`
in this case the `updated` attribute may contain non-zero values) or `ignore` (in this case the ignored` attribute may contain a non-zero value).
To support the feature, arangoimp also has a new command line option `--on-duplicate` which can have one of the values `error`, `update`, `replace`, `ignore`. The default value is `error`.
changed behavior of `db._query()` in the ArangoShell:
if the command's result is printed in the shell, the first 10 results will be printed. Previously only a basic description of the underlying query result cursor was printed. Additionally, if the cursor result contains more than 10 results, the cursor is assigned to a global variable `more`,
which can be used to iterate over the cursor result.
Disallow batchSize value 0 in HTTP `POST /_api/cursor`:
The HTTP REST API `POST /_api/cursor` does not accept a `batchSize` parameter value of 0` any longer. A batch size of 0 never made much sense, but previous versions of ArangoDB did not check for this value. Now creating a cursor using a `batchSize` value 0 will result in an HTTP 400 error response
REST Server: fix memory leaks when failing to add jobs EDGES' AQL Function
The AQL function EDGES got a new fifth option parameter.
Right now only one option is available: 'includeVertices'. This is a boolean parameter that allows to modify the result of the `EDGES` function.
Default is 'includeVertices: false' which does not have any effect.
includeVertices: true' modifies the result, such that vertex: , edge: } is returned.
INCOMPATIBLE CHANGE:
The result format of the AQL function `NEIGHBORS` has been changed.
Before it has returned an array of objects containing 'vertex' and 'edge'.
Now it will only contain the vertex directly.
Also an additional option 'includeData' has been added.
This is used to define if only the 'vertex._id' value should be returned (false, default), or if the vertex should be looked up in the collection and the complete JSON should be returned true).
Using only the id values can lead to significantly improved performance if this is the only information required.
In order to get the old result format prior to ArangoDB 2.6, please use the function EDGES instead.
Edges allows for a new option 'includeVertices' which, set to true, returns exactly the format of NEIGHBORS.
Example:
NEIGHBORS(, , , , )
This can now be achieved by:
EDGES(, , , , , {includeVertices: true})
If you are nesting several NEIGHBORS steps you can speed up their performance in the following way:
Old Example:
FOR va IN NEIGHBORS(Users, relations, 'Users/123', 'outbound') FOR vc IN NEIGHBORS(Products, relations, va.vertex._id, 'outbound') RETURN vc
This can now be achieved by:
FOR va IN NEIGHBORS(Users, relations, 'Users/123', 'outbound') FOR vc IN NEIGHBORS(Products, relations, va, 'outbound', null, {includeData: true}) RETURN vc
Use intermediate directly include Data for final
INCOMPATIBLE CHANGE:
The AQL function `GRAPH_NEIGHBORS` now provides an additional option `includeData`.
This option allows controlling whether the function should return the complete vertices or just their IDs. Returning only the IDs instead of the full vertices can lead to improved performance .
If provided, `includeData` is set to `true`, all vertices in the result will be returned with all their attributes. The default value of `includeData` is `false`.
This makes the default function results incompatible with previous versions of ArangoDB.
To get the old result style in ArangoDB 2.6, please set the options as follows in calls to `GRAPH_NEIGHBORS`:
GRAPH_NEIGHBORS(, , { includeData: true })
INCOMPATIBLE CHANGE:
The AQL function `GRAPH_COMMON_NEIGHBORS` now provides an additional option `includeData`.
This option allows controlling whether the function should return the complete vertices or just their IDs. Returning only the IDs instead of the full vertices can lead toimproved performance .If provided, `includeData` is set to `true`, all vertices in the result will be returned with all their attributes. The default value of `includeData` is `false`.
This makes the default function results incompatible with previous versions of ArangoDB. To get the old result style in ArangoDB 2.6, please set the options as follows in calls to `GRAPH_COMMON_NEIGHBORS`:
GRAPH_COMMON_NEIGHBORS(, , , { includeData: true }, { includeData: true })
INCOMPATIBLE CHANGE:
The AQL function `GRAPH_SHORTEST_PATH` now provides an additional option `includeData`.
This option allows controlling whether the function should return the complete vertices and edges or just their IDs. Returning only the IDs instead of full vertices and edges can lead to improved performance .
If provided, `includeData` is set to `true`, all vertices and edges in the result will be returned with all their attributes. There is also an optional parameter `includePath` of type object.
It has two optional sub-attributes `vertices` and `edges`, both of type boolean.
Both can be set individually and the result will include all vertices on the path if includePath.vertices == true` and all edges if `includePath.edges == true` respectively.
The default value of `includeData` is `false`, and paths are now excluded by default.
This makes the default function results incompatible with previous versions of ArangoDB.
To get the old result style in ArangoDB 2.6, please set the options as follows in calls to `GRAPH_SHORTEST_PATH`:
GRAPH_SHORTEST_PATH(, , , { includeData: true, includePath: { edges: true, vertices: true } })
INCOMPATIBLE CHANGE:
All graph measurements functions in JavaScript module `general-graph` that calculated a single figure previously returned an array containing just the figure. Now these functions
will return the figure directly and not put it inside an array.
The affected functions are:
graph._absoluteEccentricity`
graph._eccentricity`
graph._absoluteCloseness`
graph._closeness`
graph._absoluteBetweenness`
graph._betweenness`
graph._radius`
graph._diameter`
Create the `_graphs` collection in new databases with `waitForSync` attribute set to `false`
The previous `waitForSync` value was `true`, so default the behavior when creating and dropping graphs via the HTTP REST API changes as follows if the new settings are in effect:
POST /_api/graph` by default returns `HTTP 202` instead of `HTTP 201`
DELETE /_api/graph/graph-name` by default returns `HTTP 202` instead of `HTTP 201`
If the `_graphs` collection still has its `waitForSync` value set to `true`, then the HTTP status code will not change.
added support for HTTP push aka chunked encoding
issue #1051: add info whether server is running in service or user mode?
This will add a "mode" attribute to the result of the result of HTTP GET `/_api/version?details=true`
"mode" can have the following values:
standalone`: server was started manually (e.g. on command-line)
service`: service is running as Windows service, in daemon mode or under the supervisor improve system error messages in Windows port
increased default value of `--server.request-timeout` from 300 to 1200 seconds for client tools arangosh, arangoimp, arangodump, arangorestore)
increased default value of `--server.connect-timeout` from 3 to 5 seconds for client tools arangosh, arangoimp, arangodump, arangorestore)
added startup option `--server.foxx-queues-poll-interval`
This startup option controls the frequency with which the Foxx queues manager is checking the queue (or queues) for jobs to be executed.
The default value is `1` second. Lowering this value will result in the queue manager waking up and checking the queues more frequently, which may increase CPU usage of the server.
When not using Foxx queues, this value can be raised to save some CPU time.
added startup option `--server.foxx-queues`
This startup option controls whether the Foxx queue manager will check queue and job entries.
Disabling this option can reduce server load but will prevent jobs added to Foxx queues from being processed at all.
The default value is `true`, enabling the Foxx queues feature.
make Foxx queues really database-specific.
Foxx queues were and are stored in a database-specific collection `_queues`. However, a global cache variable for the queues led to the queue names being treated database-independently, which
was wrong. Since 2.6, Foxx queues names are truly database-specific, so the same queue name can be used in two different databases for two different queues. Until then, it is advisable to think of queues as already being database-specific, and using the database name as a queue name prefix to be avoid name conflicts, e.g.:
var queueName = "myQueue";
var Foxx = require("org/arangodb/foxx");
Foxx.queues.create(db._name() + ":" + queueName);
added support for Foxx queue job types defined as app scripts.
The old job types introduced in 2.4 are still supported but are known to cause issues in 2.5 and later when the server is restarted or the job types are not defined in every thread.
The new job types avoid this issue by storing an explicit mount path and script name rather than an assuming the job type is defined globally. It is strongly recommended to convert your job types to the new script-based system.
renamed Foxx sessions option "sessionStorageApp" to "sessionStorage". The option now also accepts session storages directly.
Added the following JavaScript methods for file access:
fs.copyFile() to copy single files
fs.copyRecursive() to copy diretory trees
fs.chmod() to set the file permissions (non-Windows onnly)
Added process.env for accessing the process environment from JavaScript code
Cluster: kickstarter shutdown routines will more precisely follow the shutdown of its nodes.
Cluster: don't delete agency connection objects that are currently in use.
Cluster: improve passing along of HTTP errors
fixed issue #1247: debian init script problems
multi-threaded index creation on collection load
When a collection contains more than one secondary index, they can be built in memory in parallel when the collection is loaded. How many threads are used for parallel index creation
is determined by the new configuration parameter `--database.index-threads`. If this is set to 0, indexes are built by the opening thread only and sequentially. This is equivalent to the behavior in 2.5 and before.
speed up building up primary index when loading collections
added `count` attribute to `parameters.json` files of collections. This attribute indicates the number of live documents in the collection on unload. It is read when the collection is re)loaded to determine the initial size for the collection's primary index
removed remainders of MRuby integration, removed arangoirb
simplified `controllers` property in Foxx manifests. You can now specify a filename directly if you only want to use a single file mounted at the base URL of your Foxx app.
simplified `exports` property in Foxx manifests. You can now specify a filename directly if you only want to export variables from a single file in your Foxx app.
added support for node.js-style exports in Foxx exports. Your Foxx exports file can now export arbitrary values using the `module.exports` property instead of adding properties to the exports` object.
added `scripts` property to Foxx manifests. You should now specify the `setup` and `teardown`files as properties of the `scripts` object in your manifests and can define custom,
app-specific scripts that can be executed from the web interface or the CLI.
added `tests` property to Foxx manifests. You can now define test cases using the `mocha` framework which can then be executed inside ArangoDB.
updated `joi` package to 6.0.8.
added `extendible` package.
added Foxx model lifecycle events to repositories. See #1257.
speed up resizing of edge index.
allow to split an edge index into buckets which are resized individually.
This is controlled by the `indexBuckets` attribute in the `properties`
of the collection.
fix a cluster deadlock bug in larger clusters by marking a thread waiting
for a lock on a DBserver as blocked

New in ArangoDB 2.5.5 (Jun 22, 2015)

New in ArangoDB 2.5.4 (May 18, 2015)

New in ArangoDB 2.5.3 (May 7, 2015)

New in ArangoDB 2.5.2 (Apr 15, 2015)

New in ArangoDB 2.5.1 (Mar 21, 2015)

added option `--database.ignore-logfile-errors`:
This option controls how collection datafiles with a CRC mismatch are treated.
If set to `false`, CRC mismatch errors in collection datafiles will lead to a collection not being loaded at all. If a collection needs to be loaded during WAL recovery, the WAL recovery will also abort (if not forced with `--wal.ignore-recovery-errors true`). Setting this flag to `false` protects users from unintentionally using a collection with corrupted datafiles, from which only a subset of the original data can be recovered.
If set to `true`, CRC mismatch errors in collection datafiles will lead to the datafile being partially loaded. All data up to until the mismatch will be loaded. This will enable users to continue with a collection datafiles that are corrupted, but will result in only a partial load of the data. The WAL recovery will still abort when encountering a collection with a corrupted datafile, at least if `--wal.ignore-recovery-errors` is not set to`true`.
The default value is *true*, so for collections with corrupted datafiles there might be partial data loads once the WAL recovery has finished. If the WAL recovery will need to load a collection with a corrupted datafile, it will still stop when using the default values.
INCOMPATIBLE CHANGE:
make the arangod server refuse to start if during startup it finds a non-readable`parameter.json` file for a database or a collection.
Stopping the startup process in this case requires manual intervention (fixing the unreadable files), but prevents follow-up errors due to ignored databases or collections from happening.
datafiles and `parameter.json` files written by arangod are now created with read and write privileges for the arangod process user, and with read and write prileges for the arangod process group.
Previously, these files were created with user read and write permissions only.
INCOMPATIBLE CHANGE:
abort WAL recovery if one of the collection's datafiles cannot be opened
INCOMPATIBLE CHANGE:
never try to raise the privileges after dropping them, this can lead to a race condition while running the recovery
If you require to run ArangoDB on a port lower than 1024, you must run ArangoDB as root.
fixed inefficiencies in `remove` methods of general-graph module added option `--database.slow-query-threshold` for controlling the default AQL slow query threshold value on server start add system error strings for windows on many places rework service startup so we anounce 'RUNNING' only when we're finished starting.
use the windows eventlog for FATAL and ERROR - log messages fix service handling in NSIS windows installer, specify human readable name add the ICU_DATA environment variable to the fatal error messages fixed issue 1265: arangod crashed with SIGSEGV
fixed issue #1241: Wildcards in examples

New in ArangoDB 2.5.0 (Mar 12, 2015)

New in ArangoDB 2.4.4 (Mar 11, 2015)

New in ArangoDB 2.4.3 (Feb 25, 2015)

New in ArangoDB 2.4.2 (Feb 25, 2015)

added custom visitor functionality for AQL traversals
This allows more complex result processing in traversals triggered by AQL.
improved number of results estimated for nodes of type EnumerateListNode and SubqueryNode in AQL explain output
added AQL explain helper to explain arbitrary AQL queries
The helper function prints the query execution plan and the indexes to be used in the query. It can be invoked from the ArangoShell or the web interface as follows: require("org/arangodb/aql/explainer").explain(query);
enable use of indexes for certain AQL conditions with non-equality predicates, in case the condition(s) also refer to indexed attributes
The following queries will now be able to use indexes:
FILTER a.indexed == ... && a.indexed != ...
FILTER a.indexed == ... && a.nonIndexed != ...
FILTER a.indexed == ... && ! (a.indexed == ...)
FILTER a.indexed == ... && ! (a.nonIndexed == ...)
FILTER a.indexed == ... && ! (a.indexed != ...)
FILTER a.indexed == ... && ! (a.nonIndexed != ...)
FILTER (a.indexed == ... && a.nonIndexed == ...) || (a.indexed == ... && a.nonIndexed == ...)
FILTER (a.indexed == ... && a.nonIndexed != ...) || (a.indexed == ... && a.nonIndexed != ...)
Fixed spuriously occurring "collection not found" errors when running queries on local collections on a cluster DB server
Fixed upload of Foxx applications to the server for apps exceeding approx. 1 MB zipped.
Malformed Foxx applications will now return a more useful error when any route is requested.
In Production a Foxx app mounted on /app will display an html page on /app/* stating a 503 Service temporarily not available.
It will not state any information about your Application.
Before it was a 404 Not Found without any information and not distinguishable from a correct not found on your route.
In Development Mode the html page also contains information about the error occured.
Unhandled errors thrown in Foxx routes are now handled by the Foxx framework itself.
In Production the route will return a status 500 with a body {error: "Error statement"}. In Development the route will return a status 500 with a body {error: "Error statement", stack: "..."}
Before, it was status 500 with a plain text stack including ArangoDB internal routing information.
The Applications tab in web interface will now request development apps more often.
So if you have a fixed a syntax error in your app it should always be visible after reload.

New in ArangoDB 2.4.1 (Jan 21, 2015)

New in ArangoDB 2.4.0 (Jan 20, 2015)

New in ArangoDB 2.4.0 Beta 1 (Jan 17, 2015)

fixed superstates in FoxxGenerator
fixed issue #1065: Aardvark: added creation of documents and edges with _key property
fixed issue #1198: Aardvark: current AQL editor query is now cached
Upgraded V8 version from 3.16.14 to 3.29.59:
The built-in version of V8 has been upgraded from 3.16.14 to 3.29.59.
This activates several ES6 (also dubbed *Harmony* or *ES.next*) features in
ArangoDB, both in the ArangoShell and the ArangoDB server. They can be
used for scripting and in server-side actions such as Foxx routes, traversals
etc.
The following ES6 features are available in ArangoDB 2.4 by default: iterators the `of` operator symbols predefined collections types (Map, Set etc.) typed arrays
Many other ES6 features are disabled by default, but can be made available by starting arangod or arangosh with the appropriate options: arrow functions proxies generators
String, Array, and Number enhancements constants
enhanced object and numeric literals
To activate all these ES6 features in arangod or arangosh, start it with
the following options: arangosh --javascript.v8-options="--harmony --harmony_generators"
Added Foxx generator for building Hypermedia APIs
New `Applications` tab in web interface:
The `applications` tab got a complete redesign.
It will now only show applications that are currently running on ArangoDB.
For a selected application, a new detailed view has been created.
This view provides a better overview of the app:
author
license
version
contributors
download links
API documentation
To install a new application, a new dialogue is now available.
It provides the features already available in the console application `foxx manager` plus some more:
install an application from Github
install an application from a zip file
install an application from ArangoDB's application store
create a new application from scratch: this feature uses a generator to
create a Foxx application with pre-defined CRUD methods for a given list
of collections. The generated Foxx app can either be downloaded as a zip file or be installed on the server. Starting with a new Foxx app has never been easier.
fixed issue #1102: Aardvark: Layout bug in documents overview:
The documents overview was entirely destroyed in some situations on Firefox.
We replaced the plugin we used there.
fixed issue #1168: Aardvark: pagination buttons jumping
fixed issue #1161: Aardvark: Click on Import JSON imports previously uploaded file
removed configure options `--enable-all-in-one-v8`, `--enable-all-in-one-icu`,
and `--enable-all-in-one-libev`.
global internal rename to fix naming incompatibilities with JSON:
Internal functions with names containing `array` have been renamed to `object`
internal functions with names containing `list` have been renamed to `array`
The renaming was mainly done in the C++ parts. The documentation has also been
adjusted so that the correct JSON type names are used in most places
The change also led to the addition of a few function aliases in AQL
TO_LIST` now is an alias of the new `TO_ARRAY`
IS_LIST` now is an alias of the new `IS_ARRAY`
IS_DOCUMENT` now is an alias of the new `IS_OBJECT`
The changed also renamed the option `mergeArrays` to `mergeObjects` for AQL
data-modification query options and HTTP document modification API
AQL: added optimizer rule "remove-filter-covered-by-index":
This rule removes FilterNodes and CalculationNodes from an execution plan if the filter is already covered by a previous IndexRangeNode. Removing the CalculationNode and the FilterNode will speed up query execution because the query requires less computation.
AQL: added optimizer rule "remove-sort-rand":
This rule removes a `SORT RAND()` expression from a query and moves the random iteration into the appropriate `EnumerateCollectionNode`. This is more efficient than individually enumerating and then sorting randomly.
AQL: range optimizations for IN and OR:
This change enables usage of indexes for several additional cases. Filters containing the `IN` operator can now make use of indexes, and multiple OR- or AND-combined filter conditions can now also use indexes if the filters are accessing the same indexed attribute.
fixed issue #500: AQL parentheses issue:
This change allows passing subqueries as AQL function parameters without using
duplicate brackets (e.g. `FUNC(query)` instead of `FUNC((query))`
added optional `COUNT` clause to AQL `COLLECT`
fixed missing makeDirectory when fetching a Foxx application from a zip file
fixed issue #1134: Change the default endpoint to localhost:
This change will modify the IP address ArangoDB listens on to 127.0.0.1 by default. This will make new ArangoDB installations unaccessible from clients other than localhost unless changed. This is a security feature. To make ArangoDB accessible from any client, change the server's configuration server.endpoint`) to either `tcp://0.0.0.0:8529` or the server's publicly visible IP address.
deprecated `Repository#modelPrototype`. Use `Repository#model` instead.
IMPORTANT CHANGE: by default, system collections are included in replication and all replication API return values. This will lead to user accounts and credentials data being replicated from master to slave servers. This may overwrite slave-specific database users. If this is undesired, the `_users` collection can be excluded from replication easily by setting the `includeSystem` attribute to `false` in the following commands: replication.sync({ includeSystem: false }); replication.applier.properties({ includeSystem: false }); This will exclude all system collections (including `_aqlfunctions`, `_graphs` etc.) from the initial synchronisation and the continuous replication. If this is also undesired, it is also possible to specify a list of collections to exclude from the initial synchronisation and the continuous replication using the restrictCollections` attribute. The HTTP API methods for fetching the replication inventory and for dumping collections
also support the `includeSystem` control flag via a URL parameter.
removed DEPRECATED replication methods:
replication.logger.start()`
replication.logger.stop()`
replication.logger.properties()`
HTTP PUT `/_api/replication/logger-start`
HTTP PUT `/_api/replication/logger-stop`
HTTP GET `/_api/replication/logger-config`
HTTP PUT `/_api/replication/logger-config`
fixed issue #1174, which was due to locking problems in distributed AQL execution
improved cluster locking for AQL avoiding deadlocks
use DistributeNode for modifying queries with REPLACE and UPDATE, if possible

New in ArangoDB 2.3.4 (Jan 17, 2015)

New in ArangoDB 2.3.3 (Jan 17, 2015)

New in ArangoDB 2.3.2 (Dec 18, 2014)

New in ArangoDB 2.3.1 (Dec 2, 2014)

New in ArangoDB 2.3.0 (Dec 2, 2014)

New in ArangoDB 2.2.6 (Oct 22, 2014)

New in ArangoDB 2.2.5 (Oct 13, 2014)

New in ArangoDB 2.2.4 (Oct 2, 2014)

fixed accessing `_from` and `_to` attributes in `collection.byExample` and `collection.firstExample`:
These internal attributes were not handled properly in the mentioned functions, so searching for them did not always produce documents
fixed issue #1030: arangoimp 2.2.3 crashing, not logging on large Windows CSV file
fixed issue #1025: Traversal not as expected in undirected graph
fixed issue #1020:
This requires re-introducing the startup option `--database.force-sync-properties`.
This option can again be used to force fsyncs of collection, index and database properties stored as JSON strings on disk in files named `parameter.json`. Syncing these files after a write may be necessary if the underlying storage does not sync file contents by itself in a "sensible" amount of time after a file has been written and closed.
The default value is `true` so collection, index and database properties will always be synced to disk immediately. This affects creating, renaming and dropping collections as well as creating and dropping databases and indexes. Each of these operations will perform an additional fsync on the `parameter.json` file if the option is set to `true`.
It might be sensible to set this option to `false` for workloads that create and drop a lot of collections (e.g. test runs).
Document operations such as creating, updating and dropping documents are not affected by this option.
fixed issue #1016: AQL editor bug
fixed issue #1014: WITHIN function returns wrong distance
fixed AQL shortest path calculation in function `GRAPH_SHORTEST_PATH` to return complete vertex objects instead of just vertex ids
allow changing of attributes of documents stored in server-side JavaScript variables
Previously, the following did not work -
var doc = db.collection.document(key);
doc._key = "abc"; // overwriting internal attributes not supported
doc.value = 123; // overwriting existing attributes not supported
Now, modifying documents stored in server-side variables (e.g. `doc` in the above case) is supported. Modifying the variables will not update the documents in the database, but will modify the JavaScript object (which can be written back to the database using`db.collection.update` or `db.collection.replace`)
fixed issue #997: arangoimp apparently doesn't support files >2gig on Windows
large file support (requires using `_stat64` instead of `stat`) is now supported on Windows

New in ArangoDB 2.2.3 (Sep 5, 2014)

New in ArangoDB 2.2.2 (Aug 9, 2014)

New in ArangoDB 2.2.1 (Jul 25, 2014)

New in ArangoDB 2.2.0 (Jul 14, 2014)

The replication methods `logger.start`, `logger.stop` and `logger.properties` are no-ops in ArangoDB 2.2 as there is no separate replication logger anymore. Data changes are logged into the write-ahead log in ArangoDB 2.2, and not separately by the replication logger. The replication logger object is still there in ArangoDB 2.2 to ensure backwards-compatibility, however, logging cannot be started, stopped or configured anymore. INCOMPATIBLE CHANGE: replication of transactions has changed. Previously, transactions were logged on a master in one big block and shipped to a slave in one block, too. Now transactions will be logged and replicated as separate entries, allowing transactions to be bigger and also ensure replication progress. INCOMPATIBLE CHANGE: the figures reported by the `collection.figures` method now only reflect documents and data contained in the journals and datafiles of collections. Documents or deletions contained only in the write-ahead log will not influence collection figures until the write-ahead log garbage collection kicks in. The figures for a collection might therefore underreport the total resource usage of a collection. Additionally, the attributes `lastTick` and `uncollectedLogfileEntries` have been added to the result of the `figures` operation and the HTTP API method `PUT /_api/collection/figures`
added `insert` method as an alias for `save`.
added support for data-modification AQL queries
added AQL keywords `INSERT`, `UPDATE`, `REPLACE` and `REMOVE` (and `WITH`) to support data-modification AQL queries. disallow storing of JavaScript objects that contain JavaScript native objects of type `Date`, `Function`, `RegExp` or `External`. The replication methods `logger.start`, `logger.stop` and `logger.properties` are no-ops in ArangoDB 2.2 as there is no separate replication logger anymore. Data changes are logged into the write-ahead log in ArangoDB 2.2, and not separately by the replication logger. The replication logger object is still there in ArangoDB 2.2 to ensure backwards-compatibility, however, logging cannot be started, stopped or configured anymore. Using any of these methods will do nothing. INCOMPATIBLE CHANGE: replication of transactions has changed. Previously, transactions were logged on a master in one big block and shipped to a slave in one block, too. Now transactions will be logged and replicated as separate entries, allowing transactions to be bigger and also ensure replication progress. INCOMPATIBLE CHANGE: the figures reported by the `collection.figures` method now only reflect documents and data contained in the journals and datafiles of collections. Documents or deletions contained only in the write-ahead log will not influence collection figures until the write-ahead log garbage collection kicks in. The figures for a collection might therefore underreport the total resource usage of a collection.
added `insert` method as an alias for `save`.
added support for data-modification AQL queries
added AQL keywords `INSERT`, `UPDATE`, `REPLACE` and `REMOVE` (and `WITH`) to support data-modification AQL queries. disallow storing of JavaScript objects that contain JavaScript native objects of type `Date`, `Function`, `RegExp` or `External`.
honor startup option `--server.disable-statistics` when deciding whether or not to start periodic statistics collection jobs.
removed startup option `--random.no-seed`. This option had no effect in previous versions of ArangoDB and was thus removed.
removed startup option `--database.remove-on-drop`. This option was used for debugging only.
removed startup option `--database.force-sync-properties`. This option is now superfluous as collection properties are now stored in the write-ahead log.
introduced write-ahead log
removed startup option `--server.disable-replication-logger`. This option is superfluous in ArangoDB 2.2. There is no dedicated replication logger in ArangoDB 2.2. There is now always the write-ahead log, and it is also used as the server's replication log. Specifying the startup option `--server.disable-replication-logger` will do nothing in ArangoDB 2.2, but the option should not be used anymore as it might be removed in a future version.
changed behavior of replication logger. There is no dedicated replication logger in ArangoDB 2.2 as there is the write-ahead log now. The existing APIs for starting and stopping the replication logger still exist in ArangoDB 2.2 for downwards-compatibility, but calling the start or stop operations are no-ops in ArangoDB 2.2. When querying the replication logger status via the API, the server will always report that the replication logger is running. Configuring the replication logger is a no-op in ArangoDB 2.2, too. Changing the replication logger configuration has no effect. Instead, the write-ahead log configuration can be changed.
removed MRuby integration for arangod
reclaim index memory when last document in collection is deleted inlined and optimized functions in hash indexes
added AQL TRANSLATE function
fixed datafile debugger
fixed check-version for empty directory
moved try/catch block to the top of routing chain
added mountedApp function for foxx-manager
fixed issue #883: arango 2.1 - when starting multi-machine cluster, UI web does not change to cluster overview
fixed dfdb: should not start any other V8 threads
cleanup of version-check, added module org/arangodb/database-version, added --check-version option
fixed issue #881: [2.1.0] Bombarded (every 10 sec or so) with "WARNING format string is corrupt" when in non-system DB Dashboard
specialized primary index implementation to allow faster hash table rebuilding and reduce lookups in datafiles for the actual value of `_key`.
issue #862: added `--overwrite` option to arangoimp
removed number of property lookups for documents during AQL queries that access documents
prevent buffering of long print results in arangosh's and arangod's print command. removed sorting of attribute names for use in a collection's shaper
fixed a bug in arangodump which got the collection name in _from and _to attributes of edges wrong (all were "_unknown")
fixed a bug in arangorestore which did not recognise wrong _from and _to attributes of edges
improved error detection and reporting in arangorestore

New in ArangoDB 2.1.2 (Jun 18, 2014)

New in ArangoDB 2.1.1 (Jun 9, 2014)

New in ArangoDB 2.1.0 (May 30, 2014)

New in ArangoDB 2.0.7 (May 6, 2014)

New in ArangoDB 2.0.6 (Apr 24, 2014)

New in ArangoDB 2.0.4 (Apr 15, 2014)

New in ArangoDB 2.0.3 (Apr 14, 2014)

New in ArangoDB 2.0.2 (Apr 7, 2014)

New in ArangoDB 2.0.1 (Apr 2, 2014)

New in ArangoDB 2.0.1 RC1 (Mar 20, 2014)

New in ArangoDB 1.4.11 (Mar 1, 2014)

New in ArangoDB 1.4.10 (Mar 1, 2014)

New in ArangoDB 1.4.9 (Feb 14, 2014)

New in ArangoDB 1.4.8 (Feb 1, 2014)

New in ArangoDB 1.4.7 (Jan 24, 2014)

New in ArangoDB 1.4.6 (Jan 21, 2014)

New in ArangoDB 1.4.5 (Jan 16, 2014)

New in ArangoDB 1.4.4 (Dec 27, 2013)

uid and gid are now set in the scripts, there is no longer a separate config file for arangod when started from a script
foxx-manager is now an alias for arangosh
arango-dfdb is now an alias for arangod, moved from bin to sbin
changed from readline to linenoise for Windows
added --install-service and --uninstall-service for Windows
removed --daemon and --supervisor for Windows
arangosh and arangod now uses the config-file which maps the binary name, i. e. if you rename arangosh to foxx-manager it will use the config file foxx-manager.conf
fixed lock file for Windows
fixed issue #711, #687: foxx-manager throws internal errors
added `--server.ssl-protocol` option for client tools this allows connecting from arangosh, arangoimp, arangoimp etc. to an ArangoDB server that uses a non-default value for `--server.ssl-protocol`. The default value for the SSL protocol is 4 (TLSv1). If the server is configured to use a different protocol, it was not possible to connect to it with the client tools.
added more detailed request statistics. This adds the number of async-executed HTTP requests plus the number of HTTP requests per individual HTTP method type.
added `--force` option for arangorestore this option allows continuing a restore operation even if the server reports errors in the middle of the restore operation
better error reporting for arangorestore in case the server returned an HTTP error, arangorestore previously reported this error as `internal error` without any details only. Now server-side errors are reported by arangorestore with the server's error message
include more system collections in dumps produced by arangodump previously some system collections were intentionally excluded from dumps, even if the dump was run with `--include-system-collections`. for example, the collections `_aal`, `_modules`, `_routing`, and `_users` were excluded. This makes sense in a replication context but not always in a dump context. When specifying `--include-system-collections`, arangodump will now include the above- mentioned collections in the dump, too. Some other system collections are still excluded even when the dump is run with `--include-system-collections`, for example `_replication` and `_trx`.
fixed issue #701: ArangoStatement undefined in arangosh
fixed typos in configuration files

New in ArangoDB 1.4.0 (Nov 1, 2013)

fixed issue #648: /batch API is missing from Web Interface API Docummentation (Swagger)
fixed issue #647: Icon tooltips missing
fixed issue #646: index creation in web interface
fixed issue #645: Allow jumping from edge to linked vertices
merged PR for issue #643: Some minor corrections and a link to "Downloads"
fixed issue #642: Completion of error handling
fixed issue #639: compiling v1.4 on maverick produces warnings on -Wstrict-null-sentinel
fixed issue #634: Web interface bug: Escape does not always propagate
fixed issue #620: added startup option `--server.default-api-compatibility` This adds the following changes to the ArangoDB server and clients: the server provides a new startup option `--server.default-api-compatibility`. This option can be used to determine the compatibility of (some) server API return values. The value for this parameter is a server version number, calculated as follows: `10000 major + 100 minor` (e.g. `10400` for ArangoDB 1.3). The default value is `10400` (1.4), the minimum allowed value is `10300` (1.3). When setting this option to a value lower than the current server version, the server might respond with old-style results to "old" clients, increasing compatibility with "old" (non-up-to-date) clients.
the server will on each incoming request check for an HTTP header `x-arango-version`. Clients can optionally set this header to the API version number they support. For example, if a client sends the HTTP header`x-arango-version: 10300`, the server will pick this up and might send ArangoDB1.3-style responses in some situations.
Setting either the startup parameter or using the HTTP header (or both) allows running "old" clients with newer versions of ArangoDB, without having to adjust the clients too much.
the `location` headers returned by the server for the APIs `/_api/document/...` and `/_api/collection/...` will have different values depending on the used API version. If the API compatibility is `10300`, the `location` headers returned will look like this: location: /_api/document/.... whereas when an API compatibility of `10400` or higher is used, the `location` headers will look like this: location: /_db//_api/document/... Please note that even in the presence of this, old API versions still may not be supported forever by the server.
fixed issue #643: Some minor corrections and a link to "Downloads" by @frankmayer
started issue #642: Completion of error handling
fixed issue #639: compiling v1.4 on maverick produces warnings on -Wstrict-null-sentinel
fixed issue #621: Standard Config needs to be fixed
added function to manage indexes (web interface)
improved server shutdown time by signalling shutdown to applicationserver, logging, cleanup and compactor threads
added foxx-manager `replace` command
added foxx-manager `installed` command (a more intuitive alias for `list`)
fixed issue #617: Swagger API is missing '/_api/version'
fixed issue #615: Swagger API: Some commands have no parameter entry forms
fixed issue #614: API : Typo in : Request URL /_api/database/current
fixed issue #609: Graph viz tool - different background color
fixed issue #608: arangosh config files - eventually missing in the manual
fixed issue #607: Admin interface: no core documentation
fixed issue #603: Aardvark Foxx App Manager
fixed a bug in type-mapping between AQL user functions and the AQL layer.
create less system collections when creating a new database