Python Flask框架 -- ORM模型外键与表关系

宇宙核

已于 2024-03-25 00:11:33 修改

阅读量1.1k

点赞数 40

分类专栏： Flask 文章标签： flask 数据库 python

于 2024-03-24 13:15:52 首次发布

本文链接：https://blog.csdn.net/lpx666168/article/details/136985546

版权

Flask 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

表关系

关系型数据库一个强大的功能，就是多个表之间可以建立关系。比如文章表中，通常需要保存作者数据，但是我们不需要直接把作者数据放到文章表中，而是通过外键引用用户表。这种强大的表关系，可以存储非常复杂的数据，并且可以让查询非常迅速。在Flask-SQLAlchemy中，同样也支持表关系的建立。表关系建立的前提，是通过数据库层面的外键实现的。表关系总体来讲可以分为三种，分别是：一对多（多对一）、一对一、多对多。

外键

外键是数据库层面的技术，在Flask-SQLAlchemy中支持创建ORM模型的时候就指定外键，创建外键是通过db.ForeignKey实现的。比如这里我们创建一个Article表，这个表有一个author_id字段，通过外键引用user表的id字段，用来保存文章是由谁编写的，那么Article的模型代码如下。

class Article(db.Model):
    __tablename__ = "article"
    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    title = db.Column(db.String(200), nullable=False)
    content = db.Column(db.Text, nullable=False)

    # 添加作者的外键
    author_id = db.Column(db.Integer, db.ForeignKey("user.id"))

以上代码，除了添加常规title、content属性外，还增加了一个author_id，author_id通过db.ForeignKey(user.id)引用了之前我们创建的user表的id字段。这里有个细节需要注意，author_id因为引用user表的id字段，所以他的类型必须跟user表的id字段一致，否则会报错。

一对多

1.建立关系

以上通过外键，实际上己经建立起一对多的关系，一篇文章只能引用一个作者，但是一个作者可以被多篇文章引用。但是以上只是建立了一个外键，通过Article的对象，还是无法直接获取到author_ id引用的那个User对象。为了达到操作ORM对象就跟操作普通Python对象一样，Flask-SQLAlchemy提供了db.relationship来引用外键所指向的那个ORM模型。
在以上的Article模型中，我们添加db.relationiship，示例代码如下。

class Article(db.Model):
    __tablename__ = "article"
    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    title = db.Column(db.String(200), nullable=False)
    content = db.Column(db.Text, nullable=False)
    author_id = db.Column(db.Integer, db.ForeignKey("user.id"))
    author = db.relationship("User")

我们添加了一个author属性，这个属性通过db.relationship与User模型建立了联系，以后通过Article的实例对象访问author的时候，比如article.author,那么Flask-SQLAlchemy会自动根据外键author_id从user表中寻找数据，并形成User模型实例对象。以下我们通过创建Article对象，并通过访问Article实例对象上的author属性来关联User对象，示例代码如下。

@app.route('/article/add')
def article_add():
    user = User.query.first()
    article = Article(title="aa", content="bb", author=user)
    db.session.add(article)
    db.session.commit()

    article = Article.query.filter_by(title='aa').first()
    print(article.author.username)

以上代码中，我们先是创建了一个article对象并添加到数据库中，接下来从数据库中提取，然后通过article.author.username可以访问到他的用户名。

2.建立双向关系

现在的Article模型可以通过author属性访问到对应的User实例对象。但是User实例对象无法访问到和他关联的所有Article实例对象。因此为了实现双向关系绑定，我们还需要在User模型上添加一个db.relationship类型的articles属性，并且在User模型和Article模型双方的db.relationship上，都需要添加一个back populates参数，用于绑定对方访问自己的属性，示例代码如下。

class User(db.Model):
    __tablename__ = "user"
    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    username = db.Column(db.String(100))
    password = db.Column(db.String(100))

    articles = db.relationship("Article", back_populates="author")


class Article(db.Model):
    __tablename__ = "article"
    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    title = db.column(db.String(200), nullable=False)
    content = db.Column(db.Text, nullable=False)

    author_id = db.Column(db.Integer, db.ForeignKey("user.id"))
    author = db.relationship("User", back_populates="articles")

在User端绑定了articles属性后，现在双方都能通过属性直接访问到对方了，示例代码如下。

user = User.query.first()
for article in user.articles:
    print(article.title)

3.简化关系定义

以上User和Article模型中，我们通过在两边的db.relationship上，传递back_populates参数来实现双向绑定，这种方式有点啰嗦，我们还可以通过只在一个模型上定义db.relationship类型属性，并且传递backref参数，来实现双向绑定，示例代码如下。

class User(db.Model):
    __tablename__ = "user"
    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    username = db.Column(db.String(100))
    password = db.Column(db.String(100))


