python - para - sqlalchemy documentation

¿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á 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 pueden comparar y contrastar sus características y funcionalidad, velocidad, eficiencia, etc.?

Answer 1

Creo que podrías mirar:

Autumn

Storm

Answer 2

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 bastante abstracto en Python.

Answer 3

La extensión declarative de SQLAlchemy, que se está convirtiendo en estándar 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 con el estilo de mapeo 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()

Answer 4

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 5

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 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á 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 6

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 7

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

Verifique los docs para más ejemplos.

Answer 8

Usé Storm + SQLite para un proyecto pequeño, y estaba 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 9

Usamos Elixir junto con 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 10

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

Si planeas usar CherryPy, también podrías considerar el dejavu como lo hace Robert Brewer (el hombre 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 que ORM SQLAlchemy, pero no es tan poderoso.

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

Answer 11

Verificaría SQLAlchemy

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

Answer 12

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 sencillo bajar al SQL sin formato cuando necesita:

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