¿Cuáles son algunas buenas soluciones ORM de Python?

Estoy evaluando y buscando usar CherryPy para un proyecto que es básicamente un front-end de JavaScript desde el lado del cliente (navegador) que habla con un servicio web de Python en el back-end. Entonces, realmente necesito algo rápido y ligero en el back-end que pueda implementar utilizando Python que luego habla a la base de datos PostgreSQL a través de un ORM (JSON al navegador).

También estoy mirando a Django, que me gusta, ya que su ORM está integrado. Sin embargo, creo que Django podría ser un poco más de lo que realmente necesito (es decir, más funciones de las que realmente necesito == más lento).

¿Alguien tiene alguna experiencia con diferentes soluciones ORM de Python que puedan comparar y contrastar sus características y funcionalidad, velocidad, eficiencia, etc.?

SQLAlchemy es más completo y potente (usa el patrón DataMapper). Django ORM tiene una syntax más limpia y es más fácil escribir para (patrón ActiveRecord). No sé acerca de las diferencias de rendimiento.

SQLAlchemy también tiene una capa declarativa que oculta cierta complejidad y le da una syntax de estilo ActiveRecord más similar a la ORM de Django.

No me preocuparía que Django fuera “demasiado pesado”. Se ha desacoplado lo suficiente como para poder utilizar el ORM si lo desea sin tener que importar el rest.

Dicho esto, si ya estuviera usando CherryPy para la capa web y solo necesitara un ORM, probablemente optaría por SQLAlchemy.

Si busca peso ligero y ya está familiarizado con los modelos declarativos de estilo django, consulte peewee: https://github.com/coleifer/peewee

Ejemplo:

 import datetime from peewee import * class Blog(Model): name = CharField() class Entry(Model): blog = ForeignKeyField(Blog) title = CharField() body = TextField() pub_date = DateTimeField(default=datetime.datetime.now) # query it like django Entry.filter(blog__name='Some great blog') # or programmatically for finer-grained control Entry.select().join(Blog).where(Blog.name == 'Some awesome blog') 

Compruebe la documentación para más ejemplos.

Storm tiene posiblemente la API más simple:

  from storm.locals import * class Foo: __storm_table__ = 'foos' id = Int(primary=True) class Thing: __storm_table__ = 'things' id = Int(primary=True) name = Unicode() description = Unicode() foo_id = Int() foo = Reference(foo_id, Foo.id) db = create_database('sqlite:') store = Store(db) foo = Foo() store.add(foo) thing = Thing() thing.foo = foo store.add(thing) store.commit() 

Y hace que sea indoloro desplegar en SQL sin formato cuando necesita:

 store.execute('UPDATE bars SET bar_name=? WHERE bar_id like ?', []) store.commit() 

Suelo usar SQLAlchemy . Es bastante potente y es probablemente el ORM de python más maduro.

Si planea usar CherryPy, también puede buscar en dejavu, ya que es de Robert Brewer (el tipo que es el líder actual del proyecto CherryPy). Personalmente no lo he usado, pero conozco a algunas personas que lo aman.

SQLObject es un poco más fácil de usar ORM que SQLAlchemy, pero no es tan poderoso.

Personalmente, no usaría el ORM de Django a menos que estuviera planeando escribir todo el proyecto en Django, pero eso es solo yo.

La extensión declarativa de SQLAlchemy, que se está convirtiendo en estándar en 0.5, proporciona una interfaz muy parecida a la de Django o Storm. También se integra a la perfección con las clases / tablas configuradas usando el estilo de intercambio de datos:

 Base = declarative_base() class Foo(Base): __tablename__ = 'foos' id = Column(Integer, primary_key=True) class Thing(Base): __tablename__ = 'things' id = Column(Integer, primary_key=True) name = Column(Unicode) description = Column(Unicode) foo_id = Column(Integer, ForeignKey('foos.id')) foo = relation(Foo) engine = create_engine('sqlite://') Base.metadata.create_all(engine) # issues DDL to create tables session = sessionmaker(bind=engine)() foo = Foo() session.add(foo) thing = Thing(name='thing1', description='some thing') thing.foo = foo # also adds Thing to session session.commit() 

Usamos Elixir junto con SQLAlchemy y nos ha gustado hasta ahora. Elixir coloca una capa encima de SQLAlchemy que hace que se parezca más a las partes contrarias del “patrón ActiveRecord”.

Este parece ser el punto de referencia canónico para la interacción de bases de datos de alto nivel en Python: http://wiki.python.org/moin/HigherLevelDatabaseProgramming

Desde allí, parece que Dejavu implementa el patrón DataMapper de Martin Fowler de manera bastante abstracta en Python.

Creo que puedes mirar:

Otoño

Tormenta

No hay una forma concebible de que las características no utilizadas en Django den una penalización de rendimiento. Podría ser útil si alguna vez decide mejorar el proyecto.

SQLAlchemy es muy, muy poderoso. Sin embargo, no es seguro para subprocesos, asegúrese de tenerlo en cuenta cuando trabaje con cherrypy en el modo de agrupación de subprocesos.

Utilicé Storm + SQLite para un proyecto pequeño, y me sentí muy feliz con él hasta que agregué multiprocesamiento. Al intentar usar la base de datos de varios procesos, se produjo una excepción de “La base de datos está bloqueada”. Cambié a SQLAlchemy, y el mismo código funcionó sin problemas.

Me gustaría echar un vistazo a SQLAlchemy

Es realmente fácil de usar y los modelos con los que trabajas no son malos en absoluto. Django usa SQLAlchemy para su ORM, pero usarlo solo le permite usar todo su poder.

Aquí hay un pequeño ejemplo de cómo crear y seleccionar objetos orm.

 >>> ed_user = User('ed', 'Ed Jones', 'edspassword') >>> session.add(ed_user) >>> our_user = session.query(User).filter_by(name='ed').first() >>> our_user