CHANGELOG

v1.4.2 (2013-11-20)
-------------------

* ported Windows version to use native Windows API SRWLocks (slim read-write locks) 
  and condition variables instead of homemade versions

  MSDN states the following about the compatibility of SRWLocks and Condition Variables:

      Minimum supported client:
      Windows Server 2008 [desktop apps | Windows Store apps]

      Minimum supported server:
      Windows Vista [desktop apps | Windows Store apps]
  
* fixed issue #662: ArangoDB on Windows hanging

  This fixes a deadlock issue that occurred on Windows when documents were written to
  a collection at the same time when some other thread tried to drop the collection.

* fixed file-based logging in Windows
 
  the logger complained on startup if the specified log file already existed

* fixed startup of server in daemon mode (`--daemon` startup option)

* fixed a segfault in the AQL optimiser

* issue #671: Method graph.measurement does not exist

* changed Windows condition variable implementation to use Windows native
  condition variables
  
  This is an attempt to fix spurious Windows hangs as described in issue #662.

* added documentation for JavaScript traversals 

* added --code-page command-line option for Windows version of arangosh

* fixed a problem when creating edges via the web interface.

  The problem only occurred if a collection was created with type "document
  collection" via the web interface, and afterwards was dropped and re-created
  with type "edge collection". If the web interface page was not reloaded,
  the old collection type (document) was cached, making the subsequent creation
  of edges into the (seeming-to-be-document) collection fail.

  The fix is to not cache the collection type in the web interface. Users of
  an older version of the web interface can reload the collections page if they
  are affected.

* fixed a caching problem in arangosh: if a collection was created using the web
  interface, and then removed via arangosh, arangosh did not actually drop the
  collection due to caching.

  Because the `drop` operation was not carried out, this caused misleading error
  messages when trying to re-create the collection (e.g. `cannot create collection:
  duplicate name`).

* fixed ALT-introduced characters for arangosh console input on Windows

  The Windows readline port was not able to handle characters that are built
  using CTRL or ALT keys. Regular characters entered using the CTRL or ALT keys
  were silently swallowed and not passed to the terminal input handler.
  
  This did not seem to cause problems for the US keyboard layout, but was a
  severe issue for keyboard layouts that require the ALT (or ALT-GR) key to 
  construct characters. For example, entering the character `{` with a German
  keyboard layout requires pressing ALT-GR + 9. 

* fixed issue #665: Hash/skiplist combo madness bit my ass

  this fixes a problem with missing/non-deterministic rollbacks of inserts in
  case of a unique constraint violation into a collection with multiple secondary
  indexes (with at least one of them unique)

* fixed issue #664: ArangoDB installer on windows requires drive c:

* partly fixed issue #662: ArangoDB on Windows hanging

  This fixes dropping databases on Windows. In previous 1.4 versions on Windows,
  one shape collection file was not unloaded and removed when dropping a database,
  leaving one directory and one shape collection file in the otherwise-dropped
  database directory.

* fixed issue #660: updated documentation on indexes


v1.4.1 (2013-11-08)
-------------------

* performance improvements for skip-list deletes


v1.4.1-rc1 (2013-11-07)
-----------------------

* fixed issue #635: Web-Interface should have a "Databases" Menu for Management

* fixed issue #624: Web-Interface is missing a Database selector

* fixed segfault in bitarray query

* fixed issue #656: Cannot create unique index through web interface

* fixed issue #654: bitarray index makes server down

* fixed issue #653: Slow query

* fixed issue #650: Randonmess of any() should be improved

* made AQL `DOCUMENT()` function polymorphic and work with just one parameter.

  This allows using the `DOCUMENT` function like this:

      DOCUMENT('users/john') 
      DOCUMENT([ 'users/john', 'users/amy' ]) 

  in addition to the existing use cases:

      DOCUMENT(users, 'users/john')
      DOCUMENT(users, 'john')
      DOCUMENT(users, [ 'users/john' ])
      DOCUMENT(users, [ 'users/john', 'users/amy' ])
      DOCUMENT(users, [ 'john', 'amy' ])

* simplified usage of ArangoDB batch API

  It is not necessary anymore to send the batch boundary in the HTTP `Content-Type`
  header. Previously, the batch API expected the client to send a Content-Type header
  of`multipart/form-data; boundary=<some boundary value>`. This is still supported in
  ArangoDB 1.5, but clients can now also omit this header. If the header is not 
  present in a client request, ArangoDB will ignore the request content type and
  read the MIME boundary from the beginning of the request body.

  This also allows using the batch API with the Swagger "Try it out" feature (which is
  not too good at sending a different or even dynamic content-type request header).

* added API method GET `/_api/database/user` 

  This returns the list of databases a specific user can see without changing the
  username/passwd.

* issue #424: Documentation about IDs needs to be upgraded


v1.4.0 (2013-10-29)
-------------------

* 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 ArangoDB
    1.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/<database name>/_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

  The bug caused errors like the following when working with collection documents
  in an AQL user function:

      TypeError: Cannot assign to read only property '_id' of #<ShapedJson>

* create less system collections when creating a new database

  This is achieved by deferring collection creation until the collections are actually
  needed by ArangoDB. The following collections are affected by the change:
  - `_fishbowl`
  - `_structures`


v1.4.0-beta2 (2013-10-14)
-------------------------

* fixed compaction on Windows 

  The compaction on Windows did not ftruncate the cleaned datafiles to a smaller size.
  This has been fixed so not only the content of the files is cleaned but also files
  are re-created with potentially smaller sizes.

* only the following system collections will be excluded from replication from now on:
  - `_replication`
  - `_trx`
  - `_users`
  - `_aal`
  - `_fishbowl`
  - `_modules`
  - `_routing`

  Especially the following system collections will now be included in replication:
  - `_aqlfunctions`
  - `_graphs`
  
  In previous versions of ArangoDB, all system collections were excluded from the 
  replication.

  The change also caused a change in the replication logger and applier:
  in previous versions of ArangoDB, only a collection's id was logged for an operation.
  This has not caused problems for non-system collections but for system collections 
  there ids might differ. In addition to a collection id ArangoDB will now also log the
  name of a collection for each replication event.

  The replication applier will now look for the collection name attribute in logged
  events preferrably.

* added database selection to arango-dfdb

* provide foxx-manager, arangodump, and arangorestore in Windows build

* ArangoDB 1.4 will refuse to start if option `--javascript.app-path` is not set.

* added startup option `--server.allow-method-override`

  This option can be set to allow overriding the HTTP request method in a request using
  one of the following custom headers:

  - x-http-method-override
  - x-http-method
  - x-method-override

  This allows bypassing proxies and tools that would otherwise just let certain types of
  requests pass. Enabling this option may impose a security risk, so it should only be
  used in very controlled environments.

  The default value for this option is `false` (no method overriding allowed).

* added "details" URL parameter for bulk import API
  
  Setting the `details` URL parameter to `true` in a call to POST `/_api/import` will make
  the import return details about non-imported documents in the `details` attribute. If
  `details` is `false` or omitted, no `details` attribute will be present in the response.
  This is the same behavior that previous ArangoDB versions exposed.

* added "complete" option for bulk import API
 
  Setting the `complete` URL parameter to `true` in a call to POST `/_api/import` will make
  the import completely fail if at least one of documents cannot be imported successfully.

  It defaults to `false`, which will make ArangoDB continue importing the other documents
  from the import even if some documents cannot be imported. This is the same behaviour that
  previous ArangoDB versions exposed.

* added missing swagger documentation for `/_api/log`

* calling `/_api/logs` (or `/_admin/logs`) is only permitted from the `_system` database now.
  
  Calling this API method for/from other database will result in an HTTP 400.

' ported fix from https://github.com/novus/nvd3/commit/0894152def263b8dee60192f75f66700cea532cc
  
  This prevents JavaScript errors from occurring in Chrome when in the admin interface, 
  section "Dashboard".

* show current database name in web interface (bottom right corner)

* added missing documentation for /_api/import in swagger API docs 

* allow specification of database name for replication sync command replication applier

  This allows syncing from a master database with a different name than the slave database.

* issue #601: Show DB in prompt

  arangosh now displays the database name as part of the prompt by default.
  
  Can change the prompt by using the `--prompt` option, e.g.

      > arangosh --prompt "my db is named \"%d\"> "


v1.4.0-beta1 (2013-10-01)
-------------------------

* make the Foxx manager use per-database app directories

  Each database now has its own subdirectory for Foxx applications. Each database
  can thus use different Foxx applications if required. A Foxx app for a specific
  database resides in `<app-path>/databases/<database-name>/<app-name>`.

  System apps are shared between all databases. They reside in `<app-path>/system/<app-name>`.

* only trigger an engine reset in development mode for URLs starting with `/dev/`

  This prevents ArangoDB from reloading all Foxx applications when it is not
  actually necessary.

* changed error code from 10 (bad parameter) to 1232 (invalid key generator) for 
  errors that are due to an invalid key generator specification when creating a new
  collection

* automatic detection of content-type / mime-type for Foxx assets based on filenames,
  added possibility to override auto detection

* added endpoint management API at `/_api/endpoint`

* changed HTTP return code of PUT `/_api/cursor` from 400 to 404 in case a
  non-existing cursor is referred to

