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

Question

Estoy evaluando y analizando el uso de CherryPy para un proyecto que básicamente es un front-end de JavaScript desde el lado del cliente (navegador) que habla con un servicio web de Python en el back-end. Por lo tanto, realmente necesito algo rápido y liviano en el back-end que pueda implementar usando Python que luego se dirige al DB de PostgreSQL a través de un ORM (JSON para el navegador).

También estoy mirando a Django, que me gusta, ya que su ORM está incorporado. 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 pueden comparar y contrastar sus características y funcionalidad, velocidad, eficiencia, etc.?

Answer 1

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

SQLAlchemy también tiene un declarative layer que oculta cierta complejidad y le da una sintaxis de estilo ActiveRecord más similar al ORM de Django.

No me preocuparía que Django sea "demasiado pesado". Está desacoplado lo suficiente como para poder usar el ORM si lo desea sin tener que importar el resto.

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

Answer 2

creo que lo podría hacer en:

Autumn

Storm

Answer 3

Me echa un vistazo a SQLAlchemy

Es muy fácil de usar y los modelos con los que trabaja no son malos en absoluto. Django usa SQLAlchemy porque es ORM pero usarlo solo le permite usar su potencia máxima.

He aquí 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 
    <User('ed','Ed Jones', 'edspassword')> 

Answer 4

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

Si está planeando usar CherryPy, también puede consultar dejavu como es de Robert Brewer (el hombre 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 que el SQLAlchemy ORM, 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 así soy yo.

Answer 5

Utilizamos Elixir junto a SQLAlchemy y nos ha gustado hasta ahora. Elixir pone una capa encima de SQLAlchemy que hace que se parezca más a las partes del contador "Patrón de ActiveRecord".

Answer 6

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

Answer 7

Storm tiene posiblemente la API 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 es un sencillo programa para caer hacia abajo en SQL crudo cuando es necesario:

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

Answer 8

declarative extensión de SQLAlchemy, que se está convirtiendo en habitual en 0.5, proporciona una interfaz todo en uno muy similar a la de Django o Storm. También se integra a la perfección con las clases/tablas configuradas usando el estilo DataMapper:

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() 

Answer 9

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 grupo de subprocesos.

Answer 10

Utilicé Storm + SQLite para un proyecto pequeño y estuve muy contento con él hasta que agregué el multiprocesamiento. Intentar usar la base de datos de múltiples procesos resultó en una excepción "La base de datos está bloqueada". Cambié a SQLAlchemy, y el mismo código funcionó sin problemas.

Answer 11

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

A partir de ahí, parece que implementa el patrón Dejavu DataMapper de Martin Fowler bastante abstracto en Python.

Answer 12

Si lo que buscas es ligero y ya están familiarizados con los modelos declarativos de estilo Django, echa un vistazo a 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 el docs para más ejemplos.