Python’s SQLAlchemy vs Other ORMs[转发 2]Storm

Storm

Storm is a Python ORM that maps objects between one or more databases and Python. It allows developers to construct complex queries across multiple database tables to support dynamic storage and retrieval of object information. It was developed in Python at Canonical Ltd., the company behind Ubuntu, for use in the Launchpad and Landscape applications and subsequently released in 2007 as free software. The project is released under the LGPL license and contributors are required to assign copyrights to Canonical.

Like SQLAlchemy and SQLObject, Storm also maps tables to classes, rows to instances and columns to attributes. Compared to the other two, Storm's table classes do not have to be subclasses of a special framework-specific superclass. In SQLAlchemy, every table class is a subclass of sqlalchemy.ext.declarative.declarative_bas. In SQLObject, every table class is a subclass of sqlobject.SQLObject.

Similar to SQLAlchemy, Storm's Store object acts as a surrogate to the backend database, where all the operations are cached in-memory and committed into the database once the method commit is called on the store. Each store holds its own set of mapped Python database objects, just like a SQLAlchemy session holding different sets of Python objects.

Specific versions of Storm can be downloaded from the download page. In this article, the example code is written in Storm version 0.20.

 >>> from storm.locals import Int, Reference, Unicode, create_database, Store
 >>>
 >>>
 >>> db = create_database('sqlite:')
 >>> store = Store(db)
 >>>
 >>>
 >>> class Person(object):
 ...     __storm_table__ = 'person'
 ...     id = Int(primary=True)
 ...     name = Unicode()
 ...
 >>>
 >>> class Address(object):
 ...     __storm_table__ = 'address'
 ...     id = Int(primary=True)
 ...     address = Unicode()
 ...     person_id = Int()
 ...     person = Reference(person_id, Person.id)
 ...

The code above created an in-memory sqlite database and a store to reference that database object. A Storm store is similar to a SQLAlchemy DBSession object, both of which manage the life cycles of instance objects attached to them. For example, the following code creates a person and an address, and inserts both records into the database by flushing the store.

 >>> store.execute("CREATE TABLE person "
 ... "(id INTEGER PRIMARY KEY, name VARCHAR)")

 >>> store.execute("CREATE TABLE address "
 ... "(id INTEGER PRIMARY KEY, address VARCHAR, person_id INTEGER, "
 ... " FOREIGN KEY(person_id) REFERENCES person(id))")

 >>> person = Person()
 >>> person.name = u'person'
 >>> print person

 >>> print "%r, %r" % (person.id, person.name)
 None, u'person' # Notice that person.id is None since the Person instance is not attached to a valid database store yet.
 >>> store.add(person)
 >>>
 >>> print "%r, %r" % (person.id, person.name)
 None, u'person' # Since the store hasn't flushed the Person instance into the sqlite database yet, person.id is still None.
 >>> store.flush()
 >>> print "%r, %r" % (person.id, person.name)
 1, u'person' # Now the store has flushed the Person instance, we got an id value for person.
 >>> address = Address()
 >>> address.person = person
 >>> address.address = 'address'
 >>> print "%r, %r, %r" % (address.id, address.person, address.address)
 None, , 'address'
 >>> address.person == person
 True
 >>> store.add(address)
 >>>
 >>> store.flush()
 >>> print "%r, %r, %r" % (address.id, address.person, address.address)
 1, , 'address'

To get or retrieve the inserted Person and Address objects, we call store.find() to find them:

 >>> person = store.find(Person, Person.name == u'person').one()
 >>> print "%r, %r" % (person.id, person.name)
 1, u'person'
 >>> store.find(Address, Address.person == person).one()

 >>> address = store.find(Address, Address.person == person).one()
 >>> print "%r, %r" % (address.id, address.address)
 1, u'address'