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

210

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

También estoy viendo 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.?

eLuke
fuente
ponyORM se ve muy bien.
Niklas R
El mapeo relacional de objetos (ORM) ya es muy popular en muchos lenguajes de programación y es una de las mejores alternativas para SQL. Me inspiré en el estilo de encadenamiento de métodos para crear CQL para mi proyecto TRIADB. healis.eu/triadb/#latest-release
Athanassios

Respuestas:

96

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 (patrón ActiveRecord). No sé sobre las diferencias de rendimiento.

SQLAlchemy también tiene una capa declarativa 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á lo suficientemente desacoplado para que pueda 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.

Carl Meyer
fuente
77
Pero si no le gusta el ORM de Django y desea usar SA, por ejemplo, pierde muchas de las funciones de django, como admin. No es un factor decisivo, sino una rodilla desollada.
Gregg Lind
22
Cierto, pero irrelevante para la pregunta, que era simplemente acerca de elegir un ORM de Python; no se trata de interfaces de administración generadas automáticamente u otros componentes del marco.
Carl Meyer
8
Yo diría que SQLAlchemy es cualquier cosa menos ligero, aunque puede ser bastante rápido. Lanzaré mi proyecto en la mezcla, se llama peewee y habla con postgres. ¡Recientemente también se agregó soporte para consultas de estilo django! charlesleifer.com/docs/peewee
coleifer
3
Tenga en cuenta también que Django ORM no admite las claves principales compuestas y SQLAlchemy lo admite.
Marcin Kapusta
1
@yegle Estoy confundido por tu comentario. No entiendo la lógica. ¿Cómo implica "difícil de encontrar instrucciones ORDER BY DESCen los documentos" implica "malo para el patrón de registro activo"?
jpmc26
108

Si está buscando peso ligero y ya está familiarizado con los modelos declarativos de estilo django, eche 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')

Consulte los documentos para obtener más ejemplos.

coleifer
fuente
me pueden ayudar para esta pregunta? Pls ru.stackoverflow.com/q/1114189/293323
Cookie
81

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 fácil desplegarse en SQL sin formato cuando necesita:

store.execute('UPDATE bars SET bar_name=? WHERE bar_id like ?', []) 
store.commit()
Patricio
fuente
Cabe señalar que Storm solo es compatible con MySQL y PostgreSQL en este momento. Sin embargo, el soporte de Oracle está en proceso.
Jason Baker, el
15
También es compatible con SQLite como sugiere el ejemplo anterior
shearichard
2
quick_orm es tan simple como Storm y se basa en SQLAlchemy, por lo que también es muy potente: pypi.python.org/pypi/quick_orm . Descargo de responsabilidad: soy el autor de quick_orm
Tyler Long
8
La tormenta no está mantenida. No lo usaría para nuevos proyectos.
Matthias Urlichs
3
Además, parece que no hay Storm para Python 3
ygormutti
27

Usualmente uso SQLAlchemy . Es bastante poderoso y es probablemente el ORM python más maduro.

Si está planeando usar CherryPy, también puede considerar dejavu como lo hizo Robert Brewer (el tipo que es el actual líder 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 Django ORM a menos que estuviera planeando escribir todo el proyecto en Django, pero solo soy yo.

Jason Baker
fuente
¡SQLObject es genial: fácil de usar, independiente de la base de datos y puede hacer las tablas por usted! (Soy perezoso).
Lucas Jones
1
@Lucas - Entonces SQLAlchemy ...
Jason Baker el
Hasta donde puedo recordar, en general solo estaba cumpliendo con SQLObject. Sin embargo, fue hace mucho tiempo ... :)
Lucas Jones
@Lucas - Me imaginé como tal. Solo pensé en tomar nota de ello. :-)
Jason Baker
17

