5、flask第五站-简单数据库_db.drop_all()

数据库基础知识

1、关系型数据库

特征：多表查询，设有外键，节省空间但是查询慢。

常见的有：Oracle、DB2、Microsoft SQL Server、Microsoft Access、MySQL等。

2、非关系型数据库

特征：普通的键值对，查询快，但是占用空间大。

常见的有：NoSql、Cloudant。

使用Flask-SQLAlchemy管理数据库

1、准备

【init.py】

from flask_sqlalchemy import SQLAlchemy
#导入数据库
import os
base_path = os.path.abspath(os.path.dirname(__file__))
#得到当前数据库的绝对路径
app.config['SQLACHEMY_DATABASE_URI'] = 'sqlite:///'+os.path.join(base_path,'data.sqlite')
#数据库的URL 保存到 Flask 配置对象的 SQLALCHEMY_DATABASE_URI 键中
app.config['SQLACHEMY_COMMIT_ON_TEARDOWN'] = True
#让数据库自动提交数据库中的变动
db = SQLAlchemy(app)
#生成对象关系映射
1
2
3
4
5
6
7
8
9
10
11

2、定义模型和关系

【models.py】

#上图中的 roles 表和 users 表可定义为模型 Role 和 User
class Role(db.Model):
    __tablename__ = 'roles'
    #定义数据库的表名，不定义的话会被默认设置。
    id = Column(Integer,primary_key=True)
    #设置一个id列，括号里第一个参数为类型，此处Int，第二个参数设置成主键
    name = Column(String(64),unique=True)
    #设置一个name列，字符串类型长度64，第二个参数是否唯一：是。
    users = db.relationship('User',backref='role')
    # 定义一个关系，注意第一个参数是类名，第二个参数是反向引用
    def __repr__(self):
        return '<Role %r>' % self.name
    #返回一个具有可读性的字符串表示模型，可在调试和测试时使用。

class User(db.Model):
    __tablename__ = 'users'
    id = Column(Integer,primary_key=True)
    username = Column(String(64),unique=True,index=True)
    password = Column(String(64))
    def __repr__(self):
        return '<User %r>' % self.username
    role_id = db.Column(db.Integer, db.ForeignKey('roles.id'))  
    # 外键的参数不是类名，而是表名
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

一些可用的列类型以及在模型中使用的 Python 类型。

db.Column 中其余的参数指定属性的配置选项：

两个表的连接

    关系使用 users 表中的外键连接了两行。添加到 User 模型中的 role_id 列被定义为外键， 就是这个外
键建立起了关系。传给 db.ForeignKey() 的参数 ‘roles.id’ 表明，这列的值是 roles 表中行的 id
值。

    添加到 Role 模型中的 users 属性代表这个关系的面向对象视角。对于一个 Role 类的实例，其 users
属性将返回与角色相关联的用户组成的列表。 db.relationship() 的第一个参数表明这个关系的另一端是
哪个模型。如果模型类尚未定义，可使用字符串形式指定。

    db.relationship() 中的 backref 参数向 User 模型中添加一个 role 属性，从而定义反向关系。这一属
性可替代 role_id 访问 Role 模型，此时获取的是模型对象，而不是外键的值。

3、在视图函数中操作数据库

基本操作

1、创建数据库

    db.drop_all()
    #删除数据库，当前有库在，想重新建库时，可以删除操作。
    db.create_all()
1
2
3

2、插入行

#插入操作分为两个步骤：
1. 创建一个新的模型对象：
admin_role = Role(name='Admin')
2. 添加到会话中：
db.session.add(admin_role)  
1
2
3
4
5

3、修改行

#修改操作分为两个步骤：
1. 修改模型对象
admin_role.name = 'Administrator'
2. 添加到会话中：
db.session.add(admin_role)
#可以看出无论是添加还是修改，第二部添加到数据库的操作都一样
1
2
3
4
5
6

4、删除行

删除操作只有一个步骤：
db.session.delete(mod_role)
1
2

5、查询行

Role.query.all()
#查询所有
User.query.filter_by(role=user_role).all()
#带过滤器的查询
1
2
3
4

常用的SQLAlchemy查询过滤器

常使用的SQLAlchemy查询执行函数

【sql.html】

{% extends "bsbase.html" %}
{% import "bootstrap/wtf.html" as wtf %}
{% block title %}Flasky{% endblock %}
{% block page_content %}
<div class="page-header">
<h1>Hello, {% if name %}{{ name }}{% else %}Stranger{% endif %}!</h1>
{% if not known %}
#判断是不是还是之前用户
<p>Nice to meet you!</p>
{% else %}
<p>Happy to see you again!</p>
{% endif %}
</div>
{{ wtf.quick_form(form) }}
#快速创建表单
{% endblock %}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

4、设置路由

【views】

# 先删除旧表再重新创建新表
db.drop_all()
db.create_all()


@app.route('/sql/',methods = ['GET','POST'])
def sql():
    form = NameForm()
    if form.validate_on_submit():
        # 查询是否存在用户输入的用户
        user = User.query.filter_by(username=form.name.data).first()
        print(user)
        # 若不存在
        if user is None:
            user = User(username=form.name.data)
            # 添加数据
            db.session.add(user)
            # 标记为不认识这个人
            session['known'] = False
        else:
            session['known'] = True
        session['name'] = form.name.data
        return redirect(url_for('hello'))
    return render_template('sql.html',form = form,
        name = session.get('name'),
        known = session.get('known',False))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

5、使用Flask-Migrate实现数据库迁移

主要功能：修改数据库模型，而且修改之后还需要更新数据库

步骤一：(venv) $ python hello.py db init
    #在维护数据库迁移之前，要使用 init 子命令创建迁移仓库
步骤二：(venv) $ python hello.py db migrate
    #使用 migrate 子命令自动创建迁移脚本
步骤三：(venv) $ python hello.py db upgrade
    #使用 upgrade 子命令把迁移应用到数据库中
1
2
3
4
5
6