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

209

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.?

eLuke
fonte
ponyORM parece bem legal.
Niklas R
O mapeamento objeto-relacional (ORM) já é muito popular em muitas linguagens de programação e uma das melhores alternativas para SQL. Fui inspirado no estilo de encadeamento de métodos para criar CQL para o meu projeto TRIADB. healis.eu/triadb/#latest-release
Athanassios

Respostas:

96

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.

Carl Meyer
fonte
7
Mas se você não gosta do ORM do Django e deseja usar o SA, por exemplo, perde muitos recursos do django, como admin. Não é um problema, mas um joelho esfolado.
Gregg Lind
22
É verdade, mas irrelevante para a pergunta, que era simplesmente sobre escolher um ORM do Python; não sobre interfaces administrativas geradas automaticamente ou outros componentes da estrutura.
2411 Carl Meyer
8
Eu diria que o SQLAlchemy é tudo menos leve - mas pode ser bem rápido. Vou jogar meu projeto na mistura, ele se chama peewee e fala com o postgres. Recentemente, também foi adicionado suporte para consultas no estilo django! charlesleifer.com/docs/peewee
coleifer
3
Observe também que o Django ORM não suporta as chaves primárias compostas e SQLAlchemy.
Marcin Kapusta 12/09/2013
1
@ yegle Estou confuso com o seu comentário. Eu não entendo a lógica. Como "difícil encontrar instruções ORDER BY DESCnos documentos" implica "padrão de registro ativo ruim"?
precisa saber é o seguinte
108

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.

coleifer
fonte
você pode me ajudar com esta pergunta? Pls ru.stackoverflow.com/q/1114189/293323
Cookie
81

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()
Patrick
fonte
Note-se que o Storm suporta apenas MySQL e PostgreSQL no momento atual. O suporte da Oracle está em andamento.
6309 Jason Baker
15
É também suporta SQLite como o exemplo acima sugere
shearichard
2
quick_orm é tão simples quanto o Storm e é baseado no SQLAlchemy, portanto também é muito poderoso: pypi.python.org/pypi/quick_orm . Disclaimer: Eu sou o autor de quick_orm
Tyler Longo
8
A tempestade não é mantida. Eu não o usaria para novos projetos.
Matthias Urlichs
3
Além disso, parece que não há nenhuma tempestade para Python 3
ygormutti
27

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.

Jason Baker
fonte
O SQLObject é ótimo - simples de usar, independente de banco de dados e pode realmente criar as tabelas para você! (Sou preguiçosa).
Lucas Jones
1
@Lucas - O mesmo pode acontecer com SQLAlchemy ...
Jason Baker
Tanto quanto me lembro, geralmente elogiava o SQLObject. Foi há muito tempo, embora ... :)
Lucas Jones
@ Lucas - eu imaginei como tal. Apenas pensei em fazer uma anotação. :-)
Jason Baker
17

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()
zzzeek
fonte
Mas as coisas se tornam muito complexas se houver muitos relacionamentos, como herança de tabela one_to_many, many_to_many. Você precisa escrever muito código manualmente para lidar com eles. Verifique minha resposta para o Quick ORM. Isso pode economizar seu tempo.
Tyler Longo
18
:) em Tyler dizendo ao criador do SQLAlchemy que ele deveria usar o Quick ORM.
Anthony Briggs
5
:) me lembra alguém anos atrás na discussão da Usenet com dmr @ alice que ele realmente não entendo C.
Peter Rowell
@AnthonyBriggs, verifique este deslize e você verá porque quick_orm é melhor em lidar com complexas relações de SQLAlchemy: slideshare.net/tyler4long/quickorm
Tyler Longo
10

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".

airportyh
fonte
2
SQLAlchemy suporta OOP e estilos funcionais prontos para uso, o Elixir adiciona um estilo de programação declarativo (principalmente para declarações de modelo, mas pode ser estendido) sobre ele.
22468 muhuk
5

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.

entropo
fonte
Eu estava interessado e olhei para Dejavu. Só um pouco. A documentação é muito escassa (qoute "para a camada de apresentação você está por sua conta"); portanto, apenas para usuários avançados, eu diria.
r4.
1

Eu acho que você pode olhar para:

Outono

Tempestade

Lukas Šalkauskas
fonte
O outono é provavelmente mais fácil que o Storm, mas o Storm inclui muitos recursos que o Autumn não. Ambas as opções têm documentação limitada, embora o Storm esteja corrigindo tão rápido!
9139 alecwh
Obrigado, Autumn parece muito bonito e atraente, mas não possui documentação, o que é um diferencial para mim.
precisa saber é o seguinte
1
Eu apenas tentei alguns dos exemplos na página do outono e eles nem funcionam com a versão do código que meu gerenciador de pacotes instalou. As postagens no grupo do Google também são antigas. Parece que o projeto está morrendo lentamente. Não recomendaria usá-lo.
Jason Miesionczek
Storm, por outro lado, está rapidamente se tornando minha ORM de escolha. Os documentos estão melhorando e a API é limpa e simples, embora eu esteja um pouco mais acostumado com o padrão ActiveRecord empregado pelo Django ORM, acho o Storm fácil de navegar.
Jason Miesionczek
1
Autum parece não ter atividade por um ano. groups.google.com/group/autumn-orm
Sridhar Ratnakumar
1

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.

Carl Meyer
fonte
8
há uma concievable maneira
bukzor
0

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.

Phil Loden
fonte
7
Para ser justo, o SQLite não é realmente projetado para acessos simultâneos.
Xiong Chiamiov 31/03
2
@Xion +1. SQLITE é um único arquivo, sem daemon em execução.
e-satis
-1

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

Anon
fonte
2
é verdade que SQLAlchemy não é seguro para threads? Então, como é usado nos aplicativos Pyramid sobre WSGI, que principalmente as pessoas implantam no modo encadeado? Qualquer confirmação desta afirmação contraditória.
Ravi Kumar
1
É claro que o SQLAlchemy é seguro para threads.
Matthias Urlichs
-7

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')>
Yon
fonte
18
O Django não usa sqlalchemy para seu ORM. Houve algum trabalho feito para tornar o sqlalchemy um ORM opcional, mas não está completo.
sherbang 11/09/08