Was sind einige gute Python ORM-Lösungen? [geschlossen]

Ich evaluiere und verwende CherryPy für ein Projekt, bei dem es sich im Grunde um ein JavaScript-Frontend auf der Clientseite (Browser) handelt, das mit einem Python-Webdienst im Backend kommuniziert. Ich brauche also wirklich etwas schnelles und leichtes im Back-End, das ich mit Python implementieren kann und das dann über einen ORM (JSON zum Browser) mit der PostgreSQL-Datenbank spricht.

Ich schaue mir auch Django an, das mir gefällt, da sein ORM eingebaut ist. Ich denke jedoch, dass Django etwas mehr sein könnte, als ich wirklich brauche (dh mehr Funktionen, als ich wirklich brauche == langsamer?).

Hat jemand Erfahrung mit verschiedenen Python ORM-Lösungen, die ihre Merkmale und Funktionen, Geschwindigkeit, Effizienz usw. vergleichen und gegenüberstellen können?

SQLAlchemy ist umfassender und leistungsfähiger (verwendet das DataMapper-Muster). Django ORM hat eine sauberere Syntax und ist einfacher zu schreiben (ActiveRecord-Muster). Ich weiß nichts über Leistungsunterschiede.

SQLAlchemy verfügt auch über eine deklarative Ebene , die eine gewisse Komplexität verbirgt und eine Syntax im ActiveRecord-Stil bietet, die dem Django-ORM ähnlicher ist.

Ich würde mir keine Sorgen machen, dass Django "zu schwer" ist. Es ist so entkoppelt, dass Sie das ORM verwenden können, wenn Sie möchten, ohne den Rest importieren zu müssen .

Das heißt, wenn ich CherryPy bereits für die Webebene verwenden würde und nur ein ORM benötige, würde ich mich wahrscheinlich für SQLAlchemy entscheiden.

Wenn Sie auf der Suche nach Leichtgewicht sind und bereits mit deklarativen Modellen im Django-Stil vertraut sind, besuchen Sie peewee: https://github.com/coleifer/peewee

Beispiel:

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

Weitere Beispiele finden Sie in den Dokumenten .

Storm hat wohl die einfachste 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()

Und es macht es schmerzlos, in Raw SQL zu wechseln, wenn Sie Folgendes benötigen:

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

Normalerweise benutze ich SQLAlchemy . Es ist ziemlich mächtig und wahrscheinlich das ausgereifteste Python-ORM.

Wenn Sie CherryPy verwenden möchten, können Sie sich auch mit Dejavu befassen, da es von Robert Brewer (dem aktuellen CherryPy-Projektleiter) stammt. Ich persönlich habe es nicht benutzt, aber ich kenne einige Leute, die es lieben.

SQLObject ist ein bisschen einfacher zu verwenden als SQLAlchemy, aber es ist nicht ganz so leistungsfähig.

Persönlich würde ich das Django ORM nicht verwenden, wenn ich nicht vorhabe, das gesamte Projekt in Django zu schreiben, aber das bin nur ich.

Die deklarative Erweiterung von SQLAlchemy , die in 0.5 zum Standard wird, bietet eine All-in-One-Schnittstelle, die der von Django oder Storm sehr ähnlich ist. Es lässt sich auch nahtlos in Klassen / Tabellen integrieren, die im Datamapper-Stil konfiguriert wurden:

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

Wir verwenden Elixir neben SQLAlchemy und haben es bisher gemocht. Elixir legt eine Ebene auf SQLAlchemy, die es eher wie die Gegenstücke des "ActiveRecord-Musters" aussehen lässt.

Dies scheint der kanonische Bezugspunkt für die Datenbankinteraktion auf hoher Ebene in Python zu sein: http://wiki.python.org/moin/HigherLevelDatabaseProgramming

Von dort aus sieht es so aus, als würde Dejavu das DataMapper-Muster von Martin Fowler ziemlich abstrakt in Python implementieren.

Ich denke, Sie könnten sich Folgendes ansehen:

Herbst

Sturm

Es ist nicht vorstellbar, dass die nicht verwendeten Funktionen in Django zu Leistungseinbußen führen. Könnte sich als nützlich erweisen, wenn Sie sich jemals dazu entschließen, das Projekt zu verbessern.

Ich habe Storm + SQLite für ein kleines Projekt verwendet und war ziemlich zufrieden damit, bis ich Multiprocessing hinzugefügt habe. Der Versuch, die Datenbank aus mehreren Prozessen heraus zu verwenden, führte zu einer Ausnahme "Datenbank ist gesperrt". Ich wechselte zu SQLAlchemy und der gleiche Code funktionierte ohne Probleme.

SQLAlchemy ist sehr, sehr mächtig. Es ist jedoch nicht threadsicher. Denken Sie daran, wenn Sie mit cherrypy im Thread-Pool-Modus arbeiten.

Ich würde SQLAlchemy ausprobieren

Es ist wirklich einfach zu bedienen und die Modelle, mit denen Sie arbeiten, sind überhaupt nicht schlecht. Django verwendet SQLAlchemy für sein ORM, aber wenn Sie es alleine verwenden, können Sie die volle Leistung nutzen.

Hier ist ein kleines Beispiel zum Erstellen und Auswählen von Orm-Objekten

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