* issue #360: added support for asynchronous requests

  Incoming HTTP requests with the headers `x-arango-async: true` or 
  `x-arango-async: store` will be answered by the server instantly with a generic 
  HTTP 202 (Accepted) response. 
  
  The actual requests will be queued and processed by the server asynchronously, 
  allowing the client to continue sending other requests without waiting for the
  server to process the actually requested operation.

  The exact point in time when a queued request is executed is undefined. If an
  error occurs during execution of an asynchronous request, the client will not
  be notified by the server.

  The maximum size of the asynchronous task queue can be controlled using the new
  option `--scheduler.maximal-queue-size`. If the queue contains this many number of
  tasks and a new asynchronous request comes in, the server will reject it with an
  HTTP 500 (internal server error) response.
  
  Results of incoming requests marked with header `x-arango-async: true` will be
  discarded by the server immediately. Clients have no way of accessing the result
  of such asynchronously executed request. This is just _fire and forget_.

  To later retrieve the result of an asynchronously executed request, clients can
  mark a request with the header `x-arango-async: keep`. This makes the server
  store the result of the request in memory until explicitly fetched by a client
  via the `/_api/job` API. The `/_api/job` API also provides methods for basic
  inspection of which pending or already finished requests there are on the server,
  plus ways for garbage collecting unneeded results.

* Added new option `--scheduler.maximal-queue-size`.

* issue #590: Manifest Lint

* added data dump and restore tools, arangodump and arangorestore.

  arangodump can be used to create a logical dump of an ArangoDB database, or
  just dedicated collections. It can be used to dump both a collection's structure
  (properties and indexes) and data (documents).

  arangorestore can be used to restore data from a dump created with arangodump.
  arangorestore currently does not re-create any indexes, and doesn't yet handle
  referenced documents in edges propertly when doing just partial restores.
  This will be fixed until 1.4 stable.
  
* introduced `--server.database` option for arangosh, arangoimp, and arangob.

  The option allows these client tools to use a certain database for their actions.
  In arangosh, the current database can be switched at any time using the command

      db._useDatabase(<name>);

  When no database is specified, all client tools will assume they should use the
  default database `_system`. This is done for downwards-compatibility reasons.

* added basic multi database support (alpha)

  New databases can be created using the REST API POST `/_api/database` and the
  shell command `db._createDatabase(<name>)`.

  The default database in ArangoDB is called `_system`. This database is always
  present and cannot be deleted by the user. When an older version of ArangoDB is
  upgraded to 1.4, the previously only database will automatically become the
  `_system` database.

  New databases can be created with the above commands, and can be deleted with the
  REST API DELETE `/_api/database/<name>` or the shell command `db._dropDatabase(<name>);`.

  Deleting databases is still unstable in ArangoDB 1.4 alpha and might crash the
  server. This will be fixed until 1.4 stable.

  To access a specific database via the HTTP REST API, the `/_db/<name>/` prefix 
  can be used in all URLs. ArangoDB will check if an incoming request starts with
  this prefix, and will automatically pick the database name from it. If the prefix
  is not there, ArangoDB will assume the request is made for the default database 
  (`_system`). This is done for downwards-compatibility reasons.

  That means, the following URL pathnames are logically identical:

      /_api/document/mycollection/1234
      /_db/_system/document/mycollection/1234

  To access a different database (e.g. `test`), the URL pathname would look like this:

      /_db/test/document/mycollection/1234

  New databases can also be created and existing databases can only be dropped from
  within the default database (`_system`). It is not possible to drop the `_system`
  database itself.

  Cross-database operations are unintended and unsupported. The intention of the
  multi-database feature is to have the possibility to have a few databases managed
  by ArangoDB in parallel, but to only access one database at a time from a connection 
  or a request.

  When accessing the web interface via the URL pathname `/_admin/html/` or `/_admin/aardvark`,
  the web interface for the default database (`_system`) will be displayed.
  To access the web interface for a different database, the database name can be
  put into the URLs as a prefix, e.g. `/_db/test/_admin/html` or 
  `/_db/test/_admin/aardvark`.

  All internal request handlers and also all user-defined request handlers and actions
  (including Foxx) will only get to see the unprefixed URL pathnames (i.e. excluding
  any database name prefix). This is to ensure downwards-compatibility.

  To access the name of the requested database from any action (including Foxx), use
  use `req.database`.

  For example, when calling the URL `/myapp/myaction`, the content of `req.database`
  will be `_system` (the default database because no database got specified) and the
  content of `req.url` will be `/myapp/myaction`.
  
  When calling the URL `/_db/test/myapp/myaction`, the content of `req.database` will be 
  `test`, and the content of `req.url` will still be `/myapp/myaction`.
   
* Foxx now excludes files starting with . (dot) when bundling assets

  This mitigates problems with editor swap files etc.

* made the web interface a Foxx application

  This change caused the files for the web interface to be moved from `html/admin` to
  `js/apps/aardvark` in the file system.

  The base URL for the admin interface changed from `_admin/html/index.html` to
  `_admin/aardvark/index.html`.

  The "old" redirection to `_admin/html/index.html` will now produce a 404 error. 
  
  When starting ArangoDB with the `--upgrade` option, this will automatically be remedied 
  by putting in a redirection from `/` to `/_admin/aardvark/index.html`, and from 
  `/_admin/html/index.html` to `/_admin/aardvark/index.html`.

  This also obsoletes the following configuration (command-line) options:
  - `--server.admin-directory`
  - `--server.disable-admin-interface`

  when using these now obsolete options when the server is started, no error is produced
  for downwards-compatibility.

* changed User-Agent value sent by arangoimp, arangosh, and arangod from "VOC-Agent" to 
  "ArangoDB"

* changed journal file creation behavior as follows:

  Previously, a journal file for a collection was always created when a collection was
  created. When a journal filled up and became full, the current journal was made a
  datafile, and a new (empty) journal was created automatically. There weren't many
  intended situations when a collection did not have at least one journal.

  This is changed now as follows:
  - when a collection is created, no journal file will be created automatically
  - when there is a write into a collection without a journal, the journal will be
    created lazily
  - when there is a write into a collection with a full journal, a new journal will
    be created automatically

  From the end user perspective, nothing should have changed, except that there is now
  less disk usage for empty collections. Disk usage of infrequently updated collections 
  might also be reduced significantly by running the `rotate()` method of a collection, 
  and not writing into a collection subsequently.

* added method `collection.rotate()`

  This allows premature rotation of a collection's current journal file into a (read-only)
  datafile. The purpose of using `rotate()` is to prematurely allow compaction (which is 
  performed on datafiles only) on data, even if the journal was not filled up completely.

  Using `rotate()` may make sense in the following scenario:

      c = db._create("test");
      for (i = 0; i < 1000; ++i) {
        c.save(...); // insert lots of data here
      }

      ...
      c.truncate(); // collection is now empty
      // only data in datafiles will be compacted by following compaction runs
      // all data in the current journal would not be compacted

      // calling rotate will make the current journal a datafile, and thus make it
      // eligible for compaction
      c.rotate(); 

  Using `rotate()` may also be useful when data in a collection is known to not change
  in the immediate future. After having completed all write operations on a collection,
  performing a `rotate()` will reduce the size of the current journal to the actually
  required size (remember that journals are pre-allocated with a specific size) before
  making the journal a datafile. Thus `rotate()` may cause disk space savings, even if
  the datafiles does not qualify for compaction after rotation.

  Note: rotating the journal is asynchronous, so that the actual rotation may be executed
  after `rotate()` returns to the caller.

* changed compaction to merge small datafiles together (up to 3 datafiles are merged in 
  a compaction run)

  In the regular case, this should leave less small datafiles stay around on disk and allow
  using less file descriptors in total.

* added AQL MINUS function

* added AQL UNION_DISTINCT function (more efficient than combination of `UNIQUE(UNION())`)

* updated mruby to 2013-08-22

* issue #587: Add db._create() in help for startup arangosh

* issue #586: Share a link on installation instructions in the User Manual 

* issue #585: Bison 2.4 missing on Mac for custom build

* issue #584: Web interface images broken in devel

* issue #583: Small documentation update

* issue #581: Parameter binding for attributes

* issue #580: Small improvements (by @guidoreina) 

* issue #577: Missing documentation for collection figures in implementor manual

* issue #576: Get disk usage for collections and graphs

  This extends the result of the REST API for /_api/collection/figures with
  the attributes `compactors.count`, `compactors.fileSize`, `shapefiles.count`,
  and `shapefiles.fileSize`.

* issue #575: installing devel version on mac (low prio)

* issue #574: Documentation (POST /_admin/routing/reload)

* issue #558: HTTP cursors, allow count to ignore LIMIT


v1.4.0-alpha1 (2013-08-02)
--------------------------

* added replication. check online manual for details.

* added server startup options `--server.disable-replication-logger` and 
  `--server.disable-replication-applier`

* removed action deployment tool, this now handled with Foxx and its manager or
  by kaerus node utility

* fixed a server crash when using byExample / firstExample inside a transaction
  and the collection contained a usable hash/skiplist index for the example

* defineHttp now only expects a single context

* added collection detail dialog (web interface)

  Shows collection properties, figures (datafiles, journals, attributes, etc.)
  and indexes.

* added documents filter (web interface)

  Allows searching for documents based on attribute values. One or many filter
  conditions can be defined, using comparison operators such as '==', '<=', etc.

* improved AQL editor (web interface)

  Editor supports keyboard shortcuts (Submit, Undo, Redo, Select).
  Editor allows saving and reusing of user-defined queries.
  Added example queries to AQL editor.
  Added comment button.

* added document import (web interface)

  Allows upload of JSON-data from files. Files must have an extension of .json.

* added dashboard (web interface)

  Shows the status of replication and multiple system charts, e.g.
  Virtual Memory Size, Request Time, HTTP Connections etc.

* added API method `/_api/graph` to query all graphs with all properties.

* added example queries in web interface AQL editor

