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

Question

Ich bin der Bewertung und der Suche mit CherryPy für ein Projekt, das im Grunde eine JavaScript-front-end von der client-Seite (browser), dass die Gespräche, um einen Python-web-service auf dem back-end.Also, ich brauche wirklich etwas, das schnell und leicht auf die Rückseite, die ich implementieren kann mit Python, dann spricht die PostgreSQL-DB über ein ORM (JSON an den browser).

Ich bin auch auf der Suche an Django, die ich mag, da seine ORM-ist gebaut-in.Ich denke aber, Django vielleicht ein wenig mehr, als ich eigentlich brauche (d.h.mehr Funktionen, als ich wirklich brauche, = = langsamer?).

Wer noch keine Erfahrungen mit unterschiedlichen Python ORM-Lösungen, die können vergleichen und deren Eigenschaften und Funktionalität, Geschwindigkeit, Effizienz, etc.?

Answer 1

SQLAlchemy ist mehr voll funktionsfähige und leistungsstarke (verwendet die DataMapper-Muster).Django ORM hat eine sauberere syntax, und es ist einfacher für Sie zu schreiben (ActiveRecord-Muster).Ich weiß nicht, über die performance-Unterschiede.

SQLAlchemy hat auch eine deklarative Ebene versteckt, dass einige Komplexität und gibt es eine ActiveRecord-Stil-syntax ähnlich der Django ORM.

Ich würde nicht sorgen über Django "zu schwer." Es entkoppelt genug, dass Sie verwenden können die ORM-wenn Sie wollen, ohne zu importieren den rest.

Das heißt, wenn ich bereits mit CherryPy für die web-Schicht und brauchte nur ein ORM, würde ich wahrscheinlich entscheiden Sie sich für SQLAlchemy.

Answer 2

Wenn Sie suchen für leichtes und sind bereits vertraut mit django-Stil deklarative Modelle, check out 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')

Überprüfen Sie die docs für weitere Beispiele.

Answer 3

Sturm 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 drop-down in raw-SQL, wenn Sie müssen:

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

Answer 4

Normalerweise verwende ich SQLAlchemy.Es ist ziemlich stark und ist wohl die ausgereifteste python ORM.

Wenn Sie planen, über die Verwendung CherryPy, könnten Sie auch einen Blick in dejavu wie es von Robert Brewer (der Kerl, der den aktuellen CherryPy-Projektleiter).Ich persönlich noch nicht benutzt, aber ich weiß, dass manche Leute es lieben.

SQLObject ist ein wenig einfacher zu nutzen ORM als SQLAlchemy, aber es ist nicht ganz so mächtig.

Ich persönlich würde nicht mit dem Django ORM, es sei denn, ich war die Planung auf das schreiben, das gesamte Projekt in Django, aber das ist nur mir.

Answer 5

SQLAlchemy ist deklarative Erweiterung, die zum standard in 0,5, bietet eine all-in-one-Schnittstelle sehr ähnlich wie die von Django oder Sturm.Es integriert sich auch nahtlos mit Klassen/Tabellen konfiguriert werden mit dem datamapper Stil:

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

Wir verwenden Elixir neben SQLAlchemy und mochte es so weit.Elixir legt eine Schicht auf top von SQLAlchemy, die macht es Aussehen wie die "ActiveRecord-Muster" counter-Teile.

Answer 7

Dies scheint die kanonische Referenz für high-level-Datenbank-Interaktion in Python:http://wiki.python.org/moin/HigherLevelDatabaseProgramming

Von dort aus, wie es aussieht Dejavu implementiert Martin Fowler ' s DataMapper-Muster ziemlich Abstrakt in Python.

Answer 8

Ich glaube, Sie könnten Blick auf:

Herbst

Sturm

Answer 9

Es gibt keine denkbare Möglichkeit, die ungenutzte Funktionen in Django wird geben Sie eine performance-Strafe.Könnte nur nützlich sein, wenn Sie sich entscheiden, die jemals gehobenen Projekt.

Answer 10

SQLAlchemy ist sehr, sehr mächtig.Es ist jedoch nicht thread-sicher zu machen Sie sicher, dass Sie halten diese in Geist bei der Arbeit mit cherrypy im thread-pool-Modus.

Answer 11

Ich benutzte Sturm + SQLite für ein kleines Projekt, und war ziemlich glücklich mit es, bis ich fügte hinzu, multiprocessing.Versuchen, zu verwenden die Datenbank, aus der mehrere Prozesse führte zu einer "Datenbank ist gesperrt" - Ausnahme.Ich wechselte zu SQLAlchemy, und der gleiche code funktionierte ohne Probleme.

Answer 12

Ich würde check-out SQLAlchemy

Es ist wirklich einfach zu bedienen und die Modelle, mit denen Sie arbeiten, sind nicht schlecht. Django verwendet SQLAlchemy für ORM aber mit es durch sich selbst, können Sie es verwenden Ihre volle Kraft.

Hier ist ein kleines Beispiel für die Erstellung und Auswahl von orm-Objekte

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