Apa sajakah solusi Python ORM yang bagus? [Tutup]

Saya mengevaluasi dan melihat menggunakan CherryPy untuk proyek yang pada dasarnya adalah JavaScript front-end dari sisi klien (browser) yang berbicara dengan layanan web Python di back-end. Jadi, saya benar-benar membutuhkan sesuatu yang cepat dan ringan di bagian belakang yang dapat saya terapkan menggunakan Python yang kemudian berbicara kepada DB PostgreSQL melalui ORM (JSON ke browser).

Saya juga melihat Django, yang saya suka, karena ORM-nya built-in. Namun, saya pikir Django mungkin sedikit lebih dari yang saya butuhkan (yaitu lebih banyak fitur daripada yang saya butuhkan == lebih lambat?).

Adakah yang punya pengalaman dengan solusi Python ORM berbeda yang dapat membandingkan dan membedakan fitur dan fungsionalitas, kecepatan, efisiensi, dll.?

SQLAlchemy lebih berfitur lengkap dan kuat (menggunakan pola DataMapper). Django ORM memiliki sintaks yang lebih bersih dan lebih mudah ditulis untuk (pola ActiveRecord). Saya tidak tahu tentang perbedaan kinerja.

SQLAlchemy juga memiliki lapisan deklaratif yang menyembunyikan beberapa kompleksitas dan memberinya sintaks gaya ActiveRecord yang lebih mirip dengan Django ORM.

Saya tidak akan khawatir kalau Django "terlalu berat." Cukup dipisahkan sehingga Anda dapat menggunakan ORM jika Anda mau tanpa harus mengimpor sisanya .

Yang mengatakan, jika saya sudah menggunakan CherryPy untuk lapisan web dan hanya membutuhkan ORM, saya mungkin akan memilih SQLAlchemy.

Jika Anda mencari yang ringan dan sudah terbiasa dengan model deklaratif gaya django, lihat peewee: https://github.com/coleifer/peewee

Contoh:

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

Periksa dokumen untuk contoh lebih lanjut.

Storm memiliki API paling sederhana:

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

Dan itu membuatnya sulit untuk drop down ke SQL mentah ketika Anda perlu:

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

Saya biasanya menggunakan SQLAlchemy . Ini cukup kuat dan mungkin ORM python yang paling matang.

Jika Anda berencana menggunakan CherryPy, Anda mungkin juga melihat dejavu karena itu oleh Robert Brewer (orang yang merupakan pemimpin proyek CherryPy saat ini). Saya pribadi belum menggunakannya, tetapi saya tahu beberapa orang yang menyukainya.

SQLObject sedikit lebih mudah untuk menggunakan ORM daripada SQLAlchemy, tetapi itu tidak cukup kuat.

Secara pribadi, saya tidak akan menggunakan Django ORM kecuali saya berencana untuk menulis seluruh proyek di Django, tapi itu hanya saya.

Ekstensi deklaratif SQLAlchemy , yang menjadi standar dalam 0,5, menyediakan antarmuka semua dalam satu sangat mirip dengan Django atau Storm. Itu juga terintegrasi dengan mulus dengan kelas / tabel yang dikonfigurasi menggunakan gaya 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()

Kami menggunakan Elixir bersama SQLAlchemy dan sejauh ini menyukainya. Elixir menempatkan lapisan di atas SQLAlchemy yang membuatnya tampak lebih seperti bagian penghitung "pola ActiveRecord".

Ini tampaknya menjadi titik referensi kanonik untuk interaksi basis data tingkat tinggi dengan Python: http://wiki.python.org/moin/HigherLevelDatabaseProgramming

Dari sana, sepertinya Dejavu mengimplementasikan pola DataMapper Martin Fowler secara abstrak dalam Python.

Saya pikir Anda mungkin melihat:

Musim gugur

Badai

Tidak ada cara yang mungkin bahwa fitur yang tidak digunakan di Django akan memberikan penalti kinerja. Mungkin akan berguna jika Anda memutuskan untuk meningkatkan proyek.

Saya menggunakan Storm + SQLite untuk proyek kecil, dan cukup senang dengan itu sampai saya menambahkan multiprocessing. Mencoba menggunakan database dari berbagai proses menghasilkan pengecualian "Database terkunci". Saya beralih ke SQLAlchemy, dan kode yang sama berfungsi tanpa masalah.

SQLAlchemy sangat, sangat kuat. Namun itu bukan thread aman, pastikan Anda mengingatnya saat bekerja dengan cherrypy dalam mode thread-pool.

Saya akan memeriksa SQLAlchemy

Ini sangat mudah digunakan dan model yang Anda gunakan tidak buruk sama sekali. Django menggunakan SQLAlchemy untuk ORM-nya, tetapi menggunakannya dengan sendirinya memungkinkan Anda menggunakannya dengan kekuatan penuh.

Berikut adalah contoh kecil tentang cara membuat dan memilih objek 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')>