* added arango.reconnect(<host>) method for arangosh to dynamically switch server or
  user name

* added AQL range operator `..`

  The `..` operator can be used to easily iterate over a sequence of numeric
  values. It will produce a list of values in the defined range, with both bounding 
  values included.

  Example:

      2010..2013

  will produce the following result:

      [ 2010, 2011, 2012, 2013 ]

* added AQL RANGE function

* added collection.first(count) and collection.last(count) document access functions
  
  These functions allow accessing the first or last n documents in a collection. The order
  is determined by document insertion/update time.

* added AQL INTERSECTION function

* INCOMPATIBLE CHANGE: changed AQL user function namespace resolution operator from `:` to `::`

  AQL user-defined functions were introduced in ArangoDB 1.3, and the namespace resolution
  operator for them was the single colon (`:`). A function call looked like this:

      RETURN mygroup:myfunc()

  The single colon caused an ambiguity in the AQL grammar, making it indistinguishable from
  named attributes or the ternary operator in some cases, e.g.

      { mygroup:myfunc ? mygroup:myfunc }

  The change of the namespace resolution operator from `:` to `::` fixes this ambiguity.

  Existing user functions in the database will be automatically fixed when starting ArangoDB
  1.4 with the `--upgrade` option. However, queries using user-defined functions need to be
  adjusted on the client side to use the new operator.

* allow multiple AQL LET declarations separated by comma, e.g.
  LET a = 1, b = 2, c = 3

* more useful AQL error messages

  The error position (line/column) is more clearly indicated for parse errors.
  Additionally, if a query references a collection that cannot be found, the error
  message will give a hint on the collection name

* changed return value for AQL `DOCUMENT` function in case document is not found
  
  Previously, when the AQL `DOCUMENT` function was called with the id of a document and
  the document could not be found, it returned `undefined`. This value is not part of the
  JSON type system and this has caused some problems.
  Starting with ArangoDB 1.4, the `DOCUMENT` function will return `null` if the document
  looked for cannot be found.

  In case the function is called with a list of documents, it will continue to return all
  found documents, and will not return `null` for non-found documents. This has not changed.

* added single line comments for AQL

  Single line comments can be started with a double forward slash: `//`.
  They end at the end of the line, or the end of the query string, whichever is first.

* fixed documentation issues #567, #568, #571.

* added collection.checksum(<withData>) method to calculate CRC checksums for
  collections

  This can be used to 
  - check if data in a collection has changed
  - compare the contents of two collections on different ArangoDB instances

* issue #565: add description line to aal.listAvailable()

* fixed several out-of-memory situations when double freeing or invalid memory
  accesses could happen

* less msyncing during the creation of collections

  This is achieved by not syncing the initial (standard) markers in shapes collections.
  After all standard markers are written, the shapes collection will get synced.

* renamed command-line option `--log.filter` to `--log.source-filter` to avoid
  misunderstandings

* introduced new command-line option `--log.content-filter` to optionally restrict 
  logging to just specific log messages (containing the filter string, case-sensitive).
  
  For example, to filter on just log entries which contain `ArangoDB`, use:
  
      --log.content-filter "ArangoDB"

* added optional command-line option `--log.requests-file` to log incoming HTTP
  requests to a file.

  When used, all HTTP requests will be logged to the specified file, containing the
  client IP address, HTTP method, requests URL, HTTP response code, and size of the
  response body.

* added a signal handler for SIGUSR1 signal: 

  when ArangoDB receives this signal, it will respond all further incoming requests
  with an HTTP 503 (Service Unavailable) error. This will be the case until another
  SIGUSR1 signal is caught. This will make ArangoDB start serving requests regularly
  again. Note: this is not implemented on Windows.

* limited maximum request URI length to 16384 bytes:

  Incoming requests with longer request URIs will be responded to with an HTTP
  414 (Request-URI Too Long) error.

* require version 1.0 or 1.1 in HTTP version signature of requests sent by clients:
  
  Clients sending requests with a non-HTTP 1.0 or non-HTTP 1.1 version number will
  be served with an HTTP 505 (HTTP Version Not Supported) error.

* updated manual on indexes:  

  using system attributes such as `_id`, `_key`, `_from`, `_to`, `_rev` in indexes is
  disallowed and will be rejected by the server. This was the case since ArangoDB 1.3,
  but was not properly documented.

* issue #563: can aal become a default object?

  aal is now a prefab object in arangosh

* prevent certain system collections from being renamed, dropped, or even unloaded.

  Which restrictions there are for which system collections may vary from release to
  release, but users should in general not try to modify system collections directly
  anyway. 
  
  Note: there are no such restrictions for user-created collections.

* issue #559: added Foxx documentation to user manual

* added server startup option `--server.authenticate-system-only`. This option can be
  used to restrict the need for HTTP authentication to internal functionality and APIs,
  such as `/_api/*` and `/_admin/*`. 
  Setting this option to `true` will thus force authentication for the ArangoDB APIs 
  and the web interface, but allow unauthenticated requests for other URLs (including
  user defined actions and Foxx applications).
  The default value of this option is `false`, meaning that if authentication is turned
  on, authentication is still required for *all* incoming requests. Only by setting the
  option to `true` this restriction is lifted and authentication becomes required for
  URLs starting with `/_` only.

  Please note that authentication still needs to be enabled regularly by setting the
  `--server.disable-authentication` parameter to `false`. Otherwise no authentication 
  will be required for any URLs as before.

* protect collections against unloading when there are still document barriers around.

* extended cap constraints to optionally limit the active data size in a collection to
  a specific number of bytes.

  The arguments for creating a cap constraint are now:
  `collection.ensureCapConstraint(<count>, <byteSize>);`

  It is supported to specify just a count as in ArangoDB 1.3 and before, to specify 
  just a fileSize, or both. The first met constraint will trigger the automated
  document removal.

* added `db._exists(doc)` and `collection.exists(doc)` for easy document existence checks

* added API `/_api/current-database` to retrieve information about the database the
  client is currently connected to (note: the API `/_api/current-database` has been
  removed in the meantime. The functionality is accessible via `/_api/database/current` 
  now).

* ensure a proper order of tick values in datafiles/journals/compactors.
  any new files written will have the _tick values of their markers in order. for
  older files, there are edge cases at the beginning and end of the datafiles when
  _tick values are not properly in order.

* prevent caching of static pages in PathHandler. 
  whenever a static page is requested that is served by the general PathHandler, the
  server will respond to HTTP GET requests with a "Cache-Control: max-age=86400" header.

* added "doCompact" attribute when creating collections and to collection.properties().
  The attribute controls whether collection datafiles are compacted.

* changed the HTTP return code from 400 to 404 for some cases when there is a referral 
  to a non-existing collection or document.

* introduced error code 1909 `too many iterations` that is thrown when graph traversals
  hit the `maxIterations` threshold.

* optionally limit traversals to a certain number of iterations
  the limitation can be achieved via the traversal API by setting the `maxIterations` 
  attribute, and also via the AQL `TRAVERSAL` and `TRAVERSAL_TREE` functions by setting
  the same attribute. If traversals are not limited by the end user, a server-defined
  limit for `maxIterations` may be used to prevent server-side traversals from running
  endlessly.

* added graph traversal API at `/_api/traversal`

* added "API" link in web interface, pointing to REST API generated with Swagger

* moved "About" link in web interface into "links" menu

* allow incremental access to the documents in a collection from out of AQL
  this allows reading documents from a collection chunks when a full collection scan
  is required. memory usage might be must lower in this case and queries might finish
  earlier if there is an additional LIMIT statement

* changed AQL COLLECT to use a stable sort, so any previous SORT order is preserved

* issue #547: Javascript error in the web interface

* issue #550: Make AQL graph functions support key in addition to id

* issue #526: Unable to escape when an errorneous command is entered into the js shell

* issue #523: Graph and vertex methods for the javascript api
 
* issue #517: Foxx: Route parameters with captial letters fail

* issue #512: Binded Parameters for LIMIT


v1.3.3 (2013-08-01)
-------------------

* issue #570: updateFishbowl() fails once

* updated and fixed generated examples

* issue #559: added Foxx documentation to user manual

* added missing error reporting for errors that happened during import of edges


v1.3.2 (2013-06-21)
-------------------

* fixed memleak in internal.download()

* made the shape-collection journal size adaptive:
  if too big shapes come in, a shape journal will be created with a big-enough size
  automatically. the maximum size of a shape journal is still restricted, but to a 
  very big value that should never be reached in practice.

* fixed a segfault that occurred when inserting documents with a shape size bigger
  than the default shape journal size (2MB)

* fixed a locking issue in collection.truncate()

* fixed value overflow in accumulated filesizes reported by collection.figures()

* issue #545: AQL FILTER unnecessary (?) loop

* issue #549: wrong return code with --daemon


v1.3.1 (2013-05-24)
-------------------

* removed currently unused _ids collection

* fixed usage of --temp-path in aranogd and arangosh

* issue #540: suppress return of temporary internal variables in AQL

* issue #530: ReferenceError: ArangoError is not a constructor

* issue #535: Problem with AQL user functions javascript API

* set --javascript.app-path for test execution to prevent startup error

* issue #532: Graph _edgesCache returns invalid data?

* issue #531: Arangod errors

* issue #529: Really weird transaction issue

* fixed usage of --temp-path in aranogd and arangosh


v1.3.0 (2013-05-10)
-------------------

* fixed problem on restart ("datafile-xxx is not sealed") when server was killed
  during a compaction run

* fixed leak when using cursors with very small batchSize

* issue #508: `unregistergroup` function not mentioned in http interface docs

