कुप्पी-SQLAlchemy - कई डेटाबेस के लिए फ्लाई कनेक्शन पर

एक डेटाबेस

इंजन वह है जो आपको कनेक्शन पूलिंग का उपयोग करने की अनुमति देता है। डिफ़ॉल्ट रूप से, यह अनुरोधों के बीच कनेक्शन जारी रखेगा। मूल उपयोग (बिना फैंसी चीजों जैसे scoped_session .) या sessionmaker ) इस प्रकार है:

engine = create_engine(...)

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

इसके ऊपर आप scoped_session add जोड़ सकते हैं और 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 यह सब प्रदान करके आपके जीवन को आसान बनाता है:

db = SQLAlchemy(app)

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

एकाधिक डेटाबेस

आप इस अवधारणा को आसानी से कई डेटाबेस तक बढ़ा सकते हैं:

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

जब आप scoped_session जोड़ते हैं और 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 ""

जब आपके पास कई डेटाबेस होते हैं तो यह थोड़ा परेशान हो जाता है, इस मामले में आपको शायद सभी इंजनों और सत्रों का ट्रैक रखने के लिए एक रजिस्ट्री क्लास लिखनी चाहिए:

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

आपको इसके ऊपर किसी प्रकार का LRU जोड़ना होगा ताकि इंजनों का कोई असीमित निर्माण न हो।

flask-sqlalchemy एकाधिक डेटाबेस के सीमित रूप के लिए समर्थन है जहां आपका प्रत्येक मॉडल एक अलग डेटाबेस से जुड़ता है। यदि यह आप पर लागू होता है, तो दस्तावेज़ीकरण यहां है। ।