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

Question

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 Python en el back-end.Entonces, realmente necesito algo rápido y liviano en el back-end que pueda implementar usando Python que luego se comunique con la base de datos PostgreSQL a través de un ORM (JSON para el navegador).

También estoy mirando 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 funcionalidades, velocidad, eficiencia, etc.?

Answer 1

SQLAlchemy tiene más funciones y es más 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é acerca de las diferencias de rendimiento.

SQLAlchemy también tiene una capa declarativa eso esconde 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". Es lo suficientemente desacoplado como para que pueda usar el ORM si 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

Si busca algo liviano y ya está familiarizado con los modelos declarativos 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')

Comprobar el documentos para más ejemplos.

Answer 3

Tormenta 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 sencillo acceder a SQL sin formato cuando sea necesario:

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

Answer 4

Yo suelo usar SQLAlquimia.Es bastante poderoso y probablemente sea el ORM de Python más maduro.

Si planeas usar CherryPy, también puedes considerar deja Vu como lo es Robert Brewer (el tipo que es el actual líder del proyecto CherryPy).Personalmente no lo he usado, pero conozco a algunas personas a las que les encanta.

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

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

Answer 5

SQLAlquimia declarativo La extensión, 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 perfectamente con 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 6

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

Answer 7

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 Deja Vu implementa el patrón DataMapper de Martin Fowler de forma bastante abstracta en Python.

Answer 8

Creo que podrías mirar:

Otoño

Tormenta

Answer 9

No hay forma concebible de que las funciones no utilizadas en Django supongan una penalización en el rendimiento.Podría resultar útil si alguna vez decide ampliar el proyecto.

Answer 10

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.

Answer 11

Utilicé Storm + SQLite para un proyecto pequeño y estaba bastante satisfecho con él hasta que agregué el multiprocesamiento.Al intentar utilizar la base de datos desde varios procesos se produjo la excepción "La base de datos está bloqueada".Cambié a SQLAlchemy y el mismo código funcionó sin problemas.

Answer 12

yo comprobaría SQLAlquimia

Es realmente fácil de usar y los modelos con los que trabajas no están nada mal. Django usa SQLAlchemy para su ORM pero usarlo solo te permite utilizar toda su potencia.

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

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