SQLAlchemy est alambiqué?

Cela peut semble plutôt argumentatif, mais je suis juste allé à travers SQLAlchemy de ORM tutoriel et s'est terminé avec le code suivant:

from sqlalchemy import create_engine
from sqlalchemy import Table, Column, Integer, String, MetaData, ForeignKey
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker
engine = create_engine('sqlite:///:memory:', echo=True)
metadata = MetaData()
users_table = Table('users', metadata,
Column('id', Integer, primary_key=True),
Column('name', String),
Column('fullname', String),
Column('password', String)
)
metadata.create_all(engine)
Base = declarative_base()
class User(Base):
__tablename__ = 'users'
id = Column(Integer, primary_key=True)
name = Column(String)
fullname = Column(String)
password = Column(String)
def __init__(self, name, fullname, password):
self.name = name
self.fullname = fullname
self.password = password
def __repr__(self):
return "<User('%s','%s', '%s')>" % (self.name, self.fullname, self.password)
users_table = User.__table__
metadata = Base.metadata
Session = sessionmaker(bind=engine)
Session = sessionmaker()
Session.configure(bind=engine)  # once engine is available
session = Session()
# actually using the ORM isn't too bad..
ed_user = User('ed', 'Ed Jones', 'edspassword')
session.add(ed_user)
our_user = session.query(User).filter_by(name='ed').first() 
print our_user
session.add_all([
User('wendy', 'Wendy Williams', 'foobar'),
User('mary', 'Mary Contrary', 'xxg527'),
User('fred', 'Fred Flinstone', 'blah')])
ed_user.password = 'f8s7ccs'
print session.dirty
print session.new
session.commit()
for instance in session.query(User).order_by(User.id): 
print instance.name, instance.fullname
for name, fullname in session.query(User.name, User.fullname): 
print name, fullname

Cela semble incroyablement compliqué pour un Hello World table, surtout par rapport à l'à peu près similaire SQLObject code:

from sqlobject import SQLObject, StringCol, sqlhub, connectionForURI
sqlhub.processConnection = connectionForURI('sqlite:/:memory:')
class Person(SQLObject):
fname = StringCol()
mi = StringCol(length=1, default=None)
lname = StringCol()
Person.createTable()
p = Person(fname="John", lname="Doe")
p.mi = 'Q'
p2 = Person.get(1)
print p2
print p2 is p

Je comprends SQLAlchemy est "le plus fort", mais que la puissance semble venir à un coût, ou ai-je raté quelque chose?

L'alimentation a un coût? Que dites-vous?
SQLAlchemy de puissance se fait au prix de la simplicité d'utilisation?
Essayez Élixir comme mentionné ci-dessous, votre Bonjour tout le Monde sera très similaire à SQLObject, et vous serez toujours en mesure d'accéder à la SQLAlchemy couche. J'ai utilisé SQLObject et frustré par ses limites, et je suis très heureux avec l'Élixir de la mesure (il manque un peu de documentation et de soutien, mais l'utilisateur de base semble limité malheureusement).
On n'a pas tout simplement ajouter un point d'interrogation à une instruction.

InformationsquelleAutor dbr | 2009-05-13

86

Bien, il y a une chose qui vous manque: le tutoriel que vous mentionnez n'est pas "construire" un exemple complet, les différents bouts de code ne sont pas destinés à être concaténés dans un seul fichier source. Plutôt, ils décrivent les différentes manières de la bibliothèque peut être utilisée. Pas besoin d'essayer de faire la même chose encore et encore vous-même.

Laissant de côté le fait-de-la-orm partie de votre exemple, le code pourrait ressembler à ceci:
```
from sqlalchemy import *
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker, scoped_session
engine = create_engine('sqlite:///:memory:', echo=True)
Base = declarative_base(bind=engine)
Session = scoped_session(sessionmaker(engine))
class User(Base):
__tablename__ = 'users'
id = Column(Integer, primary_key=True)
name = Column(String)
fullname = Column(String)
password = Column(String)
Base.metadata.create_all()
```
Le "déclaratif" extension prend en charge la définition de la table et de la cartographie à votre classe, vous n'avez pas besoin de déclarer le users_table vous-même. L'Utilisateur de la classe permettra également à l'instanciation avec le mot-clé arguments, comme User(name="foo"), (mais pas les arguments de position tout de même).
J'ai aussi ajouté l'utilisation de scoped_session, ce qui signifie que vous pouvez utiliser directement Session sans avoir à instancier (il va instancier une nouvelle session si il n'est pas déjà présent dans le thread en cours, ou la réutilisation de l'existant contraire)
- Qui ressemble un peu plus raisonnable que le code que j'ai fini avec. Merci!
- Je suis très hésitant sur l'utilisation de scoped_session pour rien; Sauf si vous savez pourquoi vous avez besoin de thread local storage, vous devez instancier la session explicitement et de les passer en tant que de besoin.
- Je suis en complet désaccord. scoped_session prend toutes les conjectures et inutile argument en passant de l'utilisation de sessions. Vous venez de définir votre scoped_session classe au début, puis instancier partout où vous avez besoin d'accéder à la session, et le système fait le reste. J'ai trouvé que c'était très pratique pour toutes les applications web que j'ai écrit.
- Dans le cas de web-apps, scoped_session peut être un bon ajustement; tant que les besoins de votre application exactement session par demande, et à l'aide de votre un une demande par modèle de thread. Si ce n'est pas vrai, vous pourriez avoir besoin pour opérer sur la base de données en dehors d'un contexte de demande; si vous avez besoin de coordonner les opérations à travers de multiples bases de données, si vous effectuez un travail dans un système de manière à améliorer les performances, cette hypothèse commence à se décomposer.
- Est-il nécessaire de définir le moteur de Base, et de la Session dans la portée de module?? C'est un peu brut pour les autres modules, que l'importation de ce module. Ils n'ont pas besoin de savoir à propos de l'Utilisateur interne ORM membres. Je suis également pas tout à fait saisir pourquoi le moteur et la Base doit être instancié à l'intérieur de chaque module de Modèle.
- Sqlalchemy du problème, c'est que c'est toujours compliquée. La structure du module est un gâchis, la documentation est incroyablement difficile à trouver pour quelqu'un qui n'est pas encore connu, et le dev est forcé d'écrire de grandes quantités de passe-partout sans raison particulière autre que l'absence de l'architecture de la supervision. Si le package a été bien conçu, cet exemple aurait une ligne pour un couple d'importations et d'une définition de classe. Rien d'autre ne devrait être nécessaire pour définir une table.
InformationsquelleAutor Steven

