用 Flask 来写个轻博客 (6) — (M)VC_models 的关系(one to many)

àì夳堔傛蜴生んèń 2022-01-06 23:47 126阅读 0赞

# 目录 #

*  目录
 *  前文列表
 *  扩展阅读
 *  前言
 *  一对多
    
     *  再一次 sync db
 *  How to use

# 前文列表 #

[用 Flask 来写个轻博客 (1) — 创建项目 ][Flask _ _1_ _ _]  
[用 Flask 来写个轻博客 (2) — Hello World！ ][Flask _ _2_ _ Hello World_]  
[用 Flask 来写个轻博客 (3) — (M)VC\_连接 MySQL 和 SQLAlchemy ][Flask _ _3_ _ _M_VC_ MySQL _ SQLAlchemy]  
[用 Flask 来写个轻博客 (4) — (M)VC\_创建数据模型和表 ][Flask _ _4_ _ _M_VC_]  
[用 Flask 来写个轻博客 (5) — (M)VC\_SQLAlchemy 的 CRUD 详解 ][Flask _ _5_ _ _M_VC_SQLAlchemy _ CRUD _]

# 扩展阅读 #

[SQLAlchemy\_定义(一对一/一对多/多对多)关系 ][SQLAlchemy_]

# 前言 #

models 中的关系能够映射成为关系型数据库表中的关系，models 中可以相互建立引用，使得相关联的数据能够很容易的一次性的从数据库中取出。

# 一对多 #

*  首先继续在 models.py 中建立一个 Post models 来表示 Blog 中的文章。而且一个用户 User 可以拥有多篇文章 Post，他们之间的关系是一对多。

表示一对多的关系时，在子表类 Post 中需要通过 foreign key (外键)引用父表类 User。

class Post(db.Model):
        """Represents Proected posts."""
    
        __tablename__ = 'posts'
        id = db.Column(db.String(45), primary_key=True)
        title = db.Column(db.String(255))
        text = db.Column(db.Text())
        publish_date = db.Column(db.DateTime)
        # Set the foreign key for Post
        user_id = db.Column(db.String(45), db.ForeignKey('users.id'))
    
        def __init__(self, title):
            self.title = title
    
        def __repr__(self):
            return "<Model Post `{}`>".format(self.title)

其中 `user_id` 字段是 posts 表的外键，代表了数据库中的一种约束规则 —— 外键约束。这种规则强制规定了字段 `user_id` 的值必须同时存在于 `User.id` 列中。**用来保证每一篇 post 都能对应找到一个 user，而且一个 user 能够对应多篇 posts。**

**NOTE**: 如果你没有在父表类指定 `__tablename__` 属性，那么这一条语句我们应该这么写：

user_id = db.Column(db.String(45), db.ForeignKey('User.id'))

但是一般不建议写成这样，因为在 SQLAlchemy 初始化期间， User 对象可能还没有被创建出来，所以同时也建议在定义 models class 的时候应该指定 `__tablename__` 属性。

*  然后我们还需要在父表类 User 中定义出这种 one to many 的关系：

class User(db.Model):
        """Represents Proected users."""
    
        # Set the name for table
        __tablename__ = 'users'
        id = db.Column(db.String(45), primary_key=True)
        username = db.Column(db.String(255))
        password = db.Column(db.String(255))
        # Establish contact with Post's ForeignKey: user_id
        posts = db.relationship(
            'Post',
            backref='users',
            lazy='dynamic')
    
        def __init__(self, id, username, password):
            self.id = id
            self.username = username
            self.password = password
    
        def __repr__(self):
            """Define the string format for instance of User."""
            return "<Model User `{}`>".format(self.username)

*  **db.relationsformat(self.username)hip**： 会在 SQLAlchemy 中创建一个虚拟的列，该列会与 `Post.user_id` (db.ForeignKey) 建立联系。这一切都交由 SQLAlchemy 自身管理。
 *  **backref**：用于指定表之间的双向关系，如果在一对多的关系中建立双向的关系，这样的话在对方看来这就是一个多对一的关系。
 *  **lazy**：指定 SQLAlchemy 加载关联对象的方式。
    
     *  `lazy=subquery`: 会在加载 Post 对象后，将与 Post 相关联的对象全部加载，这样就可以减少 Query 的动作，也就是减少了对 DB 的 I/O 操作。但可能会返回大量不被使用的数据，会影响效率。
     *  `lazy=dynamic`: 只有被使用时，对象才会被加载，并且返回式会进行过滤，*如果现在或将来需要返回的数据量很大，建议使用这种方式*。Post 就属于这种对象。

## 再一次 sync db ##

每一次新增了 models class，都需要导入到 manage.py 中，在通过 manager shell 来同步数据库。

