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

Question

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

Answer 1

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.

Answer 2

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.

Answer 3

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

Answer 4

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.

Answer 5

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

Answer 6

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

Answer 7

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.

Answer 8

Acho que você pode dar uma olhada em:

Outono

Tempestade

Answer 9

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.

Answer 10

SQLAlchemy é muito, muito poderoso.No entanto, não é thread-safe, lembre-se disso ao trabalhar com cherrypy no modo thread-pool.

Answer 11

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.

Answer 12

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