Jakie są dobre rozwiązania ORM Pythona? [Zamknięte]

Oceniam i patrzę na użycie CherryPy dla projektu, który jest w zasadzie interfejsem JavaScript po stronie klienta (przeglądarki), który komunikuje się z usługą internetową Python na zapleczu. Tak więc naprawdę potrzebuję czegoś szybkiego i lekkiego na zapleczu, które mogę wdrożyć za pomocą Pythona, który następnie komunikuje się z bazą danych PostgreSQL za pośrednictwem ORM (JSON do przeglądarki).

Patrzę też na Django, które mi się podoba, ponieważ jego ORM jest wbudowany. Myślę jednak, że Django może być trochę więcej niż naprawdę potrzebuję (tj. Więcej funkcji niż naprawdę potrzebuję == wolniej?).

Czy ktoś ma jakieś doświadczenie z różnymi rozwiązaniami Python ORM, które mogą porównywać i kontrastować ich funkcje i funkcje, szybkość, wydajność itp.?

SQLAlchemy jest bardziej w pełni funkcjonalny i potężny (wykorzystuje wzorzec DataMapper). Django ORM ma czystszą składnię i łatwiej jest pisać (wzorzec ActiveRecord). Nie wiem o różnicach wydajności.

SQLAlchemy ma również warstwę deklaratywną, która ukrywa pewną złożoność i nadaje jej składnię w stylu ActiveRecord bardziej podobną do Django ORM.

Nie martwiłbym się, że Django będzie „zbyt ciężki”. Jest na tyle oddzielony, że możesz użyć ORM, jeśli chcesz, bez konieczności importowania reszty .

To powiedziawszy, jeśli już korzystałem z CherryPy dla warstwy internetowej i potrzebowałem tylko ORM, prawdopodobnie wybrałbym SQLAlchemy.

Jeśli szukasz lekkości i znasz już modele deklaratywne w stylu django, sprawdź peewee: https://github.com/coleifer/peewee

Przykład:

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

Sprawdź dokumenty, aby uzyskać więcej przykładów.

Storm ma prawdopodobnie najprostszy interfejs API:

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

I sprawia, że ​​bezbolesne jest wpadanie do surowego SQL, gdy trzeba:

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

Zwykle używam SQLAlchemy . Jest dość potężny i jest prawdopodobnie najbardziej dojrzałym ORM-em Pythona.

Jeśli planujesz używać CherryPy, możesz również zajrzeć do dejavu, ponieważ jest to Robert Brewer (facet, który jest obecnie kierownikiem projektu CherryPy). Osobiście nie korzystałem z niego, ale znam kilka osób, które to uwielbiają.

SQLObject jest nieco łatwiejszy w użyciu ORM niż SQLAlchemy, ale nie jest tak potężny.

Osobiście nie używałbym Django ORM, chyba że planowałem napisać cały projekt w Django, ale to tylko ja.

Deklaratywne rozszerzenie SQLAlchemy , które staje się standardem w wersji 0.5, zapewnia interfejs typu „wszystko w jednym” bardzo podobny do interfejsu Django lub Storm. Bezproblemowo integruje się również z klasami / tabelami skonfigurowanymi za pomocą stylu 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()

Używamy Elixir wraz z SQLAlchemy i do tej pory nam się podobało. Elixir nakłada warstwę na SQLAlchemy, dzięki czemu wygląda bardziej jak części licznika „wzorzec ActiveRecord”.

To wydaje się być kanonicznym punktem odniesienia dla interakcji z bazą danych wysokiego poziomu w Pythonie: http://wiki.python.org/moin/HigherLevelDatabaseProgramming

Stąd wygląda na to, że Dejavu implementuje wzorzec DataMapper Martina Fowlera dość abstrakcyjnie w Pythonie.

Myślę, że możesz spojrzeć na:

Jesień

Burza

Nie ma możliwego sposobu, aby nieużywane funkcje w Django spowodowały spadek wydajności. Może się przydać, jeśli kiedykolwiek zdecydujesz się na ulepszenie projektu.

Użyłem Storm + SQLite do małego projektu i byłem z niego bardzo zadowolony, dopóki nie dodałem wieloprocesowości. Próba użycia bazy danych z wielu procesów spowodowała wyjątek „Baza danych jest zablokowana”. Przełączyłem się na SQLAlchemy i ten sam kod działał bez żadnych problemów.

SQLAlchemy jest bardzo, bardzo potężny. Jednak nie jest to bezpieczne dla wątków, pamiętaj o tym podczas pracy z Cherrypy w trybie puli wątków.

Sprawdziłbym SQLAlchemy

Jest naprawdę łatwy w użyciu, a modele, z którymi pracujesz, wcale nie są złe. Django używa SQLAlchemy do ORM, ale użycie go samo w sobie pozwala na wykorzystanie jego pełnej mocy.

Oto mały przykład tworzenia i wybierania obiektów 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')>