# import Flask Script object
    from flask.ext.script import Manager, Server
    import main
    import models
    
    # Init manager object via app object
    manager = Manager(main.app)
    
    # Create some new commands
    manager.add_command("server", Server())
    
    @manager.shell
    def make_shell_context():
        """Create a python CLI.
    
        return: Default import object
        type: `Dict`
        """
        return dict(app=main.app,
                    db=models.db,
                    User=models.User,
                    Post=models.Post)
    
    if __name__ == '__main__':
        manager.run()

**NOTE**： 因为前面我们对原有的 users 表结构做了修改，所以我们需要将 users 表删除，再重新同步数据库。但需要注意，这是一种非常不推荐的方法，以后我们会介绍一种更加科学的增量同步数据库的方法。

mysql> DROP TABLE users;

*  重新同步数据库

(env) [root@flask-dev JmilkFan-s-Blog]# python manage.py shell
    >>> db.create_all()
    >>> Post
    <class 'models.Post'>

# How to use #

>>> from uuid import uuid4
    # 实例化一个 User 的对象
    >>> user = User(id=str(uuid4()), username='jmilkfan', password='fanguiju')
    # 写入一条 users 记录     
    >>> db.session.add(user)
    >>> db.session.commit()
    
    >>> user.posts
    <sqlalchemy.orm.dynamic.AppenderBaseQuery object at 0x22bc410>

**NOTE**: 因为 user 的关联对象的加载方式为动态方式，所以 user.posts 会返回一个 Query 对象，需要调用 filter()/all()/first() 来获取实际需要被使用到的对象。  
反之，如果是子查询方式的话，就是直接将关联对象全部返回

# 现在因为还没有添加 posts 的记录所以为空
    >>> user.posts.all()
    []
    
    # 实例化一个 Post 的对象
    >>> post_one = Post('First Post')
    # 主键值是非空的，必须指定一个，否则会报错
    >>> post_one.id = str(uuid4())
    # 指定该 post 是属于哪一个 user 的
    >>> post_one.user_id = user.id
    >>> db.session.add(post_one)
    >>> db.session.commit()
    
    >>> user.posts.all()
    [<Model Post `First Post`>]

**NOTE**： 必须在 commit 了 post\_one 对象之后，user 才能够通过关系来获取关联对象 posts。

上面一个例子是为 user 添加一个 post，那么反过来能不能为一个 post 指定一个 user 呢？  
如果我们有使用到 `backref` 参数的话，那答案就是肯定的，这也是该参数所谓 *双向* 的含义。

# 获取一个已经存在数据库中的记录 user 
    >>> user = db.session.query(User).first()
    >>> user.id
    u'ad7fd192-89d8-4b53-af96-fceb1f91070f'
    
    # 实例化一个 Post 的对象 post_second
    >>> post_second = Post('Second Post')
    # 必须为其设置主键值
    >>> post_second.id = str(uuid4())
    # 现在该 post_second 对象是没有关联到任何 user 的
    >>> post_second.users
    # 为 post_second 指定一个 user 对象
    >>> post_second.users = user

**NOTE**:\# 另一种建立联系的写法为 `user.posts.append(post_second)`  
因为 user.posts 本质上是一个列表，只要该列表中存在 post 那么 post 就是属于这个 user 的

# 将 post_second 写入数据库
    >>> db.session.add(post_second)
    >>> db.session.commit()
    # 写入完成之后，user 才能够通过关系来访问到属于其下的 posts
    >>> user.posts.all()
    [<Model Post `Second Post`>, <Model Post `First Post`>]

**ERROR LOG**：

InvalidRequestError: This Session's transaction has been rolled back due to a previous exception during flush. To begin a new transaction with this Session, first issue Session.rollback(). Original exception was: (pymysql.err.InternalError) (1364, u"Field 'id' doesn't have a default value") [SQL: u'INSERT INTO posts (title, text, publish_date, user_id) VALUES (%(title)s, %(text)s, %(publish_date)s, %(user_id)s)'] [parameters: {
          'text': None, 'title': 'First Post', 'publish_date': None, 'user_id': '9ecae9b3-f4d2-4c8e-b033-616bb1642842'}]

**TS**: 因为 commit 一个指定了 user\_id 的 port 对象时，实际上数据库中还不存在被关联的 user 对象，导致报错。

转载于:https://www.cnblogs.com/jmilkfan-fanguiju/p/7532283.html

[Flask _ _1_ _ _]: http://blog.csdn.net/jmilk/article/details/53150084
[Flask _ _2_ _ Hello World_]: http://blog.csdn.net/jmilk/article/details/53152158
[Flask _ _3_ _ _M_VC_ MySQL _ SQLAlchemy]: http://blog.csdn.net/jmilk/article/details/53153382
[Flask _ _4_ _ _M_VC_]: http://blog.csdn.net/jmilk/article/details/53184903
[Flask _ _5_ _ _M_VC_SQLAlchemy _ CRUD _]: http://blog.csdn.net/jmilk/article/details/53187575
[SQLAlchemy_]: http://blog.csdn.net/jmilk/article/details/52445093