* issue #507: GET /_api/aqlfunction returns code inside parentheses

* fixed issue #489: Bug in aal.install

* fixed issue 505: statistics not populated on MacOS


v1.3.0-rc1 (2013-04-24)
-----------------------

* updated documentation for 1.3.0

* added node modules and npm packages

* changed compaction to only compact datafiles with more at least 10% of dead
  documents (byte size-wise)

* issue #498: fixed reload of authentication info when using 
  `require("org/arangodb/users").reload()`

* issue #495: Passing an empty array to create a document results in a 
  "phantom" document

* added more precision for requests statistics figures

* added "sum" attribute for individual statistics results in statistics API
  at /_admin/statistics

* made "limit" an optional parameter in AQL function NEAR().
  limit can now be either omitted completely, or set to 0. If so, an internal
  default value (currently 100) will be applied for the limit.

* issue #481

* added "attributes.count" to output of `collection.figures()`
  this also affects the REST API /_api/collection/<name>/figures

* added IndexedPropertyGetter for ShapedJson objects

* added API for user-defined AQL functions

* issue #475: A better error message for deleting a non-existent graph

* issue #474: Web interface problems with the JS Shell
 
* added missing documentation for AQL UNION function

* added transaction support. 
  This provides ACID transactions for ArangoDB. Transactions can be invoked
  using the `db._executeTransaction()` function, or the `/_api/transaction`
  REST API.

* switched to semantic versioning (at least for alpha & alpha naming)

* added saveOrReplace() for server-side JS

v1.3.alpha1 (2013-04-05)
------------------------

* cleanup of Module, Package, ArangoApp and modules "internal", "fs", "console"

* use Error instead of string in throw to allow stack-trace

* issue #454: error while creation of Collection

* make `collection.count()` not recalculate the number of documents on the fly, but
  use some internal document counters.

* issue #457: invalid string value in web interface

* make datafile id (datafile->_fid) identical to the numeric part of the filename.
  E.g. the datafile `journal-123456.db` will now have a datafile marker with the same
  fid (i.e. `123456`) instead of a different value. This change will only affect
  datafiles that are created with 1.3 and not any older files.
  The intention behind this change is to make datafile debugging easier.

* consistently discard document attributes with reserved names (system attributes)
  but without any known meaning, for example `_test`, `_foo`, ...

  Previously, these attributes were saved with the document regularly in some cases,
  but were discarded in other cases. 
  Now these attributes are discarded consistently. "Real" system attributes such as
  `_key`, `_from`, `_to` are not affected and will work as before.
  
  Additionally, attributes with an empty name (``) are discarded when documents are
  saved.

  Though using reserved or empty attribute names in documents was not really and 
  consistently supported in previous versions of ArangoDB, this change might cause 
  an incompatibility for clients that rely on this feature.

* added server startup flag `--database.force-sync-properties` to force syncing of
  collection properties on collection creation, deletion and on property update.
  The default value is true to mimic the behavior of previous versions of ArangoDB.
  If set to false, collection properties are written to disk but no call to sync()
  is made.

* added detailed output of server version and components for REST APIs
  `/_admin/version` and `/_api/version`. To retrieve this extended information,
  call the REST APIs with URL parameter `details=true`.

* issue #443: For git-based builds include commit hash in version

* adjust startup log output to be more compact, less verbose

* set the required minimum number of file descriptors to 256.
  On server start, this number is enforced on systems that have rlimit. If the limit
  cannot be enforced, starting the server will fail.
  Note: 256 is considered to be the absolute minimum value. Depending on the use case
  for ArangoDB, a much higher number of file descriptors should be used.

  To avoid checking & potentially changing the number of maximum open files, use the
  startup option `--server.descriptors-minimum 0`

* fixed shapedjson to json conversion for special numeric values (NaN, +inf, -inf).
  Before, "NaN", "inf", or "-inf" were written into the JSONified output, but these 
  values are not allowed in JSON. Now, "null" is written to the JSONified output as
  required.

* added AQL functions VARIANCE_POPULATION(), VARIANCE_SAMPLE(), STDDEV_POPULATION(),
  STDDEV_SAMPLE(), AVERAGE(), MEDIAN() to calculate stastical values for lists

* added AQL SQRT() function

* added AQL TRIM(), LEFT() and RIGHT() string functions

* fixed issue #436: GET /_api/document on edge
 
* make AQL REVERSE() and LENGTH() functions work on strings, too

* disabled DOT generation in `make doxygen`. this speeds up docs generation

* renamed startup option `--dispatcher.report-intervall` to `--dispatcher.report-interval`

* renamed startup option `--scheduler.report-intervall` to `--scheduler.report-interval`

* slightly changed output of REST API method /_admin/log.
  Previously, the log messages returned also contained the date and log level, now
  they will only contain the log message, and no date and log level information.
  This information can be re-created by API users from the `timestamp` and `level`
  attributes of the result.

* removed configure option `--enable-zone-debug`
  memory zone debugging is now automatically turned on when compiling with ArangoDB
  `--enable-maintainer-mode`

* removed configure option `--enable-arangob`
  arangob is now always included in the build


v1.2.3 (XXXX-XX-XX)
-------------------

* added optional parameter `edgexamples` for AQL function EDGES() and NEIGHBORS()

* added AQL function NEIGHBORS()
 
* added freebsd support

* fixed firstExample() query with `_id` and `_key` attributes

* issue triAGENS/ArangoDB-PHP#55: AQL optimiser may have mis-optimised duplicate 
  filter statements with limit


v1.2.2 (2013-03-26)
-------------------

* fixed save of objects with common sub-objects

* issue #459: fulltext internal memory allocation didn't scale well
  This fix improves loading times for collections with fulltext indexes that have
  lots of equal words indexed.

* issue #212: auto-increment support

  The feature can be used by creating a collection with the extra `keyOptions`
  attribute as follows:

      db._create("mycollection", { keyOptions: { type: "autoincrement", offset: 1, increment: 10, allowUserKeys: true } });

  The `type` attribute will make sure the keys will be auto-generated if no 
  `_key` attribute is specified for a document.

  The `allowUserKeys` attribute determines whether users might still supply own 
  `_key` values with documents or if this is considered an error.

  The `increment` value determines the actual increment value, whereas the `offset` 
  value can be used to seed to value sequence with a specific starting value. 
  This will be useful later in a multi-master setup, when multiple servers can use
  different auto-increment seed values and thus generate non-conflicting auto-increment values.

  The default values currently are:

  - `allowUserKeys`: `true`
  - `offset`: `0`
  - `increment`: `1`

  The only other available key generator type currently is `traditional`. 
  The `traditional` key generator will auto-generate keys in a fashion as ArangoDB 
  always did (some increasing integer value, with a more or less unpredictable
  increment value).

  Note that for the `traditional` key generator there is only the option to disallow 
  user-supplied keys and give the server the sole responsibility for key generation.
  This can be achieved by setting the `allowUserKeys` property to `false`.

  This change also introduces the following errors that API implementors may want to check
  the return values for:

  - 1222: `document key unexpected`: will be raised when a document is created with
    a `_key` attribute, but the underlying collection was set up with the `keyOptions`
    attribute `allowUserKeys: false`.

  - 1225: `out of keys`: will be raised when the auto-increment key generator runs
    out of keys. This may happen when the next key to be generated is 2^64 or higher.
    In practice, this will only happen if the values for `increment` or `offset` are
    not set appropriately, or if users are allowed to supply own keys, those keys
    are near the 2^64 threshold, and later the auto-increment feature kicks in and
    generates keys that cross that threshold.

    In practice it should not occur with proper configuration and proper usage of the
    collections.

  This change may also affect the following REST APIs:
  - POST `/_api/collection`: the server does now accept the optional `keyOptions` 
    attribute in the second parameter
  - GET `/_api/collection/properties`: will return the `keyOptions` attribute as part
    of the collection's properties. The previous optional attribute `createOptions` 
    is now gone.

* fixed `ArangoStatement.explain()` method with bind variables

* fixed misleading "cursor not found" error message in arangosh that occurred when
  `count()` was called for client-side cursors

* fixed handling of empty attribute names, which may have crashed the server under
  certain circumstances before

* fixed usage of invalid pointer in error message output when index description could
  not be opened


v1.2.1 (2013-03-14)
-------------------

* issue #444: please darken light color in arangosh

* issue #442: pls update post install info on osx

* fixed conversion of special double values (NaN, -inf, +inf) when converting from 
  shapedjson to JSON

* fixed compaction of markers (location of _key was not updated correctly in memory,
  leading to _keys pointing to undefined memory after datafile rotation)

* fixed edge index key pointers to use document master pointer plus offset instead
  of direct _key address

* fixed case when server could not create any more journal or compactor files. 
  Previously a wrong status code may have been returned, and not being able to create
  a new compactor file may have led to an infinite loop with error message
  "could not create compactor".
 
* fixed value truncation for numeric filename parts when renaming datafiles/journals


v1.2.0 (2013-03-01)
-------------------

* by default statistics are now switch off; in order to enable comment out
  the "disable-statistics = yes" line in "arangod.conf"

* fixed issue #435: csv parser skips data at buffer border

* added server startup option `--server.disable-statistics` to turn off statistics
  gathering without recompilation of ArangoDB.
  This partly addresses issue #432.

* fixed dropping of indexes without collection name, e.g.
  `db.xxx.dropIndex("123456");`
  Dropping an index like this failed with an assertion error.
 
* fixed issue #426: arangoimp should be able to import edges into edge collections

* fixed issue #425: In case of conflict ArangoDB returns HTTP 400 Bad request 
  (with 1207 Error) instead of HTTP 409 Conflict