La extensión declarativa de SQLAlchemy , que se está convirtiendo en estándar en 0.5, proporciona una interfaz todo en uno muy parecida a la de Django o Storm. También se integra a la perfección con clases / tablas configuradas utilizando el estilo de mapa 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()
zzzeek
fuente
Pero las cosas se vuelven muy complejas si hay muchas relaciones como one_to_many, many_to_many, herencia de tablas. Tienes que escribir mucho código a mano para poder manejarlos. Verifique mi respuesta para ORM rápido. Puede ahorrarte tiempo.
Tyler Long
18
:) en Tyler diciéndole al creador de SQLAlchemy que debería usar Quick ORM.
Anthony Briggs
55
:) Me recuerda a alguien hace años en usenet discutiendo con dmr @ alice que realmente no entendía C.
Peter Rowell
@AnthonyBriggs, revise esta diapositiva y verá por qué quick_orm es mejor para manejar relaciones complejas que SQLAlchemy: slideshare.net/tyler4long/quickorm
Tyler Long
10

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

airportyh
fuente
2
SQLAlchemy admite OOP y estilos funcionales listos para usar, Elixir agrega un estilo de programación declarativa (principalmente para declaraciones de modelos, pero se puede ampliar).
muhuk
5

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

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

entropo
fuente
Estaba interesado y miré a Dejavu. Solo un poco. La documentación es muy escasa (qoute "para la capa de presentación que está solo"), por lo que solo diría que para usuarios avanzados.
r4.
1

Creo que podrías mirar:

Otoño

Tormenta

Lukas Šalkauskas
fuente
El otoño es probablemente más fácil que Storm, pero Storm incluye muchas características que Autumn no. Ambas opciones tienen documentación limitada, ¡aunque Storm lo está arreglando tan rápido!
alecwh
Gracias, Autumn se ve muy agradable y atractivo, pero tiene cero documentación, lo que es un factor decisivo para mí.
temoto
1
Acabo de probar algunos de los ejemplos en la página Otoño, y ni siquiera funcionan con la versión del código que instaló mi administrador de paquetes. Las publicaciones en el grupo de google también son antiguas. Parece que el proyecto está muriendo una muerte lenta. No recomendaría usarlo.
Jason Miesionczek
Storm, por otro lado, se está convirtiendo rápidamente en mi ORM de elección. Los documentos están mejorando y la API es limpia y simple, aunque estoy un poco más acostumbrado al patrón ActiveRecord empleado por el Django ORM, encuentro que Storm es fácil de navegar.
Jason Miesionczek
1
Autum no parece tener ninguna actividad durante un año. groups.google.com/group/autumn-orm
Sridhar Ratnakumar
1

No hay forma concebible de que las funciones no utilizadas en Django denuncien el rendimiento. Podría ser útil si alguna vez decides mejorar el proyecto.

Carl Meyer
fuente
8
hay una manera concebible
bukzor
0

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

Phil Loden
fuente
77
Para ser justos, SQLite no está realmente diseñado para accesos concurrentes.
Xiong Chiamiov
2
@Xion +1. SQLITE es un solo archivo, sin demonio ejecutándose.
e-satis
-1

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

Luego
fuente
2
¿Es cierto que SQLAlchemy no es seguro para subprocesos? Entonces, ¿cómo se usa en las aplicaciones Pyramid sobre WSGI, que principalmente las personas implementan en modo roscado? Cualquier confirmación a esta declaración contradictoria.
Ravi Kumar
1
Por supuesto, SQLAlchemy es seguro para subprocesos.
Matthias Urlichs
-7

Verificaría SQLAlchemy

Es realmente fácil de usar y los modelos con los que trabaja no son malos en absoluto. Django usa SQLAlchemy por su ORM pero usarlo por sí solo le permite usar toda su potencia.

Aquí hay un pequeño ejemplo sobre 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')>
Aquél
fuente
18
Django no usa sqlalchemy porque es ORM. Se ha realizado un trabajo para hacer que sqlalchemy sea un ORM opcional, pero no está completo.
sherbang