Quais são algumas boas soluções de ORM Python? [fechadas]

Estou avaliando e analisando o uso do CherryPy para um projeto que é basicamente um front-end JavaScript do lado do cliente (navegador) que fala com um serviço da Web Python no back-end. Então, eu realmente preciso de algo rápido e leve no back-end que possa implementar usando o Python que, em seguida, fala com o PostgreSQL DB através de um ORM (JSON para o navegador).

Também estou olhando para o Django, do qual gosto, já que o ORM está embutido. No entanto, acho que o Django pode ser um pouco mais do que realmente preciso (ou seja, mais recursos do que realmente preciso == mais lento?).

Alguém tem alguma experiência com diferentes soluções Python ORM que podem comparar e contrastar seus recursos e funcionalidades, velocidade, eficiência etc.?

SQLAlchemy é mais completo e poderoso (usa o padrão DataMapper). O Django ORM possui uma sintaxe mais limpa e é mais fácil de escrever (padrão ActiveRecord). Eu não sei sobre diferenças de desempenho.

O SQLAlchemy também possui uma camada declarativa que oculta alguma complexidade e fornece uma sintaxe no estilo ActiveRecord mais semelhante ao Django ORM.

Eu não me preocuparia com o Django ser "muito pesado". Ele está suficientemente dissociado para que você possa usar o ORM, se desejar, sem precisar importar o restante .

Dito isto, se eu já estivesse usando o CherryPy para a camada da web e apenas precisasse de um ORM, provavelmente optaria pelo SQLAlchemy.

Se você está procurando um modelo leve e já conhece os modelos declarativos no estilo django, confira peewee: https://github.com/coleifer/peewee

Exemplo:

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 os documentos para mais exemplos.

Storm tem sem dúvida a API mais simples:

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

E torna indolor cair no SQL bruto quando você precisa:

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

Eu costumo usar SQLAlchemy . É bastante poderoso e é provavelmente o ORM python mais maduro.

Se você planeja usar o CherryPy, também pode investigar o dejavu, como é de Robert Brewer (o atual líder do projeto CherryPy). Eu pessoalmente não o usei, mas conheço algumas pessoas que o amam.

SQLObject é um pouco mais fácil de usar ORM do que SQLAlchemy, mas não é tão poderoso.

Pessoalmente, eu não usaria o Django ORM a menos que estivesse planejando escrever o projeto inteiro no Django, mas sou apenas eu.

A extensão declarativa do SQLAlchemy , que está se tornando padrão em 0,5, fornece uma interface tudo em um muito parecida com a do Django ou Storm. Ele também se integra perfeitamente às classes / tabelas configuradas usando o 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()

Usamos o Elixir ao lado do SQLAlchemy e gostamos até agora. O Elixir coloca uma camada em cima do SQLAlchemy que faz com que pareça mais com as contrapartes do "padrão ActiveRecord".

Esse parece ser o ponto de referência canônico para a interação de banco de dados de alto nível no Python: http://wiki.python.org/moin/HigherLevelDatabaseProgramming

A partir daí, parece que Dejavu implementa o padrão DataMapper de Martin Fowler de maneira bastante abstrata em Python.

Eu acho que você pode olhar para:

Outono

Tempestade

Não há maneira concebível de os recursos não utilizados no Django darem uma penalidade no desempenho. Pode ser útil se você decidir melhorar o projeto.

Usei o Storm + SQLite para um projeto pequeno e fiquei muito feliz com isso até adicionar o multiprocessamento. Tentar usar o banco de dados de vários processos resultou em uma exceção "O banco de dados está bloqueado". Eu mudei para SQLAlchemy e o mesmo código funcionou sem problemas.

SQLAlchemy é muito, muito poderoso. No entanto, não é seguro para threads. Lembre-se disso ao trabalhar com cherrypy no modo pool de threads.

Gostaria de verificar SQLAlchemy

É realmente fácil de usar e os modelos com os quais você trabalha não são ruins. O Django usa SQLAlchemy para seu ORM mas usá-lo por si só permite usar sua potência total.

Aqui está um pequeno exemplo de criação e seleção de 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')>