NoSQL Benchmarks NoSQL use cases NoSQL Videos NoSQL Hybrid Solutions NoSQL Presentations Big Data Hadoop MapReduce Pig Hive Flume Oozie Sqoop HDFS ZooKeeper Cascading Cascalog BigTable Cassandra HBase Hypertable Couchbase CouchDB MongoDB OrientDB RavenDB Jackrabbit Terrastore Amazon DynamoDB Redis Riak Project Voldemort Tokyo Cabinet Kyoto Cabinet memcached Amazon SimpleDB Datomic MemcacheDB M/DB GT.M Amazon Dynamo Dynomite Mnesia Yahoo! PNUTS/Sherpa Neo4j InfoGrid Sones GraphDB InfiniteGraph AllegroGraph MarkLogic Clustrix CouchDB Case Studies MongoDB Case Studies NoSQL at Adobe NoSQL at Facebook NoSQL at Twitter



libraries: All content tagged as libraries in NoSQL databases and polyglot persistence

CouchDB Official List of Drivers

This ☞ official list (nb: as in listed on Couchone blog) of CouchDB drivers — we’ve had it for a long time under CouchDB libraries — is just the first step towards the list of CouchDB official libraries.

Original title and link: CouchDB Official List of Drivers (NoSQL databases © myNoSQL)

Redis: Java Libraries

Staying in the Java land, I’ve put together this short list of Redis Java libraries as I’m looking myself for a stable one:


Main page mentions that JRedis is compatible with Redis 1.2.x only. But JRedis author left a comment mentioning that JRedis is Redis 2.0.0 compatible.

jredis project


Project home page mentions that Jedis is compatible with Redis 2.0.0. Currently the following features are supported:

  • Sorting
  • Connection handling
  • Commands operating on all the kind of values
  • Commands operating on string values
  • Commands operating on hashes
  • Commands operating on lists
  • Commands operating on sets
  • Commands operating on sorted sets
  • Transactions
  • Pipelining
  • Publish/Subscribe
  • Persistence control commands
  • Remote server control commands
  • Connection pooling

jedis project


A library developed in Scala (you should still be able to use it from any VM language) compatible with Redis 2.0.0. Some features:

  • Native Scala types Set and List responses.
  • Consisten Hashing on the client.
  • Support for Clustering of Redis nodes.

scala-redis project

Have I missed any? Also wondering which of these is stable.

Update: Graeme Rocher (@graemerocher) pointed out:


According to project home page, it is compatible with Redis 2.0.0, but there are no other details.

java-redis-client project.

Original title and link for this post: Redis: Java Libraries (published on the NoSQL blog: myNoSQL)

MongoDB: Java Frameworks Compared

Knut Haugen takes a look at MongoDB Java Driver, Morphia, and Mungbean:

It’s Mungbean, by a nose! Mainly because of the cleaner domain objects and the DSL. There is more code involved but I found it to be more elegant than the other approaches. I want to note that both morphia and mungbean are not immensely mature and done by any definition of the word and that has to come into consideration when using them. And it may be that a wordy statically typed language like Java has a bit of friction with a very dynamic database backend like MongoDB. I don’t know, but I’ll be looking into ruby drivers in the future and we’ll see.

The other libraries — GuiceyData, Sculptor, Morphia, but also the MongoDB Java driver — are compared in MongoDB in Java.

Original title and link for this post: MongoDB: Java Frameworks Compared (published on the NoSQL blog: myNoSQL)


MongoODM: A new Mongo ODM for Ruby

There have been only a few days since I’ve written that (maybe) there are already too may mapping tools for document databases. Then, we’ve heard about Mongomatic: a minimal Ruby mapper for MongoDB. And now it is MongoODM, yet another Ruby mapper for MongoDB that can be found on ☞ GitHub.

Basically, I’ve tried to create an ODM that uses the native query syntax of the Ruby driver, but that was:

  • Fully compatible with Rails 3
  • Use the Mongo ruby driver syntax over a new syntax (for queries, cursors, indexes management…)
  • Allow lazy loading of collections and queries nesting (concatenation of ‘find’ calls) to emulate ActiveRecord 3
  • No association methods (for now): Just declare your own methods on models to fetch associated items
  • Give support for dirty objects, validations, etc. through ActiveModel 3
  • Automanage type conversions and default values
  • Keep it as simple as possible

I made sure to ask the author, Carlos Paramio, why a new mapping tool for MongoDB? and what is it different in MongoODM compared to those other 3 MongoDB mapping libraries?

Carlos Paramio: The main reason for me creating this new ODM is that I felt the Mongo Ruby driver and its syntax (which is pretty similar to the native MongoDB syntax) is much more proper and richer than the syntax similar to the popular ActiveRecord ORM for Ruby — which is particularly designed for relational databases. Even if MongoMapper and MongoId are awesome projects, they both share this particular ActiveRecord-like syntax, which sometimes seems a bit forced and it generates weird bugs and unexpected behavior.

I preferred to use the official syntax and instead of writing tons of new code to bring all the other interesting features that you would expect from an Object Mapper (as an extra to the database driver), I used some stable and widely used Ruby libraries to provide: Validations, type conversions, dirty objects, nesting conditions, Rails 3 compatibility, etc.

There is a similar ODM by Ben Myles, who shares this same opinion about how a MongoDB ODM should work. It’s called MongoMatic, and it’s really cool. I think we started to code our ODMs at approximately same time, because we both have published stable versions of them recently (I’m particularly using MongoODM for my own project). MongoMatic doesn’t support some features like dirty objects, nesting conditions or Rails 3 compatibility yet, but it seems to be interesting to follow.