class Article(db.Model):
    __tablename__ = "article"
    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    title = db.column(db.String(200), nullable=False)
    content = db.Column(db.Text, nullable=False)

    author_id = db.Column(db.Integer, db.ForeignKey("user.id"))
    author = db.relationship("User", backref="articles")

以上代码中，我们删除了User模型上的articles属性，并且在Article模型上，将author属性的db.relationship中的back_populates修改为backref。backref参数的功能更加强大，它可以自动给对方添加db.relationship的属性。
这种方式虽然方便，但是在模型比较多，项目团队人数较多的情况，也容易造成困扰。比如User模型上根本没有看到定义articles属性，但是却在Article模型上创建了，这着实会让人摸不着头脑。因此为了更加直观和方便团队协作，我们建议使用back_populates来实
现双向绑定。

实例：

class User(db.Model):
    __tablename__ = 'user'
    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    username = db.Column(db.String(100), nullable=False)
    password = db.Column(db.String(100), nullable=False)

    # articles = db.relationship("Article", back_populates="author")  建立双向关系，这个和下面那个要一一对应


class Article(db.Model):
    __tablename__ = "article"
    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    title = db.Column(db.String(200), nullable=False)
    content = db.Column(db.Text, nullable=False)

    # 添加作者的外键
    author_id = db.Column(db.Integer, db.ForeignKey("user.id"))
    # author = db.relationship("User", back_populates="articles")    建立双向关系，这个和上面那个要一一对应

    # backref会自动给User模型添加一个article的属性，用来获取文章列表
    author = db.relationship("User", backref="articles")

    # 关联表
    # author = db.relationship("User")


article = Article(title='Flask学习', content='Flaskxxx')

with app.app_context():  # 请求应用上下文
    db.create_all()  # 把所有的表同步到数据库中去

运行后，在数据库中刷新

刷新前：

刷新后：

此时成功创建了article表，点击设计表进去查看

可以看到已经和外键建立了联系

下面继续：

@app.route('/article/add')
def article_add():
    article1 = Article(title='Flask学习', content='Flaskxxx')
    article1.author=User.query.get(2)

    article2 = Article(title='学习', content='Flask')
    article2.author = User.query.get(2)

    db.session.add_all([article1,article2])
    db.session.commit()
    return '文章添加成功'

运行前article表里面还是空的：

运行后：

刷新article表：

文章查找：

@app.route('/article/query')
def query_article():
    user = User.query.get(2)
    for article in user.articles:
        print(article.title)
    return '文章查找成功'

运行：

然后在终端上可以看到查找结果：

说明user和article已经建立起了联系

app.py 完整代码：

from flask import Flask
from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)

# MySQL所在的主机名或域名
HOSTNAME = '127.0.0.1'
# MySQL监听的端口号，默认3306
PORT = 3306
# 连接MySQL的用户名,用自己的
USERNAME = 'root'
# 连接MySQL的密码,用自己的
PASSWORD = '***'
# MySQL上创建的数据库名称
DATABASE = 'database_learn'

app.config[
    'SQLALCHEMY_DATABASE_URI'] = f'mysql+pymysql://{USERNAME}:{PASSWORD}@{HOSTNAME}:{PORT}/{DATABASE}?charset=utf8mb4'

# 在app.config中设置好连接数据库的信息
# 然后使用SQLAlchemy(app)创建一个db对象
# SQLAlchemy会自动读取app.config中连接数据库的信息
db = SQLAlchemy(app)


class User(db.Model):
    __tablename__ = 'user'
    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    username = db.Column(db.String(100), nullable=False)
    password = db.Column(db.String(100), nullable=False)

    # articles = db.relationship("Article", back_populates="author")  建立双向关系，这个和下面那个要一一对应


class Article(db.Model):
    __tablename__ = "article"
    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    title = db.Column(db.String(200), nullable=False)
    content = db.Column(db.Text, nullable=False)

    # 添加作者的外键
    author_id = db.Column(db.Integer, db.ForeignKey("user.id"))
    # author = db.relationship("User", back_populates="articles")    建立双向关系，这个和上面那个要一一对应

    # backref会自动给User模型添加一个article的属性，用来获取文章列表
    author = db.relationship("User", backref="articles")

    # 关联表
    # author = db.relationship("User")


# article = Article(title='Flask学习', content='Flaskxxx')

with app.app_context():  # 请求应用上下文
    db.create_all()  # 把所有的表同步到数据库中去


@app.route('/article/add')
def article_add():
    article1 = Article(title='Flask学习', content='Flaskxxx')
    article1.author=User.query.get(2)

    article2 = Article(title='学习', content='Flask')
    article2.author = User.query.get(2)

    db.session.add_all([article1,article2])
    db.session.commit()
    return '文章添加成功'


@app.route('/article/query')
def query_article():
    user = User.query.get(2)
    for article in user.articles:
        print(article.title)
    return '文章查找成功'


if __name__ == '__main__':
    app.run()