* fixed too greedy token consumption in AQL for negative values:
  e.g. in the statement `RETURN { a: 1 -2 }` the minus token was consumed as part 
  of the value `-2`, and not interpreted as the binary arithmetic operator


v1.2.beta3 (2013-02-22)
-----------------------

* issue #427: ArangoDB Importer Manual has no navigation links (previous|home|next)

* issue #319: Documentation missing for Emergency console and incomplete for datafile debugger.

* issue #370: add documentation for reloadRouting and flushServerModules

* issue #393: added REST API for user management at /_api/user

* issue #393, #128: added simple cryptographic functions for user actions in module "crypto":
  * require("org/arangodb/crypto").md5()
  * require("org/arangodb/crypto").sha256()
  * require("org/arangodb/crypto").rand()

* added replaceByExample() Javascript and REST API method

* added updateByExample() Javascript and REST API method

* added optional "limit" parameter for removeByExample() Javascript and REST API method

* fixed issue #413

* updated bundled V8 version from 3.9.4 to 3.16.14.1
  Note: the Windows version used a more recent version (3.14.0.1) and was not updated.

* fixed issue #404: keep original request url in request object


v1.2.beta2 (2013-02-15)
-----------------------

* fixed issue #405: 1.2 compile warnings

* fixed issue #333: [debian] Group "arangodb" is not used when starting vie init.d script

* added optional parameter 'excludeSystem' to GET /_api/collection
  This parameter can be used to disable returning system collections in the list
  of all collections.

* added AQL functions KEEP() and UNSET()

* fixed issue #348: "HTTP Interface for Administration and Monitoring" 
  documentation errors.

* fix stringification of specific positive int64 values. Stringification of int64
  values with the upper 32 bits cleared and the 33rd bit set were broken.

* issue #395:  Collection properties() function should return 'isSystem' for 
  Javascript and REST API

* make server stop after upgrade procedure when invoked with `--upgrade option`.
  When started with the `--upgrade` option, the server will perfom
  the upgrade, and then exit with a status code indicating the result of the
  upgrade (0 = success, 1 = failure). To start the server regularly in either 
  daemon or console mode, the `--upgrade` option must not be specified.
  This change was introduced to allow init.d scripts check the result of
  the upgrade procedure, even in case an upgrade was successful.
  this was introduced as part of issue #391.

* added AQL function EDGES()

* added more crash-protection when reading corrupted collections at startup

* added documentation for AQL function CONTAINS()

* added AQL function LIKE()

* replaced redundant error return code 1520 (Unable to open collection) with error code
  1203 (Collection not found). These error codes have the same meanings, but one of
  them was returned from AQL queries only, the other got thrown by other parts of
  ArangoDB. Now, error 1203 (Collection not found) is used in AQL too in case a 
  non-existing collection is used.

v1.2.beta1 (2013-02-01)
-----------------------

* fixed issue #382: [Documentation error] Maschine... should be Machine...
 
* unified history file locations for arangod, arangosh, and arangoirb.
  - The readline history for arangod (emergency console) is now stored in file
    $HOME/.arangod. It was stored in $HOME/.arango before.
  - The readline history for arangosh is still stored in $HOME/.arangosh.
  - The readline history for arangoirb is now stored in $HOME/.arangoirb. It was
    stored in $HOME/.arango-mrb before.

* fixed issue #381: _users user should have a unique constraint

* allow negative list indexes in AQL to access elements from the end of a list,
  e.g. ```RETURN values[-1]``` will return the last element of the `values` list.

* collection ids, index ids, cursor ids, and document revision ids created and 
  returned by ArangoDB are now returned as strings with numeric content inside. 
  This is done to prevent some value overrun/truncation in any part of the
  complete client/server workflow. 
  In ArangoDB 1.1 and before, these values were previously returned as 
  (potentially very big) integer values. This may cause problems (clipping, overrun,
  precision loss) for clients that do not support big integers natively and store 
  such values in IEEE754 doubles internally. This type loses precision after about
  52 bits and is thus not safe to hold an id.
  Javascript and 32 bit-PHP are examples for clients that may cause such problems. 
  Therefore, ids are now returned by ArangoDB as strings, with the string
  content being the integer value as before. 

  Example for documents ("_rev" attribute):
  - Document returned by ArangoDB 1.1: { "_rev": 1234, ... } 
  - Document returned by ArangoDB 1.2: { "_rev": "1234", ... } 
  
  Example for collections ("id" attribute / "_id" property):
  - Collection returned by ArangoDB 1.1: { "id": 9327643, "name": "test", ... } 
  - Collection returned by ArangoDB 1.2: { "id": "9327643", "name": "test", ... }

  Example for cursors ("id" attribute):
  - Collection returned by ArangoDB 1.1: { "id": 11734292, "hasMore": true, ... } 
  - Collection returned by ArangoDB 1.2: { "id": "11734292", "hasMore": true, ... }

* global variables are not automatically available anymore when starting the 
  arangod Javascript emergency console (i.e. ```arangod --console```). 
  
  Especially, the variables `db`, `edges`, and `internal` are not available 
  anymore. `db` and `internal` can be made available in 1.2 by
  ```var db = require("org/arangodb").db;``` and
  ```var internal = require("internal");```, respectively.
  The reason for this change is to get rid of global variables in the server
  because this will allow more specific inclusion of functionality.

  For convenience, the global variable `db` is still available by default in 
  arangosh. The global variable `edges`, which since ArangoDB 1.1 was kind of
  a redundant wrapper of `db`, has been removed in 1.2 completely.
  Please use `db` instead, and if creating an edge collection, use the explicit
  ```db._createEdgeCollection()``` command.

* issue #374: prevent endless redirects when calling admin interface with 
  unexpected URLs

* issue #373: TRAVERSAL() `trackPaths` option does not work. Instead `paths` does work

* issue #358: added support for CORS

* honor optional waitForSync property for document removal, replace, update, and
  save operations in arangosh. The waitForSync parameter for these operations
  was previously honored by the REST API and on the server-side, but not when
  the waitForSync parameter was specified for a document operation in arangosh.

* calls to db.collection.figures() and /_api/collection/<collection>/figures now 
  additionally return the number of shapes used in the collection in the
  extra attribute "shapes.count"

* added AQL TRAVERSAL_TREE() function to return a hierchical result from a traversal

* added AQL TRAVERSAL() function to return the results from a traversal

* added AQL function ATTRIBUTES() to return the attribute names of a document

* removed internal server-side AQL functions from global scope. 

  Now the AQL internal functions can only be accessed via the exports of the 
  ahuacatl module, which can be included via ```require("org/arangodb/ahuacatl")```.
  It shouldn't be necessary for clients to access this module at all, but 
  internal code may use this module.

  The previously global AQL-related server-side functions were moved to the 
  internal namespace. This produced the following function name changes on 
  the server:

     old name              new name
     ------------------------------------------------------
     AHUACATL_RUN       => require("internal").AQL_QUERY
     AHUACATL_EXPLAIN   => require("internal").AQL_EXPLAIN
     AHUACATL_PARSE     => require("internal").AQL_PARSE

  Again, clients shouldn't have used these functions at all as there is the
  ArangoStatement object to execute AQL queries.

* fixed issue #366: Edges index returns strange description

* added AQL function MATCHES() to check a document against a list of examples

* added documentation and tests for db.collection.removeByExample

* added --progress option for arangoimp. This will show the percentage of the input
  file that has been processed by arangoimp while the import is still running. It can
  be used as a rough indicator of progress for the entire import.

* make the server log documents that cannot be imported via /_api/import into the
  logfile using the warning log level. This may help finding illegal documents in big
  import runs.

* check on server startup whether the database directory and all collection directories
  are writable. if not, the server startup will be aborted. this prevents serious
  problems with collections being non-writable and this being detected at some pointer
  after the server has been started

* allow the following AQL constructs: FUNC(...)[...], FUNC(...).attribute

* fixed issue #361: Bug in Admin Interface. Header disappears when clicking new collection

* Added in-memory only collections

  Added collection creation parameter "isVolatile": 
  if set to true, the collection is created as an in-memory only collection, 
  meaning that all document data of that collection will reside in memory only, 
  and will not be stored permanently to disk. 
  This means that all collection data will be lost when the collection is unloaded 
  or the server is shut down.
  As this collection type does not have datafile disk overhead for the regular 
  document operations, it may be faster than normal disk-backed collections. The
  actual performance gains strongly depend on the underlying OS, filesystem, and 
  settings though.
  This collection type should be used for caches only and not for any sensible data
  that cannot be re-created otherwise.
  Some platforms, namely Windows, currently do not support this collection type.
  When creating an in-memory collection on such platform, an error message will be
  returned by ArangoDB telling the user the platform does not support it.

  Note: in-memory collections are an experimental feature. The feature might
  change drastically or even be removed altogether in a future version of ArangoDB.

* fixed issue #353: Please include "pretty print" in Emergency Console

* fixed issue #352: "pretty print" console.log
  This was achieved by adding the dump() function for the "internal" object

* reduced insertion time for edges index
  Inserting into the edges index now avoids costly comparisons in case of a hash 
  collision, reducing the prefilling/loading timer for bigger edge collections

* added fulltext queries to AQL via FULLTEXT() function. This allows search 
  fulltext indexes from an AQL query to find matching documents

* added fulltext index type. This index type allows indexing words and prefixes of
  words from a specific document attribute. The index can be queries using a
  SimpleQueryFull object, the HTTP REST API at /_api/simple/fulltext, or via AQL

