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



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

Quick Guide to Using MongoDB With Django

In this article, learn how to call MongoDB from Python (using MongoEngine), and integrate it into a Django project in lieu of the built-in ORM. A sample web interface for creating, reading, writing, and updating data to the MongoDB back end is included.

When I’m thinking of Django (and Rails) one of its major strengths is the ease of defining mappings for the application entities and the way these mappings integrate with both the persistence layer and presentation layer. But the document model is introducing a lot of different options and approaches when compared with the relational model (which is the default in Django). Support for simple mappings is a good start, but I don’t think MongoDB integration supports yet optional fields, or entity versioning, or custom aggregate entity mappings, or tunable queries.

Original title and link: Quick Guide to Using MongoDB With Django (NoSQL database©myNoSQL)


Storing Django Sessions in DynamoDB with django-dynamodb-sessions



  • reduces read/write access to your main database
  • all DynamoDB benefits:
    • fully manged solution
    • scalable
    • fast and predictable performance

Cons (or more of when not to use it):

  • if your application is not running in the AWS cloud
  • the size of the sessions is bigger than 64KB

Original title and link: Storing Django Sessions in DynamoDB with django-dynamodb-sessions (NoSQL database©myNoSQL)


The realtime web with gevent, socket io, redis and django

To show you how to achieve this we are going to build a quick Tic Tac Toe application using SocketIO, gevent, redis, and Django.

Not a revolutionary app, but you can get all the code and see how the pieces fit together

Salvatore Sanfilippo

Original title and link: The realtime web with gevent, socket io, redis and django (NoSQL databases © myNoSQL)


Riak as a Django Session Store

Using an external reliable storage for web sessions makes sense when you don’t want to use sticky balancers:

This snippet uses a Riak bucket as a Django session store.

There is one thing you want to make sure your session manager is doing right: all session set operations must not access the underlying storage.


Original title and link: Riak as a Django Session Store (NoSQL databases © myNoSQL)


NoSQL and Django Panel Video

Featuring Jacob Burch, Alex Gaynor, Eric Florenzano, Jacob Kaplan-Moss, Michael Richardson, Noah Silas[1]:

You probably know already that Django and NoSQL is hot!

  1. Unfortunately it looks like the real people on the panel aren’t the same with the ones listed.  ()

Original title and link: NoSQL and Django Panel Video (NoSQL databases © myNoSQL)

Cassandra and ElasticSearch backends for Django-nonrel in development

Django continues his path towards NoSQL:

Rob Vaterlaus has started working on a Cassandra backend and Alberto Paro is working on an ElasticSearch backend for Django-nonrel.

The Cassandra backend is still experimental and lacks support for ListField (from djangotoolbox.fields), but overall it already looks very very interesting. This backend comes with experimental secondary indexes support for Cassandra and requires a recent Cassandra 0.7 build.

Currently supported: App Engine and MongoDB.

Original title and link: Cassandra and ElasticSearch backends for Django-nonrel in development (NoSQL databases © myNoSQL)


Disqus: Scaling the World’s Largest Django Application

Good lessons on building high availability services from Disqus, the commenting service:

Interesting to note that MongoDB is not mentioned anywhere in the talk, even if Disqus is powered by MongoDB. It is either because MongoDB scaling and high availability weren’t a concern (nb no pun intended, but I doubt that) or that MongoDB is not a central piece of Disqus architecture.

Original title and link: Disqus: Scaling the World’s Largest Django Application (NoSQL databases © myNoSQL)

Django and MongoDB

Chris Umbel ending a short tutorial on using Django with MongoDB:

Thanks to the hard work of others it’s a simple matter for us to use MongoDB as a backend for django.

All the work on intergrating NoSQL with Django seems to show its usefulness.

Original title and link: Django and MongoDB (NoSQL databases © myNoSQL)


Django Getting NoSQL Support in Trunk?

We’ve covered Django and NoSQL extensively over here and now the news it that “official” NoSQL support might get into Django trunk:

Waldemar Kornewald: in my last discussion on django-users Russell told me that he’d like to see four proof-of-concept (or better) backends before considering NoSQL for inclusion in trunk. The primary point was that enough eyeballs have looked at the API, first. Now we finally have four backends for Django-nonrel:

  • App Engine (used in production), developed by Thomas Wanschik and me
  • MongoDB (used in production), developed by Flavio Percoco Premoli, Alberto Paro, George Karpenkov, and me
  • Cassandra (alpha/experimental), developed by Rob Vaterlaus with very minor hints from me
  • ElasticSearch (alpha/experimental), developed by Alberto Paro

Neo4j integration with Django seems to be missing from the list.