Les exemples de code que vous donnez ne sont pas des pommes avec des pommes. La SQLAlchemy version pourrait être réduite vers le bas un peu:

from sqlalchemy import create_engine
from sqlalchemy import Table, Column, Integer, String, MetaData, ForeignKey
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker
engine = create_engine('sqlite:///:memory:', echo=True)
Base = declarative_base()
class User(Base):
__tablename__ = 'users'
id = Column('id', Integer, primary_key=True)
name = Column('name', String)
fullname = Column('fullname', String)
password = Column('password', String)
def __repr__(self):
return "" % (self.name, self.fullname, self.password)
Base.metadata.create_all(engine)
Session = sessionmaker(bind=engine)
session = Session()
# actually using the ORM isn't too bad..
ed_user = User(name='ed', fullname='Ed Jones', password='edspassword')
session.add(ed_user)
our_user = session.query(User).filter_by(name='ed').first()
session.add_all([
User(name='wendy', fullname='Wendy Williams', password='foobar'),
User(name='mary', fullname='Mary Contrary', password='xxg527'),
User(name='fred', fullname='Fred Flinstone', password='blah')])
ed_user.password = 'f8s7ccs'
session.flush()
for instance in session.query(User).order_by(User.id):
print instance.name, instance.fullname
for name, fullname in session.query(User.name, User.fullname):
print name, fullname

Vous pouvez également trouver des Elixir plus comme SQLObject (mais puisque je n'ai pas utilisé non plus, c'est juste une supposition).

Ne pas avoir utilisé SQLObject à tous, je ne peux pas commenter sur ce que SA fait mieux. Mais j'ai eu de grandes expériences avec SA, surtout lorsqu'il s'agit compliqué, dans le monde réel, les anciens schémas. Il fait un bon travail de venir avec une bonne requêtes SQL par défaut, et il y a beaucoup de façons de les améliorer.

J'ai trouvé SQLAlchemy de l'auteur elevator pitch de tenir assez bien dans la pratique.

InformationsquelleAutor Jacob Gabrielson

1

Avoir utilisé SQLObject (et que par la lecture de SQLAlchemy), je peux dire que l'un des SQLObject des points forts est la facilité et la simplicité avec laquelle vous pouvez obtenir des choses faites. Aussi, un excellent soutien est fourni par le groupe email (https://lists.sourceforge.net/lists/listinfo/sqlobject-discuss) qui obtient des réponses pour vous assez rapidement.

InformationsquelleAutor Joe L.

Essayer Rapide ORM, c'est encore plus simple:

from quick_orm.core import Database
from sqlalchemy import Column, String
class User(object):
__metaclass__ = Database.DefaultMeta
name = Column(String(30))
if __name__ == '__main__':
database = Database('sqlite://')
database.create_tables()
user = User(name = 'Hello World')
database.session.add_then_commit(user)
user = database.session.query(User).get(1)
print 'My name is', user.name

Rapide ORM est construit sur SQLAlchemy, donc, on pourrait dire que SQLAlchemy pourrait être aussi simple que de SQLObject.

Je suis désolé que quick_orm n'est plus maintenue.

InformationsquelleAutor Tyler Long

1

Bien, SQLAlchemy est divisé en différentes parties, la base principale de la partie tout simplement les poignées de la DB, en transformant votre python construit des requêtes en langage SQL pour les sous-jacents DB. Ensuite, il ya la prise en charge des sessions, l'orm, et la nouvelle syntaxe déclarative.

Ressemble SQLObject (je ne peux pas dire pour sûr, ne l'ai pas utilisé depuis de nombreuses années, et même alors, seulement une fois) saute plus et ne l'ORM partie tout de suite. Souvent, cela rend les choses plus faciles pour de simples données (que vous pouvez sortir avec dans la plupart des cas), mais SQLAlchemy permet plus complexe db mises en page, et de descendre et sale avec la db si vous en avez vraiment besoin.
- SQLObject semble à l'appui des choses plus avancées, comme l'un-à-plusieurs ou plusieurs-à-un/plusieurs-à-plusieurs liens (qui couvre toutes les bases de données de mise en page que j'ai vu) et des opérations.
InformationsquelleAutor Nico
0

vous dire "alambiqué".... quelqu'un pourrait dire "flexible". Parfois, vous devez parfois vous n'avez pas. N'est-il pas incroyable que vous avez un choix?
- Bien sûr, mais je dis "compliquée" car il semble que de vous obliger à utiliser une partie de ses caractéristiques pour faire des trucs de base. La flexibilité est grande, mais pas si elle comprend cinq lignes d'importation est juste pour commencer!
InformationsquelleAutor Tom Willis

Vous devez vous connecter pour publier un commentaire.