Quali sono alcune buone soluzioni ORM Python?[Chiuso]

Question

Sto valutando e valutando l'utilizzo di CherryPy per un progetto che è fondamentalmente un front-end JavaScript dal lato client (browser) che comunica con un servizio web Python sul back-end.Quindi, ho davvero bisogno di qualcosa di veloce e leggero nel back-end che posso implementare utilizzando Python che poi parli con il DB PostgreSQL tramite un ORM (JSON per il browser).

Sto anche guardando Django, che mi piace, poiché il suo ORM è integrato.Tuttavia, penso che Django potrebbe essere un po' più di quello di cui ho realmente bisogno (ad es.più funzionalità di quelle di cui ho realmente bisogno == più lento?).

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

Answer 1

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

SQLAlchemy ha anche un file strato dichiarativo questo nasconde una certa complessità e gli conferisce una sintassi in stile ActiveRecord più simile a Django ORM.

Non mi preoccuperei che Django sia "troppo pesante". È abbastanza disaccoppiato da poter usare l'ORM se si desidera senza dover importare il resto.

Detto questo, se stessi già utilizzando CherryPy per il livello web e avessi solo bisogno di un ORM, probabilmente opterei per SQLAlchemy.

Answer 2

Se stai cercando leggerezza e hai già familiarità con 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 il documenti per ulteriori esempi.

Answer 3

Tempesta 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 il passaggio all'SQL grezzo quando è necessario:

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

Answer 4

Di solito uso SQLAlchemy.È piuttosto potente ed è probabilmente l'ORM Python più maturo.

Se hai intenzione di utilizzare CherryPy, potresti anche esaminare già visto poiché è di Robert Brewer (il ragazzo che è l'attuale leader del progetto CherryPy).Personalmente non l'ho usato, ma conosco alcune persone che lo adorano.

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

Personalmente, non utilizzerei Django ORM a meno che non avessi intenzione di scrivere l'intero progetto in Django, ma sono solo io.

Answer 5

di SQLAlchemy dichiarativo l'estensione, che diventerà standard nella versione 0.5, fornisce un'interfaccia tutto in uno molto simile a quella di Django o Storm.Inoltre si integra perfettamente con 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()

Answer 6

Noi usiamo Elisir insieme a SQLAlchemy e finora mi è piaciuto.Elixir mette uno strato sopra SQLAlchemy che lo fa sembrare più simile alle controparti "modello ActiveRecord".

Answer 7

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

Da lì, sembra Già visto implementa il modello DataMapper di Martin Fowler in modo abbastanza astratto in Python.

Answer 8

Penso che potresti guardare:

Autunno

Tempesta

Answer 9

Non è concepibile che le funzionalità inutilizzate di Django possano penalizzare le prestazioni.Potrebbe tornare utile se mai decidessi di migliorare il progetto.

Answer 10

SQLAlchemy è molto, molto potente.Tuttavia non è thread-safe, assicurati di tenerlo a mente quando lavori con cherrypy in modalità thread-pool.

Answer 11

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

Answer 12

Farei un controllo 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')>