Original title and link: Django Getting NoSQL Support in Trunk? (NoSQL databases © myNoSQL)


Tornado Sees Some NoSQL Activity

Tornado, the non-blocking web server and tools open sourced by FriendFeed before their acquisition, seems to get some NoSQL activity. While Django is leading the way in the Python world, judging by the NoSQL projects happening around Node.js, one could say that Tornado, with its non-blocking architecture, may be an interesting alternative.

Thomas Pelletier has ☞ a blog post about a simple websocket + Tornado + Redis Pub/Sub protocol integration:

The principle is very simple: when your user loads the page, she is automatically added to a list of “listeners”. An independent thread is running: it listens for messages from Redis with the subscribe command, and send a message through Websocket to every registered ”listener”. In this example, the user can send a message to herself with a simple AJAX-powered form, which calls a view with a payload (the message), and the view publish it via the publish command of Redis.

This is basically a web chat! If you want to have fun, you can then add a roster, with a presence system, authentication etc…

There’s also a ☞ GitHub project called Trombi:

Trombi is an asynchronous CouchDB client for Tornado.

And I’m pretty sure there are other projects I’ve missed (but you can leave a comment to add them to the list).

Original title and link for this post: Tornado Sees Some NoSQL Activity (published on the NoSQL blog: myNoSQL)

Django and NoSQL Databases Latest Status Update

Recently, in the Django and NoSQL databases revisited, I’ve covered the coordinated efforts for making Django a NoSQL friendly framework. Alex Gaynor, the main person behind this initiative having the support of the Django community, has ☞ published the final report of the GSOC project:

With this past week GSOC has officially come to it’s close, and I’m here to report on the status of the query-refactor. The original purpose of this branch was to do refactorings to the internals of the ORM, and produce a prototype backend for a non-relational database to demonstrate that this was a viable option. At this time far more work has gone into the latter half of the project, I have developed a fully functioning MongoDB backend, that demonstrates that possibility of using the ORM, almost unmodified on non-relational databases. However, some of the larger refactors that I was originally hoping to do have ultimately not happened, on the other hand they are evidentially not necessary for a functioning backend. At this time there are a number of outstanding tasks, such as: porting the ListField to work on Postgres, and completing the work on embedded documents.
However the largest open question is what of this work should be merged into trunk, and what should live external. My recommendation would be for any changes in Django itself to be merged, including the new form fields, but for the MongoDB backend (and, indeed, any future backends) to live external to Django, until such a time as it obtains a user base anywhere approaching our current backends, as well as a more individuals dedicated to maintaining it.

The guys over ☞ All Buttons Pressed also commented on the outcome of this project:

The biggest design issue (in my opinion) is how to handle AutoField. In the GSoC branch, non-relational model code would always need a manually added NativeAutoField(primary_key=True) because many NoSQL DBs use string-based primary keys. As you can see in Django-nonrel, a NativeAutoField is unnecessary. The normal AutoField already works very well and it has the advantage that you can reuse existing Django apps unmodified and you don’t need a special NativeAutoField definition in your model. Hopefully this issue will get fixed before official NoSQL support is merged into trunk.

Original title and link for this post: Django and NoSQL Databases Latest Status Update (published on the NoSQL blog: myNoSQL)

Django and NoSQL Databases Revisited

Django decided long time ago that Ruby on Rails cannot be the only framework where people can have fun integrating with all NoSQL databases. During this year DjangoCon Europe there were several session dedicated to Django and NoSQL databases:

What NoSQL support in the Django ORM looks like, and how do we get there

Alex Gaynor speaks about what needs to change in Django ORM to make it more NoSQL friendly:

Reinout van Rees has a summary of the talk ☞ here.

Using MongoDB in your app

Peter Bengtsson talks about his experience of passing from using ZODB for the last 10 years to MongoDB

Some notes from the talk are available ☞ here.

Relax your project with CouchDB

Benoît Chesneau talks about what makes CouchDB appealing to python developers. He also covers the CouchDBkit python framework.

Django and Neo4j: Domain Modeling that Kicks Ass

Not coming from DjangoCon, but still about Django and Neo4j, is Tobias Ivarsson’s presentation: “Django and Neo4j - Domain modeling that kicks ass”:

Derek Stainer summarizes the slide deck ☞ here.

Django and NoSQL Panel

A fantastic panel on the future of Django and NoSQL databases that you can watch over ☞ Reinout van Rees published a transcript of the panel ☞ here.

All in all a lot of NoSQL excitement in the Django world! Or should it be the opposite?

Update: Here is the latest Django and NoSQL Databases status update

Django and NoSQL Databases Revisited originally posted on the NoSQL blog: myNoSQL