Flask-SQLAlchemy - connexions à la volée à plusieurs bases de données

Une base de données

Le moteur est ce qui vous permet d'utiliser le regroupement de connexions. Par défaut, il conservera les connexions entre les requêtes. L'utilisation de base (sans choses fantaisistes comme scoped_session ou sessionmaker ) est comme ceci :

engine = create_engine(...)

@app.route(...)
def foo():
    session = Session(bind=engine)
    try:
        session.query(...)
        session.commit()
    finally:
        session.close()
    return ""

En plus de cela, vous pouvez ajouter scoped_session et sessionmaker :

engine = create_engine(...)
Session = sessionmaker(bind=engine)
session = scoped_session(Session, scopefunc=...)

@app.route(...)
def foo():
    try:
        session.query(...)
        session.commit()
    finally:
        session.close()
    return ""

flask-sqlalchemy vous facilite la vie en fournissant tout cela :

db = SQLAlchemy(app)

@app.route(...)
def foo():
    db.session.query(...)
    db.session.commit()
    return ""

Bases de données multiples

Vous pouvez facilement étendre ce concept à plusieurs bases de données :

engine1 = create_engine(...)
engine2 = create_engine(...)

@app.route(...)
def foo():
    session = Session(bind=choose_engine_for_user())
    try:
        session.query(...)
        session.commit()
    finally:
        session.close()
    return ""

Lorsque vous ajoutez scoped_session et sessionmaker :

engine1 = create_engine(...)
engine2 = create_engine(...)
Session1 = sessionmaker(bind=engine1)
Session2 = sessionmaker(bind=engine2)
session1 = scoped_session(Session1, scopefunc=...)
session2 = scoped_session(Session2, scopefunc=...)

@app.route(...)
def foo():
    session = choose_session_for_user()
    try:
        session.query(...)
        session.commit()
    finally:
        session.close()
    return ""

Cela devient un peu ennuyeux lorsque vous avez de nombreuses bases de données, auquel cas vous devriez probablement écrire une classe de registre pour garder une trace de tous les moteurs et sessions :

class SessionRegistry(object):
    _registry = {}

    def get(self, url, **kwargs):
        if url not in self._registry:
            engine = create_engine(url, **kwargs)
            Session = session_maker(bind=engine)
            session = scoped_session(Session, scopefunc=...)
            self._registry[url] = session
        return self._registry[url]

registry = SessionRegistry()

@app.route(...)
def foo():
    session = registry.get(...)
    try:
        session.query(...)
        session.commit()
    finally:
        session.close()
    return ""

Vous devrez ajouter une sorte de LRU par-dessus afin qu'il n'y ait pas de création illimitée de moteurs.

flask-sqlalchemy prend en charge une forme limitée de bases de données multiples où chacun de vos modèles se connecte à une base de données différente. Si cela s'applique à vous, la documentation est ici .