* added collection.revision() method to determine whether a collection has changed. 
  The revision method returns a revision string that can be used by client programs
  for equality/inequality comparisons. The value returned by the revision method
  should be treated by clients as an opaque string and clients should not try to
  figure out the sense of the revision id. This is still useful enough to check
  whether data in a collection has changed.

* issue #346: adaptively determine NUMBER_HEADERS_PER_BLOCK

* issue #338: arangosh cursor positioning problems

* issue #326: use limit optimisation with filters

* issue #325: use index to avoid sorting

* issue #324: add limit optimisation to AQL

* removed arango-password script and added Javascript functionality to add/delete
  users instead. The functionality is contained in module `users` and can be invoked
  as follows from arangosh and arangod:
  * require("users").save("name", "passwd");
  * require("users").replace("name", "newPasswd");
  * require("users").remove("name");
  * require("users").reload();
  These functions are intentionally not offered via the web interface.
  This also addresses issue #313

* changed print output in arangosh and the web interface for JSON objects.
  Previously, printing a JSON object in arangosh resulted in the attribute values
  being printed as proper JSON, but attribute names were printed unquoted and
  unescaped. This was fine for the purpose of arangosh, but lead to invalid
  JSON being produced. Now, arangosh will produce valid JSON that can be used
  to send it back to ArangoDB or use it with arangoimp etc.

* fixed issue #300: allow importing documents via the REST /_api/import API 
  from a JSON list, too.
  So far, the API only supported importing from a format that had one JSON object
  on each line. This is sometimes inconvenient, e.g. when the result of an AQL
  query or any other list is to be imported. This list is a JSON list and does not
  necessary have a document per line if pretty-printed.
  arangoimp now supports the JSON list format, too. However, the format requires
  arangoimp and the server to read the entire dataset at once. If the dataset is
  too big (bigger than --max-upload-size) then the import will be rejected. Even if
  increased, the entire list must fit in memory on both the client and the server,
  and this may be more resource-intensive than importing individual lines in chunks.

* removed unused parameter --reuse-ids for arangoimp. This parameter did not have
  any effect in 1.2, was never publicly announced and did evil (TM) things.

* fixed issue #297 (partly): added whitespace between command line and
  command result in arangosh, added shell colors for better usability

* fixed issue #296: system collections not usable from AQL

* fixed issue #295: deadlock on shutdown

* fixed issue #293: AQL queries should exploit edges index

* fixed issue #292: use index when filtering on _key in AQL

* allow user-definable document keys
  users can now define their own document keys by using the _key attribute
  when creating new documents or edges. Once specified, the value of _key is
  immutable.
  The restrictions for user-defined key values are:
  * the key must be at most 254 bytes long
  * it must consist of the letters a-z (lower or upper case), the digits 0-9,
    the underscore (_) or dash (-) characters only
  * any other characters, especially multi-byte sequences, whitespace or
    punctuation characters cannot be used inside key values

  Specifiying a document key is optional when creating new documents. If no
  document key is specified, ArangoDB will create a document key itself.
  There are no guarantees about the format and pattern of auto-generated document
  keys other than the above restrictions.
  Clients should therefore treat auto-generated document keys as opaque values.
  Keys can be used to look up and reference documents, e.g.:
  * saving a document: `db.users.save({ "_key": "fred", ... })`
  * looking up a document: `db.users.document("fred")`
  * referencing other documents: `edges.relations.save("users/fred", "users/john", ...)`

  This change is downwards-compatible to ArangoDB 1.1 because in ArangoDB 1.1 
  users were not able to define their own keys. If the user does not supply a _key
  attribute when creating a document, ArangoDB 1.2 will still generate a key of
  its own as ArangoDB 1.1 did. However, all documents returned by ArangoDB 1.2 will 
  include a _key attribute and clients should be able to handle that (e.g. by
  ignoring it if not needed). Documents returned will still include the _id attribute
  as in ArangoDB 1.1.

* require collection names everywhere where a collection id was allowed in 
  ArangoDB 1.1 & 1.0
  This change requires clients to use a collection name in place of a collection id 
  at all places the client deals with collections.
  Examples:
  * creating edges: the _from and _to attributes must now contain collection names instead
    of collection ids: `edges.relations.save("test/my-key1", "test/my-key2", ...)`
  * retrieving edges: the returned _from and _to attributes now will contain collection
    names instead of ids, too: _from: `test/fred` instead of `1234/3455`
  * looking up documents: db.users.document("fred") or db._document("users/fred")
  
  Collection names must be used in REST API calls instead of collection ids, too.
  This change is thus not completely downwards-compatible to ArangoDB 1.1. ArangoDB 1.1
  required users to use collection ids in many places instead of collection names.
  This was unintuitive and caused overhead in cases when just the collection name was
  known on client-side but not its id. This overhead can now be avoided so clients can
  work with the collection names directly. There is no need to work with collection ids
  on the client side anymore. 
  This change will likely require adjustments to API calls issued by clients, and also
  requires a change in how clients handle the _id value of returned documents. Previously,
  the _id value of returned documents contained the collection id, a slash separator and
  the document number. Since 1.2, _id will contain the collection name, a slash separator
  and the document key. The same applies to the _from and _to attribute values of edges
  that are returned by ArangoDB.

  Also removed (now unnecessary) location header in responses of the collections REST API.
  The location header was previously returned because it was necessary for clients.
  When clients created a collection, they specified the collection name. The collection
  id was generated on the server, but the client needed to use the server-generated
  collection id for further API calls, e.g. when creating edges etc. Therefore, the
  full collection URL, also containing the collection id, was returned by the server in
  responses to the collection API, in the HTTP location header.
  Returning the location header has become unnecessary in ArangoDB 1.2 because users
  can access collections by name and do not need to care about collection ids.


v1.1.3 (2013-XX-XX)
-------------------

* fix case when an error message was looked up for an error code but no error
  message was found. In this case a NULL ptr was returned and not checked everywhere.
  The place this error popped up was when inserting into a non-unique hash index
  failed with a specific, invalid error code.

* fixed issue #381:  db._collection("_users").getIndexes();

* fixed issue #379: arango-password fatal issue javscript.startup-directory 

* fixed issue #372: Command-Line Options for the Authentication and Authorisation


v1.1.2 (2013-01-20)
-------------------

* upgraded to mruby 2013-01-20 583983385b81c21f82704b116eab52d606a609f4

* fixed issue #357: Some spelling and grammar errors

* fixed issue #355: fix quotes in pdf manual
 
* fixed issue #351: Strange arangosh error message for long running query 

* fixed randomly hanging connections in arangosh on MacOS

* added "any" query method: this returns a random document from a collection. It
  is also available via REST HTTP at /_api/simple/any.

* added deployment tool

* added getPeerVertex

* small fix for logging of long messages: the last character of log messages longer
  than 256 bytes was not logged.

* fixed truncation of human-readable log messages for web interface: the trailing \0
  byte was not appended for messages longer than 256 bytes

* fixed issue #341: ArangoDB crashes when stressed with Batch jobs
  Contrary to the issue title, this did not have anything to do with batch jobs but
  with too high memory usage. The memory usage of ArangoDB is now reduced for cases
   when there are lots of small collections with few documents each

* started with issue #317: Feature Request (from Google Groups): DATE handling

* backported issue #300: Extend arangoImp to Allow importing resultset-like 
  (list of documents) formatted files

* fixed issue #337: "WaitForSync" on new collection does not work on Win/X64

* fixed issue #336: Collections REST API docs

* fixed issue #335: mmap errors due to wrong memory address calculation 

* fixed issue #332: arangoimp --use-ids parameter seems to have no impact

* added option '--server.disable-authentication' for arangosh as well. No more passwd
  prompts if not needed

* fixed issue #330: session logging for arangosh

* fixed issue #329: Allow passing script file(s) as parameters for arangosh to run

* fixed issue #328: 1.1 compile warnings

* fixed issue #327: Javascript parse errors in front end


v1.1.1 (2012-12-18)
-------------------

* fixed issue #339: DELETE /_api/cursor/cursor-identifier return incollect errorNum

  The fix for this has led to a signature change of the function actions.resultNotFound().
  The meaning of parameter #3 for This function has changed from the error message string
  to the error code. The error message string is now parameter #4.
  Any client code that uses this function in custom actions must be adjusted.

* fixed issue #321: Problem upgrading arangodb 1.0.4 to 1.1.0 with Homebrew (OSX 10.8.2)

* fixed issue #230: add navigation and search for online documentation

* fixed issue #315: Strange result in PATH

* fixed issue #323: Wrong function returned in error message of AQL CHAR_LENGTH()

* fixed some log errors on startup / shutdown due to pid file handling and changing
  of directories


v1.1.0 (2012-12-05)
-------------------

* WARNING:
  arangod now performs a database version check at startup. It will look for a file
  named "VERSION" in its database directory. If the file is not present, arangod will
  perform an automatic upgrade of the database directory. This should be the normal
  case when upgrading from ArangoDB 1.0 to ArangoDB 1.1.

  If the VERSION file is present but is from an older version of ArangoDB, arangod 
  will refuse to start and ask the user to run a manual upgrade first. A manual upgrade
  can be performed by starting arangod with the option `--upgrade`. 

  This upgrade procedure shall ensure that users have full control over when they 
  perform any updates/upgrades of their data, and can plan backups accordingly. The
  procedure also guarantees that the server is not run without any required system
  collections or with in incompatible data state.

* added AQL function DOCUMENT() to retrieve a document by its _id value

* fixed issue #311: fixed segfault on unload 

* fixed issue #309: renamed stub "import" button from web interface

