Quelles sont les bonnes Python ORM solutions?[fermé]
https://stackoverflow.com/questions/53428
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianQuestion
Je suis de l'évaluation et de la recherche à l'aide de CherryPy pour un projet, c'est essentiellement un JavaScript front-end du côté client (navigateur) qui parle d'un Python de service web sur le back-end.Alors, j'ai vraiment besoin de quelque chose de rapide et léger sur le back-end que je puisse les mettre en œuvre à l'aide de Python qui parle ensuite de le PostgreSQL base de données via un ORM (JSON pour le navigateur).
Je suis également à la recherche de Django, que j'aime, depuis sa ORM est intégré.Cependant, je pense que Django peut-être un peu plus que j'ai vraiment besoin (c'est à direplus de fonctionnalités que j'ai vraiment besoin d' == plus lent?).
Quelqu'un a une expérience avec les différentes Python ORM solutions qui peuvent comparer leurs caractéristiques et de fonctionnalités, rapidité, efficacité, etc.?
La solution
SQLAlchemy est plus complet et puissant qui utilise le DataMapper modèle).L'ORM de Django a un nettoyeur de syntaxe et est plus facile à écrire pour (ActiveRecord modèle).Je ne connais pas les différences de rendement.
SQLAlchemy dispose également d'un déclaratif de la couche qui cache une certaine complexité et lui donne un ActiveRecord-la syntaxe de style de plus en plus semblables à l'ORM de Django.
Je ne serais pas s'inquiéter à propos de Django "trop lourd". C'est découplé assez que vous pouvez utiliser l'ORM si vous le souhaitez, sans avoir à importer le reste.
Cela dit, si j'étais déjà à l'aide de CherryPy pour le web la couche et juste besoin d'un ORM, je serais probablement opter pour SQLAlchemy.
Autres conseils
Si vous êtes à la recherche pour les légers et sont déjà familiers avec django style déclaratif modèles, découvrez 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')
De vérifier la docs pour plus d'exemples.
Tempête a sans doute le plus simple 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()
Et il le fait indolore pour descendre dans les matières premières SQL lorsque vous avez besoin de:
store.execute('UPDATE bars SET bar_name=? WHERE bar_id like ?', [])
store.commit()
J'ai l'habitude de l'utiliser SQLAlchemy.Il est assez puissant et sans doute le plus mature python ORM.
Si vous prévoyez sur l'utilisation de CherryPy, vous pouvez également regarder dans dejavu comme c'est par Robert Brasseur (le gars qui est l'actuel CherryPy chef de projet).Personnellement, je ne l'ai pas utilisé, mais je sais que certaines personnes qu'il aime.
SQLObject est un peu plus facile à utiliser l'ORM de SQLAlchemy, mais ce n'est pas tout à fait aussi puissant.
Personnellement, je ne voudrais pas utiliser l'ORM de Django, à moins que je comptais sur l'écriture de l'ensemble du projet dans Django, mais c'est juste moi.
SQLAlchemy de l' déclarative l'extension, qui est en train de devenir la norme de 0,5, ce qui donne un tout dans une interface très semblable à celle de Django ou de la Tempête.Il s'intègre également parfaitement avec les classes/tables configuré à l'aide de la datamapper style:
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 ont aimé jusqu'à présent.Elixir met une couche sur le dessus de SQLAlchemy qui en fait ressemble plus à de la "ActiveRecord modèle" comptoir des pièces.
Cela semble être la canonique de point de référence pour de haut niveau de l'interaction des bases de données en Python:http://wiki.python.org/moin/HigherLevelDatabaseProgramming
À partir de là, il ressemble à Dejavu implémente Martin Fowler DataMapper modèle assez abstraite en Python.
Il n'est pas concevable que les fonctionnalités non utilisées dans Django donnera une pénalité de performances.Pourrait tout simplement venir dans maniable si jamais vous décidez de haut de gamme le projet.
SQLAlchemy est très, très puissant.Cependant, il n'est pas thread-safe assurez-vous de garder cela à l'esprit lorsque vous travaillez avec cherrypy dans le thread du pool de mode.
J'ai utilisé de la Tempête + SQLite pour un petit projet, et a été très heureux avec elle jusqu'à ce que j'ai ajouté multiprocessing.Essayez d'utiliser la base de données à partir de plusieurs processus a abouti à une "Base de données est verrouillée" l'exception".Je suis passé à SQLAlchemy, et le même code a fonctionné sans problèmes.
J'avais découvrez SQLAlchemy
Il est vraiment facile à utiliser et les modèles avec qui vous travaillez ne sont pas mauvais du tout. Django utilise SQLAlchemy pour ORM mais en l'utilisant, par lui-même vous permet d'utiliser la pleine puissance.
Voici un petit exemple sur la création et la sélection de l'orm objets
>>> 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')>
