Какие хорошие решения ORM для Python?

Question

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

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

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

Answer 1

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

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

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

При этом, если бы я уже использовал CherryPy для веб-уровня и просто нуждался в ORM, я бы выбрал SQLAlchemy.

Answer 2

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

Autumn

Storm

Answer 3

Я бы проверить 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')> 

Answer 4

Обычно я использую SQLAlchemy. Это довольно мощный и, вероятно, самый зрелый ORM питона.

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

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

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

Answer 5

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

Answer 6

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

Answer 7

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

Answer 8

declarative расширение 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() 

Answer 9

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

Answer 10

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

Answer 11

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

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

Answer 12

Если вы ищете легкий и уже знакомы с Джанго стиле декларативных моделей, проверить 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') 

Проверьте docs больше примеров.