Bazı iyi Python ORM çözümleri nelerdir? [kapalı]

Ben temelde arka taraftaki bir Python web hizmetiyle görüşen istemci tarafı (tarayıcı) bir JavaScript ön uç olan bir proje için CherryPy kullanarak değerlendiriyorum ve bakıyorum. Yani, ben gerçekten daha sonra bir ORM (tarayıcı JSON) PostgreSQL DB konuşuyor Python kullanarak uygulayabilirsiniz arka ucunda hızlı ve hafif bir şeye ihtiyacım var.

Ayrıca ORM yerleşik olduğu için sevdiğim Django'ya bakıyorum. Ancak, Django gerçekten ihtiyacım olandan biraz daha fazla olabilir düşünüyorum (yani gerçekten == daha yavaş daha fazla özellik?).

Herkes özellikleri ve işlevsellik, hız, verimlilik vb karşılaştırabilir ve kontrast farklı Python ORM çözümleri ile herhangi bir deneyimi var mı?

SQLAlchemy daha tam özellikli ve güçlüdür (DataMapper modelini kullanır). Django ORM daha temiz bir sözdizimine sahiptir ve (ActiveRecord şablonu) için yazılması daha kolaydır. Performans farklarını bilmiyorum.

SQLAlchemy ayrıca, bazı karmaşıklığı gizleyen ve Django ORM'ye daha çok benzeyen bir ActiveRecord tarzı sözdizimi veren bildirici bir katmana sahiptir.

Django'nun "çok ağır" olması konusunda endişelenmezdim. Geri kalanını içe aktarmak zorunda kalmadan isterseniz ORM'yi kullanabileceğiniz kadar ayrıştırılmıştır .

Bu, zaten web katmanı için CherryPy kullanıyor ve sadece bir ORM gerekiyorsa, muhtemelen SQLAlchemy tercih ediyorum dedi.

Hafif arıyorsanız ve zaten django tarzı bildirim modellerine aşina iseniz, peewee'ye göz atın: https://github.com/coleifer/peewee

Misal:

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

Daha fazla örnek için dokümanlara bakın.

Storm tartışmasız en basit API'ya sahip:

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

Ve ihtiyacınız olduğunda ham SQL'e düşmeyi ağrısız hale getirir:

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

Genellikle SQLAlchemy kullanıyorum . Oldukça güçlü ve muhtemelen en olgun python ORM.

CherryPy kullanmayı planlıyorsanız, Robert Brewer (şu anda CherryPy proje lideri olan adam) tarafından olduğu gibi dejavu'ya da bakabilirsiniz . Ben şahsen kullanmadım, ama onu seven bazı insanlar tanıyorum.

SQLObject , ORM'yi kullanmak için SQLAlchemy'den biraz daha kolaydır, ancak o kadar güçlü değildir.

Şahsen, tüm projeyi Django'da yazmayı planlamıyorsam Django ORM'yi kullanmazdım, ama bu sadece benim.

0.5'de standart hale gelen SQLAlchemy'nin bildirimsel uzantısı, Django veya Storm'a çok benzeyen hepsi bir arada arabirim sağlar. Ayrıca datamapper stili kullanılarak yapılandırılmış sınıflar / tablolarla sorunsuz bir şekilde bütünleşir:

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

İksiri SQLAlchemy ile birlikte kullanıyoruz ve şimdiye kadar beğendik. Elixir, SQLAlchemy'nin üzerine daha çok "ActiveRecord deseni" sayaç parçalarına benzeyen bir katman yerleştirir.

Bu, Python'da üst düzey veritabanı etkileşimi için standart referans noktası gibi görünüyor: http://wiki.python.org/moin/HigherLevelDatabaseProgramming

Oradan, Dejavu Martin Fowler'in DataMapper desenini oldukça soyut bir şekilde Python'da uyguluyor gibi görünüyor .

Sanırım şuna bakabilirsiniz:

Sonbahar

Fırtına

Django'daki kullanılmayan özelliklerin performans cezası vermesinin makul bir yolu yoktur. Projeyi yükseltmeye karar verirseniz kullanışlı olabilir.

Küçük bir proje için Storm + SQLite kullandım ve çok işlemciliğe kadar çok mutlu oldum. Veritabanını birden çok işlemden kullanmaya çalışmak "Veritabanı kilitli" özel durumu ile sonuçlandı. SQLAlchemy'ye geçtim ve aynı kod sorunsuz çalıştı.

SQLAlchemy çok, çok güçlü. Ancak, iplik güvenli değildir, iplik havuzu modunda cherrypy ile çalışırken bunu aklınızda bulundurun.

SQLAlchemy'yi kontrol ederdim

Kullanımı gerçekten çok kolay ve birlikte çalıştığınız modeller hiç de fena değil. Django, ORM için SQLAlchemy kullanıyor ancak tek başına kullanmak tam gücünü kullanmanıza izin veriyor.

Orm nesneleri oluşturma ve seçme ile ilgili küçük bir örnek

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