Quelles sont les bonnes solutions Python ORM? [fermé]

J'évalue et cherche à utiliser CherryPy pour un projet qui est essentiellement un front-end JavaScript du côté client (navigateur) qui parle à un service Web Python sur le back-end. Donc, j'ai vraiment besoin de quelque chose de rapide et léger sur le back-end que je peux implémenter en utilisant Python qui parle ensuite à la base de données PostgreSQL via un ORM (JSON au navigateur).

Je regarde également Django, que j'aime, car son ORM est intégré. Cependant, je pense que Django pourrait être un peu plus que ce dont j'ai vraiment besoin (c'est-à-dire plus de fonctionnalités que je n'en ai vraiment besoin == plus lent?).

Quelqu'un a-t-il une expérience avec différentes solutions Python ORM qui peuvent comparer et contraster leurs caractéristiques et fonctionnalités, leur vitesse, leur efficacité, etc.?

SQLAlchemy est plus complet et puissant (utilise le modèle DataMapper). Django ORM a une syntaxe plus propre et est plus facile à écrire (modèle ActiveRecord). Je ne connais pas les différences de performances.

SQLAlchemy a également une couche déclarative qui cache une certaine complexité et lui donne une syntaxe de style ActiveRecord plus similaire à l'ORM Django.

Je ne m'inquiéterais pas du fait que Django soit "trop ​​lourd". Il est suffisamment découplé pour que vous puissiez utiliser l'ORM si vous le souhaitez sans avoir à importer le reste .

Cela dit, si j'utilisais déjà CherryPy pour la couche Web et que j'avais juste besoin d'un ORM, j'opterais probablement pour SQLAlchemy.

Si vous êtes à la recherche de poids léger et connaissez déjà les modèles déclaratifs de style django, consultez peewee: https://github.com/coleifer/peewee

Exemple:

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

Consultez les documents pour plus d'exemples.

Storm a sans doute l'API la plus simple:

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

Et il est indolore de descendre dans le SQL brut lorsque vous devez:

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

J'utilise habituellement SQLAlchemy . Il est assez puissant et est probablement l'ORM en python le plus mature.

Si vous prévoyez d'utiliser CherryPy, vous pourriez également vous pencher sur dejavu car il est de Robert Brewer (le gars qui est le chef de projet CherryPy actuel). Personnellement, je ne l'ai pas utilisé, mais je connais des gens qui l'aiment.

SQLObject est un peu plus facile à utiliser ORM que SQLAlchemy, mais il n'est pas aussi puissant.

Personnellement, je n'utiliserais pas l'ORM Django à moins que je ne prévoie d'écrire tout le projet dans Django, mais c'est juste moi.

L' extension déclarative de SQLAlchemy , qui devient standard en 0.5, fournit une interface tout en un très similaire à celle de Django ou Storm. Il s'intègre également de manière transparente aux classes / tables configurées à l'aide du style de 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()

Nous utilisons Elixir aux côtés de SQLAlchemy et nous l'avons aimé jusqu'à présent. Elixir place une couche au-dessus de SQLAlchemy qui la fait ressembler davantage aux contre-parties du "modèle ActiveRecord".

Cela semble être le point de référence canonique pour l'interaction de base de données de haut niveau en Python: http://wiki.python.org/moin/HigherLevelDatabaseProgramming

De là, il semble que Dejavu implémente le modèle DataMapper de Martin Fowler de manière assez abstraite en Python.

Je pense que vous pourriez regarder:

L'automne

Tempête

Il n'y a aucun moyen concevable que les fonctionnalités inutilisées de Django entraînent une baisse des performances. Pourrait être utile si vous décidez de faire évoluer le projet.

J'ai utilisé Storm + SQLite pour un petit projet et j'en ai été très satisfait jusqu'à ce que j'ajoute le multiprocessing. La tentative d'utilisation de la base de données à partir de plusieurs processus a entraîné une exception «La base de données est verrouillée». Je suis passé à SQLAlchemy et le même code a fonctionné sans problème.

SQLAlchemy est très, très puissant. Cependant, il n'est pas sûr pour les threads, assurez-vous de garder cela à l'esprit lorsque vous travaillez avec cherrypy en mode pool de threads.

Je vérifierais SQLAlchemy

C'est vraiment facile à utiliser et les modèles avec lesquels vous travaillez ne sont pas mauvais du tout. Django utilise SQLAlchemy pour son ORM mais l'utiliser seul vous permet d'utiliser sa pleine puissance.

Voici un petit exemple sur la création et la sélection d'objets 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')>