Quais são algumas boas soluções Python ORM?[fechado]
Pergunta
Estou avaliando e pensando em usar o CherryPy para um projeto que é basicamente um front-end JavaScript do lado do cliente (navegador) que se comunica com um serviço web Python no back-end.Então, eu realmente preciso de algo rápido e leve no back-end que possa implementar usando Python e que se comunique com o banco de dados PostgreSQL por meio de um ORM (JSON para o navegador).
Também estou olhando para o Django, do qual gosto, já que seu ORM está integrado.No entanto, acho que o Django pode ser um pouco mais do que eu realmente preciso (ou seja,mais recursos do que eu 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.?
Solução
SQLAlchemy é mais completo e poderoso (usa o padrão DataMapper).Django ORM tem uma sintaxe mais limpa e é mais fácil de escrever (padrão ActiveRecord).Não sei sobre diferenças de desempenho.
SQLAlchemy também tem um camada declarativa que esconde alguma complexidade e fornece uma sintaxe no estilo ActiveRecord mais semelhante ao Django ORM.
Eu não me preocuparia com o Django "muito pesado". É dissociado o suficiente para que você possa usar o ORM se quiser sem precisar importar o resto.
Dito isso, se eu já estivesse usando o CherryPy para a camada web e precisasse apenas de um ORM, provavelmente optaria pelo SQLAlchemy.
Outras dicas
Se você está procurando algo leve e já está familiarizado com modelos declarativos no estilo Django, dê uma olhada 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')
Verifica a documentos para mais exemplos.
Tempestade 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 mais fácil entrar no SQL bruto quando você precisa:
store.execute('UPDATE bars SET bar_name=? WHERE bar_id like ?', [])
store.commit()
Eu costumo usar SQLAlquimia.É muito poderoso e é provavelmente o ORM python mais maduro.
Se você está planejando usar o CherryPy, você também pode dar uma olhada em déjà vu já que é de Robert Brewer (o cara que é o atual líder do projeto CherryPy).Eu pessoalmente não usei, mas conheço algumas pessoas que adoram.
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 em Django, mas sou só eu.
SQLAlchemy's declarativo extensão, que está se tornando padrão no 0.5, fornece uma interface completa muito parecida com a do Django ou Storm.Ele também se integra perfeitamente com 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()
Nós usamos Elixir junto com SQLAlchemy e gostei até agora.Elixir coloca uma camada sobre o SQLAlchemy que o faz parecer mais com as contrapartes do "padrão ActiveRecord".
Este parece ser o ponto de referência canônico para interação de banco de dados de alto nível em Python:http://wiki.python.org/moin/HigherLevelDatabaseProgramming
A partir daí, parece Déjávu implementa o padrão DataMapper de Martin Fowler de forma bastante abstrata em Python.
Não há nenhuma maneira concebível de que os recursos não utilizados no Django causem uma penalidade no desempenho.Pode ser útil se você decidir aprimorar o projeto.
SQLAlchemy é muito, muito poderoso.No entanto, não é thread-safe, lembre-se disso ao trabalhar com cherrypy no modo thread-pool.
Usei Storm + SQLite para um projeto pequeno e fiquei muito feliz com ele até adicionar o multiprocessamento.A tentativa de usar o banco de dados de vários processos resultou em uma exceção "Banco de dados bloqueado".Mudei para SQLAlchemy e o mesmo código funcionou sem problemas.
eu verificaria SQLAlquimia
É muito fácil de usar e os modelos com os quais você trabalha não são nada ruins. Django usa SQLAlchemy para seu ORM mas usá-lo sozinho permite que você use todo o seu poder.
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')>