it is me

Hi,

for a while now I’ve been using and trying out Apache CouchDB, the rather new and very cool document-oriented database written in Erlang.

The problem

To get used to the Couch a bit (it’s very comfortable, by the way), I’m currently writing a quote management system with CouchDB as backend. Now, every quote thingy has a feature like »random quotes«, and this is done with SQL backends using ORDER BY RANDOM() or something like that. Now CouchDB doesn’t use SQL, but instead view-based querying, where views are based on map/reduce functions (read more in the CouchDB wiki). It’s not so easy to order by RANDOM() here.

The solution

… is to create a view that I called random_quotes, with only a map function, which looks as follows:

function(doc) {
    emit(Math.random(), doc);
}

Now you’ll get a random number associated with each of your documents. To get 1 or n random documents from your CouchDB now, you query the view with the startkey parameter set to a random number between 0 and 1 (e. g. in Python: startkey = random.random()), and set limit to the maximum of rows that you want to get.
Now you could possibly get less rows than you wanted, because if your startkey is too high, it won’t cover that much documents. The solution is to count what you’ve got, and get documents from the beginning of the view, with a limit of as much documents as you still need, and the endkey set to your previous startkey.

I have written a python function that does this, using CouchDBKit, to which I contributed a object mapper:

import random
def get_random(db, n):
    """Get an iterator over n random quotes from the database.
    
    Parameters:
        db: couchdbkit.session.Session
        n: int
    """
    # see above how this view looks like
    view_results = db.view('quote/random_quotes',
        startkey=random.random(),
        limit=n)
    count = view_results.count()
    if count >= n:
        return view_results
    else: # not enough documents yet:
        new_limit = n - count
        other_results = view_results.view(
            endkey=view_results.params['startkey'],
            limit=new_limit)
        # we'll get at most as much documents as the DB contains, rather than
        # getting duplicates
        return chain(view_results, other_results)

Update: Note that if you query for more than a document at a time, you are likely to get »bad« randomness, i. e. always the same set of documents for a given random startkey. I haven’t yet found a solution to this, so if you need true randomness, you better query for single documents and aggregate them yourself.

Have fun with that, and a nice day,
Jannis.