Какие хорошие решения для Python ORM? [закрыто]

Я оцениваю и смотрю на использование CherryPy для проекта, который в основном является интерфейсом JavaScript со стороны клиента (браузера), который взаимодействует с веб-сервисом Python на стороне сервера. Итак, мне действительно нужно что-то быстрое и легковесное на сервере, которое я могу реализовать с помощью Python, который затем обращается к БД PostgreSQL через ORM (JSON для браузера).

Я также смотрю на Django, который мне нравится, так как его ORM встроен. Тем не менее, я думаю, что Django может быть немного больше, чем мне действительно нужно (т.е. больше возможностей, чем мне действительно нужно == медленнее?).

Кто-нибудь имеет опыт работы с различными решениями Python ORM, которые могут сравнивать и сравнивать их функции и функциональность, скорость, эффективность и т. Д.?

SQLAlchemy является более полнофункциональным и мощным (использует шаблон DataMapper). Django ORM имеет более чистый синтаксис и его легче писать (шаблон ActiveRecord). Я не знаю о различиях в производительности.

SQLAlchemy также имеет декларативный слой, который скрывает некоторую сложность и придает ему синтаксис в стиле ActiveRecord, более похожий на Django ORM.

Я бы не беспокоился о том, что Джанго «слишком тяжелый». Он настолько разделен, что вы можете использовать ORM, если хотите, без необходимости импортировать остальное .

Тем не менее, если бы я уже использовал 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 . Это довольно мощный и, вероятно, самый зрелый Python ORM.

Если вы планируете использовать CherryPy, вы также можете посмотреть на dejavu как это Роберт Брюер (парень, который в настоящее время является лидером проекта CherryPy). Лично я не использовал это, но я знаю некоторых людей, которые любят это.

SQLObject немного проще в использовании ORM, чем SQLAlchemy, но он не такой мощный.

Лично я бы не использовал Django ORM, если бы не планировал написать весь проект на Django, но это только я.

Декларативное расширение SQLAlchemy , которое становится стандартным в 0.5, предоставляет интерфейс «все в одном», очень похожий на интерфейс Django или Storm. Он также легко интегрируется с классами / таблицами, настроенными с использованием стиля 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()

Мы используем Elixir вместе с SQLAlchemy и нам это до сих пор нравилось. Elixir помещает слой поверх SQLAlchemy, который делает его более похожим на элементы счетчика «шаблон ActiveRecord».

Кажется, это каноническая точка отсчета для взаимодействия с базами данных высокого уровня в Python: http://wiki.python.org/moin/HigherLevelDatabaseProgramming

Оттуда, похоже, Dejavu довольно абстрактно реализует шаблон DataMapper Мартина Фаулера в Python.

Я думаю, что вы можете посмотреть на:

осень

Буря

Невозможно представить, что неиспользуемые функции в Django приведут к снижению производительности. Может пригодиться, если вы когда-нибудь решите расширить проект.

Я использовал Storm + SQLite для небольшого проекта и был доволен им до тех пор, пока не добавил многопроцессорность. Попытка использовать базу данных из нескольких процессов привела к исключению «База данных заблокирована». Я перешел на SQLAlchemy, и тот же код работал без проблем.

SQLAlchemy очень, очень мощный. Однако это не безопасно для потоков, убедитесь, что имейте это в виду при работе с cherrypy в режиме пула потоков.

Я бы проверил SQLAlchemy

Он действительно прост в использовании, и модели, с которыми вы работаете, совсем не плохи. Django использует SQLAlchemy для своего ORM, но использование его само по себе позволяет использовать его в полную силу.

Вот небольшой пример создания и выбора объектов 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')>