Addressing a database as a multi-level associative array - database

Question

I'm writing a web game, where it's very convenient to think about the complete game state as a single arbitrary-level hash.
A couple examples of the game state being updated:
// Defining a mission card that could be issued to a player
$game['consumables']['missions']['id04536']['name'] = "Build a Galleon for Blackbeard";
$game['consumables']['missions']['id04536']['requirements']['lumber'] = 20;
$game['consumables']['missions']['id04536']['requirements']['iron'] = 10;
$game['consumables']['missions']['id04536']['rewards']['blackbeard_standing'] = 5;
// When a player turns in this mission card with its requirements
$game['players']['id3214']['blackbeard_standing'] += 5;
This is a web game, so storing the information in a database makes sense. I need the features of a database: That the game state can be accessed from multiple browsers at the same time, that it's non-volatile and easy to back up, etc.
Essentially, I want syntax as easy as reading-to/writing-from an associative array of arbitrary depth. I need all the functionality of dealing with an associative array: Not just simple reads and writes, the but the ability to run foreach loops against it, and so on. And I need the effect to actually be to perform all reads/writes from a database, not from volatile memory.
I'm personally fond of raw Ruby, but if there's a specific language or framework that gives me this one feature, it would make the rest of this project easy enough to be worth using.

Answer 1

any language, framework? How about python+sqlalchemy+postgresql
python because you can easily create new types that behave for all the world like regular dicts
postgres because it has two particularly interesting types uncommon in other sql databases, we'll get to that in a moment.
sqlalchemy because it can do all of the dirty work of dealing with an rdbms concisely.
Using a sql database like this is awkward, because the normal 'key' you would want in a table has to be a fixed set of columns, so ideally, you'd need a single column for the whole "path" into the deeply nested mapping.
An even more irritating problem is that you seem to want to store a range of different types at the leaves. This is not ideal.
Fortunately, postgres can help us out with both issues, using a TEXT[] for the first, we can have a single column so that every entry can concisely represent the whole path, all the way down the tree. For the second, we can use JSON, which is exactly like it sounds, permitting arbitrary json encodable types, which significantly does include both strings and numbers as in your code example.
Because I am lazy, i'll use sqlalchemy to do most of the work. First, we need a table using the above types:
from sqlalchemy import *
from sqlalchemy.orm import *
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.dialects import postgres as pg
Base = declarative_base()
class AssocStorage(Base):
__tablename__ = 'assoc_storage'
key = Column(pg.ARRAY(pg.TEXT, as_tuple=True), primary_key=True)
value = Column(pg.JSON)
That will give us a relational version of a single entry in a deeply nested mapping. We're most of the way there already:
>>> engine = create_engine('postgres:///database')
>>> Base.metadata.create_all(engine) ## beware, extreem lazyness
>>> session = Session(bind=engine) ## also unusually lazy, real applications should use `sessionmaker`
>>> session.add(AssocStorage(key=('foo','bar'), value=5))
>>> session.commit()
>>> x = session.query(AssocStorage).get((('foo', 'bar'),))
>>> x.key
(u'foo', u'bar')
>>> x.value
5
Okay, not too bad, but this is a little more annoying to use, Like i mentioned earlier, the python type system is compliant enough to make this look like a normal dict, we need only give a class that implements the proper protocol:
import collections
class PersistentDictView(collections.MutableMapping):
# a "production grade" version should actually implement these:
__delitem__ = __iter__ = __len__ = NotImplemented
def __init__(self, session):
self.session = session
def __getitem__(self, key):
return self.session.query(AssocStorage).get((key, )).value
def __setitem__(self, key, value):
existing_item = self.session.query(AssocStorage).get((key, ))
if existing_item is None:
existing_item = AssocStorage(key=key)
self.session.add(existing_item)
existing_item.value = value
This is slightly different from the code you've posted, where you have x[a][b][c], this requires x[a, b, c].
>>> d = PersistentDictView(session)
>>> d['foo', 'bar', 'baz'] = 5
>>> d['foo', 'bar', 'baz']
5
>>> d['foo', 'bar', 'baz'] += 5
>>> session.commit()
>>> d['foo', 'bar', 'baz']
10
If you really need your nesting for some reason, you could get that behavior with only a bit more work, but it would require a little more effort. Additionally, this totally punts on transaction management, notice the explicit session.commit() above.

Answer 2

MongoDB(+its Ruby gem) was the best answer I found. And so easy to install and learn.
It gets me 90% of the way to treating the entire game state as a multi-level hash. Close enough. I can treat the collections as the first hash level, and use it to store & retrieve multilevel hashes.