โซลูชั่น Python ORM ที่ดีคืออะไร [ปิด]

ฉันกำลังประเมินและมองหาการใช้ CherryPy สำหรับโครงการที่เป็นพื้นหน้า JavaScript จากฝั่งไคลเอ็นต์ (เบราว์เซอร์) ที่พูดคุยกับ Python เว็บเซอร์วิสด้านหลัง ดังนั้นฉันต้องการบางสิ่งที่รวดเร็วและมีน้ำหนักเบาที่ back-end ที่ฉันสามารถนำไปใช้โดยใช้ Python ที่พูดกับ PostgreSQL DB ผ่าน ORM (JSON กับเบราว์เซอร์)

ฉันกำลังดู Django ด้วยซึ่งฉันชอบเนื่องจาก ORM ของมันมีอยู่ในตัว อย่างไรก็ตามฉันคิดว่า Django อาจจะมากกว่าที่ฉันต้องการเล็กน้อย (เช่นมีฟีเจอร์มากกว่าที่ฉันต้องการ == ช้าลงไหม?)

ทุกคนมีประสบการณ์ใด ๆ กับโซลูชัน Python ORM ที่แตกต่างกันซึ่งสามารถเปรียบเทียบและเปรียบเทียบคุณลักษณะและฟังก์ชันการทำงานความเร็วประสิทธิภาพ ฯลฯ

SQLAlchemy มีคุณสมบัติครบถ้วนและทรงพลังมากขึ้น (ใช้รูปแบบ DataMapper) Django ORM มีไวยากรณ์ที่สะอาดกว่าและเขียนได้ง่ายกว่า (รูปแบบ ActiveRecord) ฉันไม่รู้เกี่ยวกับความแตกต่างด้านประสิทธิภาพ

SQLAlchemy ยังมีชั้นประกาศที่ซ่อนความซับซ้อนบางอย่างและทำให้มันเป็นรูปแบบ ActiveRecord- รูปแบบคล้ายกับ Django ORM

ฉันไม่ต้องกังวลว่า Django จะ "หนักเกินไป" ก็พอที่ decoupled ที่คุณสามารถใช้ออมถ้าคุณต้องการได้โดยไม่ต้องนำเข้าส่วนที่เหลือ

ที่กล่าวว่าถ้าฉันใช้ CherryPy สำหรับเลเยอร์เว็บและต้องการ ORM ฉันก็อาจเลือกใช้ SQLAlchemy

หากคุณกำลังมองหาน้ำหนักเบาและคุ้นเคยกับโมเดลประกาศสไตล์ django แล้วให้ตรวจสอบ peewee: https://github.com/coleifer/peewee

ตัวอย่าง:

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

ตรวจสอบเอกสารเพื่อดูตัวอย่างเพิ่มเติม

Stormมี 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()

และมันทำให้ไม่เจ็บปวดที่จะปล่อยลงใน SQL ดิบเมื่อคุณต้องการ:

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

ผมมักจะใช้SQLAlchemy มันค่อนข้างทรงพลังและน่าจะเป็นงูหลาม ORM ที่โตที่สุด

หากคุณวางแผนที่จะใช้ CherryPy คุณอาจดูเป็นdejavuโดย Robert Brewer (คนที่เป็นผู้นำโครงการ CherryPy ในปัจจุบัน) ฉันไม่ได้ใช้มันเป็นการส่วนตัว แต่ฉันรู้จักบางคนที่รักมัน

SQLObjectนั้นใช้งาน ORM ได้ง่ายกว่า SQLAlchemy เล็กน้อย แต่ก็ไม่ค่อยมีประสิทธิภาพเท่าไหร่

โดยส่วนตัวแล้วฉันจะไม่ใช้ Django ORM ถ้าฉันไม่ได้วางแผนที่จะเขียนโครงการทั้งหมดใน Django แต่นั่นเป็นเพียงฉัน

ส่วนขยายที่ประกาศของ SQLAlchemy ซึ่งกำลังกลายเป็นมาตรฐานใน 0.5 จะให้ส่วนต่อประสานทั้งหมดในหนึ่งอินเทอร์เฟซเหมือนกับ Django หรือ Storm นอกจากนี้ยังผสานรวมเข้ากับคลาส / ตารางที่กำหนดค่าโดยใช้สไตล์ดาต้าแมป:

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

เราใช้Elixirควบคู่กับ SQLAlchemy และชอบมันมาก Elixir วางเลเยอร์ไว้ด้านบนของ SQLAlchemy ซึ่งทำให้ดูเหมือนส่วนเคาน์เตอร์ "รูปแบบ ActiveRecord"

นี่น่าจะเป็นจุดอ้างอิงแบบบัญญัติสำหรับการโต้ตอบกับฐานข้อมูลระดับสูงใน Python: http://wiki.python.org/moin/HigherLevelDatabaseProgramming

ดูเหมือนว่าDejavu จะใช้รูปแบบ DataMapper ของ Martin Fowler ใน Python

ฉันคิดว่าคุณอาจจะดู:

ฤดูใบไม้ร่วง

พายุ

ไม่มีวิธีที่เป็นไปได้ที่คุณสมบัติที่ไม่ได้ใช้ใน Django จะให้โทษประสิทธิภาพ อาจมีประโยชน์ถ้าคุณตัดสินใจที่จะทำโปรเจค

ฉันใช้ Storm + SQLite สำหรับโครงการขนาดเล็กและมีความสุขมากกับมันจนกว่าฉันจะเพิ่มการประมวลผลหลายตัว กำลังพยายามใช้ฐานข้อมูลจากหลายกระบวนการทำให้เกิดข้อยกเว้น "ฐานข้อมูลถูกล็อก" ฉันเปลี่ยนเป็น SQLAlchemy และรหัสเดียวกันทำงานได้โดยไม่มีปัญหา

SQLAlchemy นั้นมีประสิทธิภาพมาก อย่างไรก็ตามมันไม่ปลอดภัยเธรดให้แน่ใจว่าคุณจำไว้เมื่อทำงานกับ cherrypy ในโหมดเธรดพูล

ฉันจะตรวจสอบSQLAlchemy

มันใช้งานง่ายมากและรุ่นที่คุณทำงานด้วยก็ไม่เลวเลย Django ใช้ SQLAlchemy เพราะเป็น 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')>