* fixed issue #307: added WaitForSync column in collections list in in web interface 

* fixed issue #306: naming in web interface 

* fixed issue #304: do not clear AQL query text input when switching tabs in
  web interface

* fixed issue #303: added documentation about usage of var keyword in web interface

* fixed issue #301: PATCH does not work in web interface

# fixed issue #269: fix make distclean & clean

* fixed issue #296: system collections not usable from AQL

* fixed issue #295: deadlock on shutdown

* added collection type label to web interface

* fixed issue #290: the web interface now disallows creating non-edges in edge collections
  when creating collections via the web interface, the collection type must also be
  specified (default is document collection)

* fixed issue #289: tab-completion does not insert any spaces

* fixed issue #282: fix escaping in web interface

* made AQL function NOT_NULL take any number of arguments. Will now return its
  first argument that is not null, or null if all arguments are null. This is downwards
  compatible.

* changed misleading AQL function name NOT_LIST() to FIRST_LIST() and slightly changed
  the behavior. The function will now return its first argument that is a list, or null 
  if none of the arguments are lists.
  This is mostly downwards-compatible. The only change to the previous implementation in
  1.1-beta will happen if two arguments were passed and the 1st and 2nd arguments were 
  both no lists. In previous 1.1, the 2nd argument was returned as is, but now null 
  will be returned.

* add AQL function FIRST_DOCUMENT(), with same behavior as FIRST_LIST(), but working
  with documents instead of lists.

* added UPGRADING help text

* fixed issue #284: fixed Javascript errors when adding edges/vertices without own
  attributes

* fixed issue #283: AQL LENGTH() now works on documents, too

* fixed issue #281: documentation for skip lists shows wrong example

* fixed AQL optimiser bug, related to OR-combined conditions that filtered on the
  same attribute but with different conditions

* fixed issue #277: allow usage of collection names when creating edges
  the fix of this issue also implies validation of collection names / ids passed to
  the REST edge create method. edges with invalid collection ids or names in the
  "from" or "to" values will be rejected and not saved


v1.1.beta2 (2012-11-13)
-----------------------

* fixed arangoirb compilation

* fixed doxygen


v1.1.beta1 (2012-10-24)
-----------------------

* fixed AQL optimiser bug

* WARNING:
  - the user has changed from "arango" to "arangodb", the start script has changed from
    "arangod" to "arangodb", the database directory has changed from "/var/arangodb" to
    "/var/lib/arangodb" to be compliant with various Linux policies

  - In 1.1, we have introduced types for collections: regular documents go into document
    collections, and edges go into edge collections. The prefixing (db.xxx vs. edges.xxx) 
    works slightly different in 1.1: edges.xxx can still be used to access collections, 
    however, it will not determine the type of existing collections anymore. To create an 
    edge collection 1.1, you can use db._createEdgeCollection() or edges._create(). 
    And there's of course also db._createDocumentCollection(). 
    db._create() is also still there and will create a document collection by default, 
    whereas edges._create() will create an edge collection.

  - the admin web interface that was previously available via the simple URL suffix / 
    is now available via a dedicated URL suffix only: /_admin/html
    The reason for this is that routing and URLs are now subject to changes by the end user,
    and only URLs parts prefixed with underscores (e.g. /_admin or /_api) are reserved
    for ArangoDB's internal usage.

* the server now handles requests with invalid Content-Length header values as follows:
  - if Content-Length is negative, the server will respond instantly with HTTP 411
    (length required)

  - if Content-Length is positive but shorter than the supplied body, the server will
    respond with HTTP 400 (bad request)

  - if Content-Length is positive but longer than the supplied body, the server will
    wait for the client to send the missing bytes. The server allows 90 seconds for this
    and will close the connection if the client does not send the remaining data

  - if Content-Length is bigger than the maximum allowed size (512 MB), the server will 
    fail with HTTP 413 (request entitiy too large).

  - if the length of the HTTP headers is greated than the maximum allowed size (1 MB),
    the server will fail with HTTP 431 (request header fields too large)

* issue #265: allow optional base64 encoding/decoding of action response data

* issue #252: create _modules collection using arango-upgrade (note: arango-upgrade was
  finally replaced by the `--upgrade` option for arangod)

* issue #251: allow passing arbitrary options to V8 engine using new command line option:
  --javascript.v8-options. Using this option, the Harmony features or other settings in
  v8 can be enabled if the end user requires them

* issue #248: allow AQL optimiser to pull out completely uncorrelated subqueries to the
  top level, resulting in less repeated evaluation of the subquery

* upgraded to Doxygen 1.8.0

* issue #247: added AQL function MERGE_RECURSIVE

* issue #246: added clear() function in arangosh

* issue #245: Documentation: Central place for naming rules/limits inside ArangoDB

* reduced size of hash index elements by 50 %, allowing more index elements to fit in 
  memory

* issue #235: GUI Shell throws Error:ReferenceError: db is not defined

* issue #229: methods marked as "under construction" 

* issue #228: remove unfinished APIs (/_admin/config/*) 

* having the OpenSSL library installed is now a prerequisite to compiling ArangoDB
  Also removed the --enable-ssl configure option because ssl is always required.

* added AQL functions TO_LIST, NOT_LIST

* issue #224: add optional Content-Id for batch requests

* issue #221: more documentation on AQL explain functionality. Also added
  ArangoStatement.explain() client method

* added db._createStatement() method on server as well (was previously available
  on the client only)

* issue #219: continue in case of "document not found" error in PATHS() function

* issue #213: make waitForSync overridable on specifc actions

* changed AQL optimiser to use indexes in more cases. Previously, indexes might
  not have been used when in a reference expression the inner collection was 
  specified last. Example: FOR u1 IN users FOR u2 IN users FILTER u1._id == u2._id
  Previously, this only checked whether an index could be used for u2._id (not
  possible). It was not checked whether an index on u1._id could be used (possible).
  Now, for expressions that have references/attribute names on both sides of the
  above as above, indexes are checked for both sides.
  
* issue #204: extend the CSV import by TSV and by user configurable 
  seperator character(s)

* issue #180: added support for batch operations

* added startup option --server.backlog-size
  this allows setting the value of the backlog for the listen() system call.
  the default value is 10, the maximum value is platform-dependent

* introduced new configure option "--enable-maintainer-mode" for
  ArangoDB maintainers. this option replaces the previous compile switches
  --with-boost-test, --enable-bison, --enable-flex and --enable-errors-dependency
  the individual configure options have been removed. --enable-maintainer-mode
  turns them all on.

* removed potentially unused configure option --enable-memfail

* fixed issue #197: HTML web interface calls /_admin/user-manager/session

* fixed issue #195: VERSION file in database directory

* fixed issue #193: REST API HEAD request returns a message body on 404

* fixed issue #188: intermittent issues with 1.0.0
  (server-side cursors not cleaned up in all cases, pthreads deadlock issue)

* issue #189: key store should use ISO datetime format bug 

* issue #187: run arango-upgrade on server start (note: arango-upgrade was finally
  replaced by the `--upgrade` option for arangod)n

* fixed issue #183: strange unittest error

* fixed issue #182: manual pages

* fixed issue #181: use getaddrinfo

* moved default database directory to "/var/lib/arangodb" in accordance with 
  http://www.pathname.com/fhs/pub/fhs-2.3.html

* fixed issue #179: strange text in import manual

* fixed issue #178: test for aragoimp is missing

* fixed issue #177: a misleading error message was returned if unknown variables
  were used in certain positions in an AQL query.

* fixed issue #176: explain how to use AQL from the arangosh

* issue #175: re-added hidden (and deprecated) option --server.http-port. This 
  option is only there to be downwards-compatible to Arango 1.0.

* fixed issue #174: missing Documentation for `within`

* fixed issue #170: add db.<coll_name>.all().toArray() to arangosh help screen

* fixed issue #169: missing argument in Simple Queries

* added program arango-upgrade. This program must be run after installing ArangoDB
  and after upgrading from a previous version of ArangoDB. The arango-upgrade script
  will ensure all system collections are created and present in the correct state.
  It will also perform any necessary data updates.
  Note: arango-upgrade was finally replaced by the `--upgrade` option for arangod.

* issue #153: edge collection should be a flag for a collection
  collections now have a type so that the distinction between document and edge 
  collections can now be done at runtime using a collection's type value.
  A collection's type can be queried in Javascript using the <collection>.type() method. 
  
  When new collections are created using db._create(), they will be document 
  collections by default. When edge._create() is called, an edge collection will be created.
  To explicitly create a collection of a specific/different type, use the methods 
  _createDocumentCollection() or _createEdgeCollection(), which are available for
  both the db and the edges object.
  The Javascript objects ArangoEdges and ArangoEdgesCollection have been removed
  completely.
  All internal and test code has been adjusted for this, and client code
  that uses edges.* should also still work because edges is still there and creates
  edge collections when _create() is called.
  
  INCOMPATIBLE CHANGE: Client code might still need to be changed in the following aspect:
  Previously, collections did not have a type so documents and edges could be inserted
  in the same collection. This is now disallowed. Edges can only be inserted into
  edge collections now. As there were no collection types in 1.0, ArangoDB will perform
  an automatic upgrade when migrating from 1.0 to 1.1.
  The automatic upgrade will check every collection and determine its type as follows:
  - if among the first 50 documents in the collection there are documents with
    attributes "_from" and "_to", the collection is typed as an edge collection
  - if among the first 50 documents in the collection there are no documents with
    attributes "_from" and "_to", the collection is made as a document collection

* issue #150: call V8 garbage collection on server periodically

