Flask-SQLAlchemy:conexiones sobre la marcha a múltiples bases de datos

Una base de datos

El motor es lo que le permite utilizar la agrupación de conexiones. De forma predeterminada, persistirá las conexiones entre las solicitudes. El uso básico (sin cosas sofisticadas como scoped_session o sessionmaker ) es así:

engine = create_engine(...)

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

Además de esto, puede agregar scoped_session y 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 hace su vida más fácil al proporcionar todo esto:

db = SQLAlchemy(app)

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

Bases de datos múltiples

Puede extender fácilmente este concepto a múltiples bases de datos:

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 ""

Cuando agrega scoped_session y 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 ""

Esto se vuelve un poco molesto cuando tiene muchas bases de datos, en cuyo caso probablemente debería escribir una clase de registro para realizar un seguimiento de todos los motores y sesiones:

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 ""

Deberá agregar algún tipo de LRU encima para que no haya una creación ilimitada de motores.

flask-sqlalchemy tiene soporte para una forma limitada de múltiples bases de datos donde cada uno de su modelo se conecta a una base de datos diferente. Si esto se aplica a usted, la documentación está aquí .