Flask数据库基本操作_db.session.delete

一. 增删改操作

1. 基本概念

• 在Flask-SQLAlchemy中，插入、修改、删除操作，均由数据库会话管理。
  会话用db.session表示。在准备把数据写入数据库前，要先将数据添加到会话中然后调用 commit() 方法提交会话。

• 在Flask-SQLAlchemy中，查询操作是通过query对象操作数据。

  最基本的查询是返回表中所有数据，可以通过过滤器进行更精确的数据库查询。

db.session.add(role)    添加到数据库的session中
db.session.add_all([user1, user2]) 添加多个信息到session中
db.session.commit()     提交数据库的修改(包括增/删/改)
db.session.rollback()   数据库的回滚操作
db.session.delete(user) 删除数据库(需跟上commit)
1
2
3
4
5

2.在视图函数中定义模型类

from flask import Flask
from flask_sqlalchemy import SQLAlchemy
import pymysql

app = Flask(__name__)

#  SQLALCHEMY_DATABASE_URI = "mysql+pymysql://root:这里填密码@localhost:3306/这里填数据库名字"
# 配置数据库的地址                          mysql://用户名：密码@本地地址/表名
app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql+pymysql://root:xxxxxx@127.0.0.1:3306/flask_sql_demo'

# 跟踪数据库的修改--> 不建议开启 未来的版本中会移除
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False

db = SQLAlchemy(app)

# 数据库的模型类，需要继承db.Model
class Role(db.Model):
    # 定义表名
    __tablename__ = 'roles'

    # 定义字段
    # db.Column
    id = db.Column(db.Integer, primary_key=True)
    role_name = db.Column(db.String(16), unique=True)

    # 在一的一方,写关联
    # users=db.relationship('User') :表示和User表发生了关联，增加了一个users的属性
    # backref='role' ：表示role是User要用的属性
    users = db.relationship('User', backref='role')

    # repr()  方法显示一个可读字符串
    def __repr__(self):
        return "<Role:%s %s>" % (self.role_name, self.id)


class User(db.Model):
    # 定义表名
    __tablename__ = 'users'

    # 定义字段
    # db.Column
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(16), unique=True)
    email = db.Column(db.String(32), unique=True)
    password = db.Column(db.String(32))
    # db.ForeignKey('roles.id') 表示是外键，表名.id
    role_id = db.Column(db.Integer, db.ForeignKey('roles.id'))

    # User希望有role属性，但是这个属性的定义，需要在另一个模型中定义

    # repr()  方法显示一个可读字符串
    def __repr__(self):
        return "<User:%s %s %s %s>" % (self.name, self.id, self.email, self.password)

@app.route('/')
def hello_world():
    return 'Hello World!'


# 删除表
db.drop_all()
# 创建表
db.create_all()

ro1 = Role(role_name='admin')
ro2 = Role(role_name='user')
db.session.add_all([ro1, ro2])
db.session.commit()

us1 = User(name='wang', email='wang@qq.com', password='111', role_id=ro1.id)
us2 = User(name='li', email='li@qq.com', password='111', role_id=ro1.id)
us3 = User(name='han', email='han@qq.com', password='111', role_id=ro2.id)
us4 = User(name='chen', email='chen@qq.com', password='111', role_id=ro1.id)
us5 = User(name='ma', email='ma@qq.com', password='111', role_id=ro2.id)
us6 = User(name='liu', email='liu@qq.com', password='111', role_id=ro1.id)
us7 = User(name='wei', email='wei@qq.com', password='111', role_id=ro2.id)
db.session.add_all([us1, us2, us3, us4, us5, us6, us7])
db.session.commit()

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

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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

#### 2.2 数据的增删改
# 导入app.py
In [2]: from app import *

# 添加角色
In [4]: role=Role(role_name='admin')
In [5]: db.session.add(role)
In [6]: db.session.commit()

# 添加用户
In [7]: user=User(name='韩寒',role_id=role.id)
In [8]: db.session.add(user)
In [9]: db.session.commit()

# 修改用户名
In [10]: user.name
Out[10]: '韩寒'
In [11]: user.name='小韩'
In [12]: db.session.commit()
In [13]: user.name
Out[13]: '小韩'

# 删除用户
In [14]: db.session.delete(user)
In [15]: db.session.commit()

# 添加多个用户  add_all([对象])
In [18]: user=User(name='小韩',role_id=role.id)
In [19]: user1=User(name='韩寒',role_id=role.id)
In [21]: db.session.add_all([user,user1])
In [22]: db.session.commit()
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
27
28
29
30
31

3 模型之间的关联

一对多

class Role(db.Model):
...
#关键代码
user = db.relationship('User', backref='role')
...

class User(db.Model):
...
role_id = db.Column(db.Integer, db.ForeignKey('roles.id'))
1
2
3
4
5
6
7
8
9

• 其中realtionship描述了Role和User的关系。在此文中，第一个参数为对应参照的类"User"
• 第二个参数backref为类User申明新属性的方法

# 添加一个角色和两个用户
In [2]: role=Role(role_name='admin')
In [3]: db.session.add(role)
In [5]: db.session.commit()

In [6]: user1=User(name='zs',role_id=role.id)
In [7]: user2=User(name='ls',role_id=role.id)
In [8]: db.session.add_all([user1,user2])
In [9]: db.session.commit()

# 实现关系引用查询

In [10]: role.users
Out[10]: [<User:zs 1 None None>, <User:ls 2 None None>]

In [11]: user1.role
Out[11]: <Role:admin 1>

In [12]: user1.role.role_name
Out[12]: 'admin'

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

二. 查询操作

1.1常用的SQLAlchemy查询过滤器

查询演练

In [1]: from app import *
# 1. 查询所有用户数据
In [3]: User.query.all()
Out[3]: 
[<User:wang 1 wang@qq.com 111>,
 <User:li 2 li@qq.com 111>,
 <User:han 3 han@qq.com 111>,
 <User:chen 4 chen@qq.com 111>,
 <User:ma 5 ma@qq.com 111>,
 <User:liu 6 liu@qq.com 111>,
 <User:wei 7 wei@qq.com 111>]
 
# 2. 查询有多少个用户
In [4]: User.query.count()
Out[4]: 7

# 3. 查询第1个用户
In [5]: User.query.first()
Out[5]: <User:wang 1 wang@qq.com 111>

# 4. 查询id为4的用户[3种方式]
In [7]: User.query.get(4)
Out[7]: <User:chen 4 chen@qq.com 111>

In [10]: User.query.filter_by(id=4).first()
Out[10]: <User:chen 4 chen@qq.com 111>

In [11]: User.query.filter(User.id==4).first()
Out[11]: <User:chen 4 chen@qq.com 111>

# 查询id大于或等于4的用户
In [23]: User.query.filter(User.id>=4).all()
Out[23]: 
[<User:chen 4 chen@qq.com 111>,
 <User:ma 5 ma@qq.com 111>,
 <User:liu 6 liu@qq.com 111>,
 <User:wei 7 wei@qq.com 111>]

# filter_by直接用属性名，比较用=, filter用类名.属性名，比较用==
# filter_by用于查询简单的列名，不支持比较运算符
# filter比filter_by的功能更强大，支持比较运算符，支持or_、in_等语法。

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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42