Redis: Relations in a NoSQL world: Using Hashes

So just yesterday we posted a tutorial on how to use redis to store relational despite relations not being supported. Soon after we published the documentation on the new redis hash type went online. Now hashes by themselves aren’t exactly relations but, more so an object field store. Extending the same concepts from our first article in namespace utilization and using hashes we can accomplish the same thing in a more formal fashion.

We will repeat the same exercise from the first article, creating a username password store, using hashes.

Basic hash overview

Without going into the technical details we can simplify the concept of redis’s as a way to store fields in a redis key. In Pythonic terms we can make a redis key into a basic Python dictionary.

[key] : {‘field’ -> ‘value’, ‘field’ -> ‘value’, ‘field’ -> ‘value’}

Basic hash usage

>>> r.hset("user:adam", "fullname", "Adam Smith")
1
>>> r.hset("user:adam", "password", "thisisapassword")
1
>>> r.hkeys("user:adam")
['fullname', 'password']
>>> r.hvals("user:adam")
['Adam Smith', 'thisisapassword']
>>> r.hgetall("user:adam")
{'fullname': 'Adam Smith', 'password': 'thisisapassword'}

We will break it down line by line here

1. First we are going to make the redis key “user:adam” a hash and set the field “fullname” in that has to the value “Adam Smith” with the redis command hset (Hash Set)
2. Then we’ll do the same thing for the field “password” and set that field in the hash to it’s appropriate value.
3. With the hkeys command we can see all of the keys in the hash set on that redis key
4. hvals returns all of the values in the redis key
5. More useful, is the hgetall command. This will return a Python dictionary of all of the fields set in the key

As you can see, this is an excellent way to store information about an object without “faking” a relation like in our previous tutorial.

As I mentioned in the conclusion of the last article, if we want to change how we store information in redis all we should have to do is to change is change the inner workings of the functions add_user, authenticate_user, delete_user and the rest of our fictitious application should operate without any changes.

Creating a new user

r = redis.Redis("localhost")
from hashlib import md5

def add_user(username, fullname, password):
    if r.sadd("users", username):
        #r.set("user:%s:fullname" % username, fullname)
        #r.set("user:%s:password" % username, md5(password).hexdigest() )
        r.hset("user:%s" % username, "fullname", fullname)
        r.hset("user:%s" % username, "password", md5(password).hexdigest())
        return True
    else:
        return False

I left the original code in the function commented out so we can see the differences in the two methods here. In our original method we used the name space of redis itself to store the reference. In the updated fashion we are using redis’s hash data type to store the related fields.

>>> add_user("adam", "Adam Smith", "wealthofnations")
True
>>> add_user("adam", "Adam Smith", "wealthofnations")
False

This function operates in the same fashion as our old version did but, is using a different data structure in the backend.

Logging a user in

Now we’ll refactor our old authentication code to work with the new backend.

def authenticate_user(username, password):
    #if username in r.smembers("users"):
    if r.sismember("users", username"):
        passhash = md5(password).hexdigest()
        #if passhash == r.get("user:%s:password" % username):
        if passhash == r.hget("user:%s" % username, "password"):
            return True
        else:
            return False
    else:
        return False

Just as in the add_user function, we just need to make a small change. Now instead of fetching the related redis key we simply fetch the field from the hash of “user:*username*”.

>>> authenticate_user("adam", "wealthofnations")
True
>>> authenticate_user("adam", "bad_password")
False

We can see the function again performs just like the old function but, it pulls the password from the hash object instead of the related key

Deleting a user

Deleting a user using the hash store is much easier than using the related key store, since everything is just stored in one key instead of being spread out across multiple keys.

def delete_user(username):
    #if username in r.smembers("users"):
    if r.sismembers("users", username):
        r.srem("users", username)
        r.delete("user:%s" % username)
        #r.delete("user:%s:fullname" % username)
        #r.delete("user:%s:password" % username)
        return True
    else:
        return False
<pre>

Now instead of having to delete the 2 related keys, we just need to delete the one key storing the hash of all of the user data