Question

方法一：使用http://flask.pocoo.org/docs/tutorial/dbcon/和http://flask.pocoo.org/docs/patterns/sqlite3/

中的特殊g对象

import sqlite3
from flask import g

DATABASE = '/path/to/database.db'

def connect_db():
    return sqlite3.connect(DATABASE)

@app.before_request
def before_request():
    g.db = connect_db()

@app.teardown_request
def teardown_request(exception):
    if hasattr(g, 'db'):
        g.db.close()

方法二：使用https://github.com/mitsuhiko/flask/blob/master/examples/flaskr/flaskr.py

中的神秘_app_ctx_stack

from sqlite3 import dbapi2 as sqlite3
from flask import Flask, request, session, g, redirect, url_for, abort, \
     render_template, flash, _app_ctx_stack
def get_db():
    """Opens a new database connection if there is none yet for the
    current application context.
    """
    top = _app_ctx_stack.top
    if not hasattr(top, 'sqlite_db'):
        top.sqlite_db = sqlite3.connect(app.config['DATABASE'])
    return top.sqlite_db


@app.teardown_appcontext
def close_db_connection(exception):
    """Closes the database again at the end of the request."""
    top = _app_ctx_stack.top
    if hasattr(top, 'sqlite_db'):
        top.sqlite_db.close()

哪种方法更好？有什么区别？

Answer 1

两者之间的区别在于方法一在g.db上创建了一个连接，无论您是否需要它，而方法二只在您在该应用程序上下文中第一次调用get_db时创建连接

如果你比较两者，使用这个设置：

yourapp = Flask(__name__)

# setup g.db or app_context here
# Add a logging statement (print will do)
# to the get_db or before_request functions
# that simply says "Getting the db connection ..."
# Then access / and /1

@yourapp.route("/")
def index():
    return "No database calls here!"

@yourapp.route("/<int:post_id>")
def show_post(post_id):
    # get a post using g.db or get_db
    return "Went to the DB and got {!r}".format(post)

当您使用/设置（@app.before_request）点击g.db时，您会看到是否使用的连接使用_app_context路线时，只有在拨打get_db 时才能获得连接。

公平地说，您还可以向g添加描述符，该描述符将执行相同的延迟连接（或者在现实生活中，从连接池获取连接）。在两个案例中，您可以使用更多魔法（werkzeug.local.LocalProxy来准确）来创建自己的g，其行为类似于current_app，{{1 }和request（thread local）。

Answer 2

第一个问题是即使不需要连接也能获得连接。第二个方面是使用第三方框架内部的缺点，而且它非常难以理解。

在这两个人中，第二个可能是更好的选择。它不仅没有为不需要的路由获取连接，而且如果你沿着任何不需要的路径下去，它也不会获得连接，即使路由中的其他代码路径需要一个。（例如，如果您有一些表单验证，则只有在验证通过时才需要连接;当验证失败时，这不会打开。）您只能在使用此设置之前获取连接。

但是，您可以避免弄乱内部并仍然获得所有这些好处。就个人而言，我创建了自己的小全局方法：

import flask
import sqlite3

def request_has_connection():
    return hasattr(flask.g, 'dbconn')

def get_request_connection():
    if not request_has_connection():
        flask.g.dbconn = sqlite3.connect(DATABASE)
        # Do something to make this connection transactional.
        # I'm not familiar enough with SQLite to know what that is.
    return flask.g.dbconn

@app.teardown_request
def close_db_connection(ex):
    if request_has_connection():
        conn = get_request_connection()
        # Rollback
        # Alternatively, you could automatically commit if ex is None
        # and rollback otherwise, but I question the wisdom 
        # of automatically committing.
        conn.close()

然后，在整个应用中，始终通过get_request_connection获取您的连接，就像您的get_db功能一样。直截了当，效率高。基本上，两全其美。

编辑：

回想起来，我真的不喜欢这些是全局方法的事实，但我认为它的原因是因为这就是Flask的工作方式：它为你提供了实际指向线程本地的“全局”。

Answer 3

我推荐Flask-SQLAlchemy，它扩展了SQLAlchemy以便在Flask中使用，因此它支持许多不同的数据库。（来自Flask-SQLAlchemy文档的示例）

设定：

from flask import Flask
from flask.ext.sqlalchemy import SQLAlchemy

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:////tmp/test.db'
db = SQLAlchemy(app)


class User(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(80), unique=True)
    email = db.Column(db.String(120), unique=True)

    def __init__(self, username, email):
        self.username = username
        self.email = email

    def __repr__(self):
        return '<User %r>' % self.username

现在，您只需导入/使用User类即可访问数据库中的User表。

创建新用户：

>>> from yourapplication import User
>>> admin = User('admin', 'admin@example.com')
>>> guest = User('guest', 'guest@example.com')

将用户添加到数据库：

>>> db.session.add(admin)
>>> db.session.add(guest)
>>> db.session.commit()

查询已存在于数据库中的用户：

>>> users = User.query.all()
[<User u'admin'>, <User u'guest'>]
>>> admin = User.query.filter_by(username='admin').first()
<User u'admin'>

Answer 4

我选择方法一 - 更具可读性，更少“黑客”。

方法2可能设计用于烧瓶扩展集成（example和explanation of app-ctx-stack）。虽然它们可能具有非常相似的效果，但方法一应该用于正常情况。

Answer 5

要保留同一flask会话内的数据库连接，可以使用应用程序上下文并分配数据库连接。如果连接断开，则上下文将在连续轮询连接对象时尝试重新建立连接。

from flask import Flask
application = Flask(__name__)


def connect_to_database():
  db_handler = SqliteDBConnect("uid={0};""pwd={1}".format(UID, PWD),
                                table_prefix="{}".format(TBL_PRFX))
  return db_handler

fd = {'_database': None}
def get_db():
  db = fd['_database']
  if not isinstance(db, SqliteDBConnect):
    fd['_database'] = connect_to_database()
    db = fd['_database']
return db

with application.app_context():
  #Get DB connection from application's context
  db = LocalProxy(lambda: get_db())

连接到Flask中的数据库，哪种方法更好？

5 个答案:

编辑：