Disk space usage with different journal sizes

A while ago we wrote some blog article that explained how ArangoDB uses disk space. That article compared the disk usage of ArangoDB, CouchDB, and MongoDB for loading some particular datasets. In this post, we’ll show in more detail the disk usage of ArangoDB for insert, update, and delete operations. We’ll also compare it to CouchDB for reference.

Posted in Architecture, Performance | Leave a comment

Disk space usage in ArangoDB

In this post we’ll explain how ArangoDB stores collection data on disk and look at its storage space requirements, compared to other popular NoSQL databases such as CouchDB and MongoDB. How ArangoDB allocates disk space ArangoDB stores documents in collections. The collection data is persisted on disk so it does not get lost in case of a server restart.

Posted in Architecture, General, Performance | 2 Comments

Is UNQL Dead?

Note: We changed the name of the database in May 2012. AvocadoDB is now called ArangoDB. UNQL started with quite some hype last year. However, after some burst of activity the project came to a hold. So it seems, that – at least as a project – UNQL has been a failure. IMHO one of the major issues with the current UNQL is, that it tries to cover everything in NoSQL, from key-value stores to document-stores to graph-database. Basically you end up with greatest common divisor – namely key-value access. But with graph structures and also document-structures you really want to supports joins, paths or some sort of sub-structures. Apart from all the technical and theoretical benefits of SQL and what advantages the underlying theory has to offer, the major plus from an users point of view is that it is readable. You simple can see an SQL statement – be it in C, Java, Ruby – and understand what is going on. It is declarative, not imperative. With other imperative solution, like a fluent interface or a map-reduce, you need to understand the underlying syntax or language. With SQL you only need to understand English – at least most of the time. And here I think is where UNQL is totally right. We need something similar for the NoSQL world. But it should not try to be a “fits all situation”. It should be a fit for 80% of the problems. For simple key-values stores a fluent-interface is indeed enough. For very complex graph traversals a traversal program must be written. For very complex map-reduces you might need to write a program – but check out Google’s talk (www.nosql-matters.org/program) about NoNoSQL. There they describe why they are developing a SQL-like interface for Map/Reduce. In my experience most of the time you have a set of collections holding different “types” of documents with some relations between them. One of the biggest advantages of document stores or graph databases is that you can have lists and sub-objects. The problem with SQL is, that it has no good way to deal with these structures. So I believe UNQL would be quite successful if it would concentrate on these strong advantages of NoSQL, instead of trying to unify everything – especially after hear Jan’s talk about a document query language at the NoSQL Cologne UG (an English version is also available). Cheers Frankaaa

Posted in Architecture, Query Language | Tagged | 4 Comments

martin on skip list indices and why we use them in ArangoDB

Note: We changed the name of the database in May 2012. AvocadoDB is now called ArangoDB. Last week AvocadoDB got mentioned in “nosql weekly” and the project achieved a huge amount of public interest especially from Japan. Awesome! In this context Mr. Fiber asked on twitter what the use of skip list indices in AvocadoDB is. Here’s a short video reply by chief architect martin Schoenert. Got an opinion on this? – we’d love to hear your thoughts on this in the comments. skip list index from NoSQL matters on Vimeo or on Youtube

Posted in Architecture | 6 Comments

Under a microscope: how ArangoDB stores data in RAM and data is secured consistently nonetheless in case of a server crash

Note: We changed the name of the database in May 2012. AvocadoDB is now called ArangoDB. AvocadoDB uses AppendOnly memory-mapped files with frequent fsync. Derived data (indices, etc.) is stored in the main memory only. This article explains why that particular combination leads to high performance and consistent data at the same time―even in case of a system failure. Classical database systems – a bulk of data and insufficient main memory Put simply, there are three possible settings regarding databases: Setting 1: All data fits into the main memory. Setting 2: The complete data pool does not fit into the main memory all at once, but the main memory is large enough to store all the data accessed in an average time span. Setting 3: Even the sub-set of data accessed in an average time span is too large for the main memory. Classical database systems had to cope with setting 3 because main memory was too expensive to store the majority of data. Basically, classical database systems had to manage the main memory themselves. To manage all data sets that exceeded the capacity of the main memory they needed sufficiently intelligent algorithms which the system software couldn’t provide (i.e., to stream the data through main memory for full table scans).

Posted in Architecture | 2 Comments

ArangoDB’s design objectives

Before we started programming the new open source NoSQL database, we reflected which design objectives to achieve or to drop. This article summarizes our considerations. In a nutshell: Schema-free schemas with shapes: Inherent structures at hand are automatically recognized and subsequently optimized. Querying: ArangoDB is able to accomplish complex operations on the provided data (query-by-example and query-language). Application Server: ArangoDB is able to act as application server on Javascript-devised routines. Mostly memory/durability: ArangoDB is memory-based including frequent file system synchronizing. AppendOnly/MVCC: Updates generate new versions of a document; automatic garbage collection. ArangoDB is multi-threaded. No indices on file: Only raw data is written on hard disk. ArangoDB supports single nodes and small, homogenous clusters with zero administration.

Posted in Architecture | Tagged | 3 Comments