I think some people was expecting a solution like this. Like Kyle Banker has said (and I quote) recently in response to the MongoODM announcement at the mongodb-user mailing list: “Awesome. I love the trend of moving toward a more native MongoDB query syntax. Great to see the surge in new Ruby ODMs, too.”

Now the Ruby world of MongoDB has 4 mapping libraries and it is only the time and users that will decide if all of them are needed.

Original title and link for this post: MongoODM: A new Mongo ODM for Ruby (published on the NoSQL blog: myNoSQL)

CouchDB: Use Wikipedia As Sample Data

In case you miss data to play with CouchDB, now you can ☞ import Wikipedia dumps:

First of all WikiImporter is a lame name! It is a set of tools for importing Wikipedia dumps to CouchDB. The parser currently only extracts the page ID, title, text, version ID and the timestamp of the latest change. For CouchDB document IDs currently the page title is used.

CouchDB: Use Wikipedia As Sample Data originally posted on the NoSQL blog: myNoSQL

Most Popular MongoDB Ruby libs Compared: MongoMapper and Mongoid

Useful information for MongoDB users in the Ruby-land:

At first glance, Mongoid and MongoMapper seem to take similar approaches and have very similar APIs, […] it turns out they have different motivations, aims, and, underneath it all, they target different use cases pretty well.


NoSQL Ecosystem News & Links 2010-06-01

  1. Richard Boulton: ☞ Using Redis as a backend for Xapian. An interesting analysis of how a dedicated search engine would work with a Redis backend. Meanwhile others try to simply store the reverted index into Redis
  2. Paul Rosania: ☞ Point-and-Click install of MongoDB on OS X 10.5+. Not that it was difficult before, but nice to have!
  3. Doug Judd: ☞ Why We Started Hypertable, Inc. … or welcome to the Hypertable Inc. blog.
  4. Surya Surabarapu: ☞ Terrastore Scala Client. First Terrastore library in our NoSQL libraries list

Tutorial: CouchDB and Java with the ektorp library

It might be only my feeling that the amount of experiments and work done in the NoSQL space using dynamic languages (PHP, Python, Ruby, etc.) is bigger than what has been done so far using “big brothers” languages like C# or Java. That’s not to say that C# and Java developers do not like NoSQL, just that good resources are rare.

Recently the author of the Java CouchDB ektorp library has published ☞ an interesting tutorial on how to build a basic blog app[1].

Here are my notes after going through the article:

  • model classes must extend a library provided class (CouchDbDocument). Java being a single inheritance language, this might be an issue for complex class hierarchies, so I was wondering if an approach based on annotations (see JPA) would not work even better. Update: according to the author this is optional and there are also mechanisms available.
  • “view” classes which provide through an annotation the CouchDB mapreduce based view definition.

It is also worth noting the comment around the model definition:

The relationship between BlogPost and Comment is modeled with a blogPostId field in Comment. In order to find the comments for a blog post a ‘by_blogPostId’ query has to be performed.

A perhaps more natural way would be let BlogPost keep its comments in a list. Although this is possible, this model would cause update congestion in the blog post document if many users post comments concurrently.

A better way is to keep each comment in its own document as no update conflict will occur.

We already talked a couple of times about how important is the role of data modeling while using a NoSQL storage. And even if CouchDB has ☞ a whole wiki page dedicated to modeling entity relationships and there are some articles covering schemaless data modeling, questions are still arising ☞ every ☞ day. The lesson to be learned from this is that: 1) you’ll need to carefully design your data model and 2) while you might be tempted to re-use an already known “pattern”, you’d better think twice about your application scenarios.


Work on Avro interface for HBase

There seems to be ☞ some work done to provide an Avro[1]recently graduated project together with HBase — interface for HBase.


Cassandra Web Console

Suguru Namura has published a set of screenshot of a web console for Cassandra:

Even if a bit later than others - for example CouchDB has Futon, HBase has ☞ hbaseexplorer, MongoDB has quite a few: mongo3, futon4mongo and phpMoAdmin plus MongoHub, Redis has Redweb — such tools are always welcome!

pymongo vs. Ming vs. Mongokit

A (not so scientific) discussion on the speed of various MongoDB libraries showing some of the overhead cause by the library language and/or the additional features.


MongoDB Utilities

After presenting a couple of nice GUI tools for MongoDB, it’s time to look at a different set of utilities for MongoDB:

MongoDB Slow Queries Monitor

This is a ☞ plugin for Scout[1]:

Reports slow queries based on the threshold (100ms or greater) you specify. Provides details on queries that are slow.

MongoDB Metrics for Ganglia

In the same field, we have ☞ a simple Python script for submitting MongoDB metrics to Ganglia[2].

Right now it tracks the following:

  • Operations per second
  • Memory usage
  • Btree statistics
  • Master/Slave status
  • Current connections

Meclipse: Eclipse + MongoDB

☞ Meclipse is an Eclipse[3] plugin for MongoDB administration:

What does Meclipse do? * It has a MongoDB View that contains a list of servers (connections). It is possible to add/remove connections. They are saved in a settings file. * It loads (as TreeView) the list of databases and collections. * It loads the data found in the collection. To do this, Meclipse opens a new Editor and shows the data loaded (This part needs a lot of work).

Do you have other MongoDB utilities that you’d like to share?


  • [1] ☞ Scout: simple server and application monitoring ()
  • [2] ☞ Ganglia: a scalable distributed monitoring system for high-performance computing systems such as clusters and Grids. ()
  • [3] ☞ Eclipse: is a multi-purpose, extensible IDE. ()