* issue #110: added support for partial updates

  The REST API for documents now offers an HTTP PATCH method to partially update
  documents. Overwriting/replacing documents is still available via the HTTP PUT method
  as before. The Javascript API in the shell also offers a new update() method in extension to
  the previously existing replace() method.


v1.0.4 (2012-11-12)
-------------------

* issue #275: strange error message in arangosh 1.0.3 at startup


v1.0.3 (2012-11-08)
-------------------

* fixed AQL optimiser bug

* issue #273: fixed segfault in arangosh on HTTP 40x 

* issue #265: allow optional base64 encoding/decoding of action response data

* issue #252: _modules collection not created automatically


v1.0.2 (2012-10-22)
-------------------

* repository CentOS-X.Y moved to CentOS-X, same for Debian

* bugfix for rollback from edges

* bugfix for hash indexes

* bugfix for StringBuffer::erase_front

* added autoload for modules

* added AQL function TO_LIST


v1.0.1 (2012-09-30)
-------------------

* draft for issue #165: front-end application howto

* updated mruby to cf8fdea4a6598aa470e698e8cbc9b9b492319d

* fix for issue #190: install doesn't create log directory

* fix for issue #194: potential race condition between creating and dropping collections

* fix for issue #193: REST API HEAD request returns a message body on 404

* fix for issue #188: intermittent issues with 1.0.0 

* fix for issue #163: server cannot create collection because of abandoned files
  
* fix for issue #150: call V8 garbage collection on server periodically 


v1.0.0 (2012-08-17)
-------------------

* fix for issue #157: check for readline and ncurses headers, not only libraries


v1.0.beta4 (2012-08-15)
-----------------------

* fix for issue #152: fix memleak for barriers


v1.0.beta3 (2012-08-10)
-----------------------

* fix for issue #151: Memleak, collection data not removed

* fix for issue #149: Inconsistent port for admin interface

* fix for issue #163: server cannot create collection because of abandoned files

* fix for issue #157: check for readline and ncurses headers, not only libraries

* fix for issue #108: db.<collection>.truncate() inefficient

* fix for issue #109: added startup note about cached collection names and how to
  refresh them

* fix for issue #156: fixed memleaks in /_api/import

* fix for issue #59: added tests for /_api/import

* modified return value for calls to /_api/import: now, the attribute "empty" is 
  returned as well, stating the number of empty lines in the input. Also changed the
  return value of the error code attribute ("errorNum") from 1100 ("corrupted datafile")
  to 400 ("bad request") in case invalid/unexpected JSON data was sent to the server. 
  This error code is more appropriate as no datafile is broken but just input data is
  incorrect.

* fix for issue #152: Memleak for barriers

* fix for issue #151: Memleak, collection data not removed

* value of --database.maximal-journal-size parameter is now validated on startup. If
  value is smaller than the minimum value (currently 1048576), an error is thrown and
  the server will not start. Before this change, the global value of maximal journal 
  size was not validated at server start, but only on collection level

* increased sleep value in statistics creation loop from 10 to 500 microseconds. This
  reduces accuracy of statistics values somewhere after the decimal points but saves
  CPU time.

* avoid additional sync() calls when writing partial shape data (attribute name data) 
  to disk. sync() will still be called when the shape marker (will be written after
  the attributes) is written to disk 

* issue #147: added flag --database.force-sync-shapes to force synching of shape data
  to disk. The default value is true so it is the same behavior as in version 1.0.
  if set to false, shape data is synched to disk if waitForSync for the collection is
  set to true, otherwise, shape data is not synched.
  
* fix for issue #145: strange issue on Travis: added epsilon for numeric comparion in
  geo index

* fix for issue #136: adjusted message during indexing

* issue #131: added timeout for HTTP keep-alive connections. The default value is 300 
  seconds. There is a startup parameter server.keep-alive-timeout to configure the value. 
  Setting it to 0 will disable keep-alive entirely on the server.

* fix for issue #137: AQL optimizer should use indexes for ref accesses with 
  2 named attributes


v1.0.beta2 (2012-08-03)
-----------------------

* fix for issue #134: improvements for centos RPM

* fixed problem with disable-admin-interface in config file


v1.0.beta1 (2012-07-29)
-----------------------

* fixed issue #118: We need a collection "debugger"

* fixed issue #126: Access-Shaper must be cached

* INCOMPATIBLE CHANGE: renamed parameters "connect-timeout" and "request-timeout" 
  for arangosh and arangoimp to "--server.connect-timeout" and "--server.request-timeout"

* INCOMPATIBLE CHANGE: authorization is now required on the server side
  Clients sending requests without HTTP autorization will be rejected with HTTP 401
  To allow backwards compatibility, the server can be started with the option
  "--server.disable-authentication"

* added options "--server.username" and "--server.password" for arangosh and arangoimp
  These parameters must be used to specify the user and password to be used when
  connecting to the server. If no password is given on the command line, arangosh/
  arangoimp will interactively prompt for a password.
  If no user name is specified on the command line, the default user "root" will be
  used.

* added startup option "--server.ssl-cipher-list" to determine which ciphers to
  use in SSL context. also added SSL_OP_CIPHER_SERVER_PREFERENCE to SSL default 
  options so ciphers are tried in server and not in client order

* changed default SSL protocol to TLSv1 instead of SSLv2

* changed log-level of SSL-related messages

* added SSL connections if server is compiled with OpenSSL support. Use --help-ssl

* INCOMPATIBLE CHANGE: removed startup option "--server.admin-port". 
  The new endpoints feature (see --server.endpoint) allows opening multiple endpoints 
  anyway, and the distinction between admin and "other" endpoints can be emulated 
  later using privileges.

* INCOMPATIBLE CHANGE: removed startup options "--port", "--server.port", and 
  "--server.http-port" for arangod. 
  These options have been replaced by the new "--server.endpoint" parameter
  
* INCOMPATIBLE CHANGE: removed startup option "--server" for arangosh and arangoimp.
  These options have been replaced by the new "--server.endpoint" parameter

* Added "--server.endpoint" option to arangod, arangosh, and arangoimp.
  For arangod, this option allows specifying the bind endpoints for the server
  The server can be bound to one or multiple endpoints at once. For arangosh
  and arangoimp, the option specifies the server endpoint to connect to.
  The following endpoint syntax is currently supported:
  - tcp://host:port or http@tcp://host:port (HTTP over IPv4)
  - tcp://[host]:port or http@tcp://[host]:port (HTTP over IPv6)
  - ssl://host:port or http@tcp://host:port (HTTP over SSL-encrypted IPv4)
  - ssl://[host]:port or http@tcp://[host]:port (HTTP over SSL-encrypted IPv6)
  - unix:///path/to/socket or http@unix:///path/to/socket (HTTP over UNIX socket)

  If no port is specified, the default port of 8529 will be used.

* INCOMPATIBLE CHANGE: removed startup options "--server.require-keep-alive" and 
  "--server.secure-require-keep-alive". 
  The server will now behave as follows which should be more conforming to the 
  HTTP standard:
  * if a client sends a "Connection: close" header, the server will close the
    connection
  * if a client sends a "Connection: keep-alive" header, the server will not
    close the connection
  * if a client does not send any "Connection" header, the server will assume
    "keep-alive" if the request was an HTTP/1.1 request, and "close" if the
    request was an HTTP/1.0 request

* (minimal) internal optimisations for HTTP request parsing and response header 
  handling

* fixed Unicode unescaping bugs for \f and surrogate pairs in BasicsC/strings.c

* changed implementation of TRI_BlockCrc32 algorithm to use 8 bytes at a time

* fixed issue #122: arangod doesn't start if <log.file> cannot be created

* fixed issue #121: wrong collection size reported

* fixed issue #98: Unable to change journalSize

* fixed issue #88: fds not closed

* fixed escaping of document data in HTML admin front end

* added HTTP basic authentication, this is always turned on

* added server startup option --server.disable-admin-interface to turn off the
  HTML admin interface

* honor server startup option --database.maximal-journal-size when creating new
  collections without specific journalsize setting. Previously, these
  collections were always created with journal file sizes of 32 MB and the
  --database.maximal-journal-size setting was ignored

* added server startup option --database.wait-for-sync to control the default
  behavior

* renamed "--unit-tests" to "--javascript.unit-tests"


v1.0.alpha3 (2012-06-30)
------------------------

* fixed issue #116: createCollection=create option doesn't work

* fixed issue #115: Compilation issue under OSX 10.7 Lion & 10.8 Mountain Lion
  (homebrew)

* fixed issue #114: image not found

* fixed issue #111: crash during "make unittests"

* fixed issue #104: client.js -> ARANGO_QUIET is not defined


v1.0.alpha2 (2012-06-24)
------------------------

* fixed issue #112: do not accept document with duplicate attribute names

* fixed issue #103: Should we cleanup the directory structure

* fixed issue #100: "count" attribute exists in cursor response with "count:
  false"

* fixed issue #84 explain command 

* added new MRuby version (2012-06-02)

* added --log.filter

* cleanup of command line options:
** --startup.directory => --javascript.startup-directory
** --quite => --quiet
** --gc.interval => --javascript.gc-interval
** --startup.modules-path => --javascript.modules-path
** --action.system-directory => --javascript.action-directory
** --javascript.action-threads => removed (is now the same pool as --server.threads)

* various bug-fixes

* support for import

* added option SKIP_RANGES=1 for make unittests

* fixed several range-related assertion failures in the AQL query optimiser

* fixed AQL query optimisations for some edge cases (e.g. nested subqueries with
  invalid constant filter expressions)


v1.0.alpha1 (2012-05-28)
------------------------

Alpha Release of ArangoDB 1.0