Quali sono alcune buone soluzioni Python ORM? [chiuso]

Sto valutando e sto cercando di utilizzare CherryPy per un progetto che è fondamentalmente un front-end JavaScript dal lato client (browser) che parla con un servizio web Python sul back-end. Quindi, ho davvero bisogno di qualcosa di veloce e leggero sul back-end che posso implementare usando Python che poi parli al DB PostgreSQL tramite un ORM (JSON al browser).

Sto anche guardando Django, che mi piace, dal momento che il suo ORM è incorporato. Tuttavia, penso che Django potrebbe essere un po 'più di quello di cui ho veramente bisogno (cioè più funzioni di quante ne abbia davvero bisogno == più lento?).

Qualcuno ha esperienza con diverse soluzioni Python ORM in grado di confrontare e confrontare le loro caratteristiche e funzionalità, velocità, efficienza, ecc.?

SQLAlchemy è più completo e potente (utilizza il modello DataMapper). Django ORM ha una sintassi più pulita ed è più facile scrivere per (modello ActiveRecord). Non conosco le differenze di prestazioni.

SQLAlchemy ha anche un livello dichiarativo che nasconde una certa complessità e gli conferisce una sintassi in stile ActiveRecord più simile all'ORM di Django.

Non mi preoccuperei che Django sia "troppo pesante". È abbastanza disaccoppiato che puoi usare l'ORM se vuoi senza dover importare il resto .

Detto questo, se avessi già utilizzato CherryPy per il livello Web e avessi solo bisogno di un ORM, probabilmente avrei optato per SQLAlchemy.

Se cerchi un modello leggero e conosci già i modelli dichiarativi in ​​stile django, dai un'occhiata a peewee: https://github.com/coleifer/peewee

Esempio:

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

Controlla i documenti per altri esempi.

Storm ha probabilmente l'API più semplice:

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 rende indolore cadere in SQL raw quando è necessario:

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

Di solito uso SQLAlchemy . È piuttosto potente ed è probabilmente il più maturo ORM in pitone.

Se stai pensando di utilizzare CherryPy, potresti anche esaminare dejavu in quanto è di Robert Brewer (il ragazzo che è l'attuale capo del progetto CherryPy). Personalmente non l'ho usato, ma conosco alcune persone che lo adorano.

SQLObject è un po 'più semplice da utilizzare ORM rispetto a SQLAlchemy, ma non è altrettanto potente.

Personalmente, non userei Django ORM se non avessi intenzione di scrivere l'intero progetto in Django, ma sono solo io.

L' estensione dichiarativa di SQLAlchemy , che sta diventando standard in 0.5, fornisce un'interfaccia tutto in uno molto simile a quella di Django o Storm. Si integra perfettamente anche con le classi / tabelle configurate utilizzando lo stile 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()

Usiamo Elisir insieme a SQLAlchemy e finora ci è piaciuto. Elisir mette uno strato sopra SQLAlchemy che lo fa sembrare più simile alle controparti "Pattern ActiveRecord".

Questo sembra essere il punto di riferimento canonico per l'interazione di database di alto livello in Python: http://wiki.python.org/moin/HigherLevelDatabaseProgramming

Da lì, sembra che Dejavu implementa il pattern DataMapper di Martin Fowler in modo abbastanza astratto in Python.

Penso che potresti guardare:

Autunno

Tempesta

Non è plausibile che le funzionalità inutilizzate di Django penalizzino le prestazioni. Potrebbe tornare utile se decidi di migliorare il progetto.

Ho usato Storm + SQLite per un piccolo progetto e ne sono rimasto abbastanza soddisfatto fino a quando non ho aggiunto il multiprocessing. Il tentativo di utilizzare il database da più processi ha comportato un'eccezione "Il database è bloccato". Sono passato a SQLAlchemy e lo stesso codice ha funzionato senza problemi.

SQLAlchemy è molto, molto potente. Tuttavia, non è sicuro per i thread, assicurati di tenerlo presente quando lavori con cherrypy in modalità pool di thread.

Darei un'occhiata a SQLAlchemy

È davvero facile da usare e i modelli con cui lavori non sono affatto male. Django utilizza SQLAlchemy per il suo ORM ma usarlo da solo ti consente di sfruttare tutta la sua potenza.

Ecco un piccolo esempio sulla creazione e selezione di oggetti 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')>