目录
一.通过SQLAlchemy(ORM)操作数据库的流程
1.安装扩展包, pip install flask_sqlalchemy
2.安装数据库驱动, pip install mysqldb / pymysql
3.导⼊SQLAlchemy类
4.配置数据库的链接信息等(可通过报错获取)
5.创建db = SQLAlchemy()对象,关联app
6.编写模型类,继承⾃db.Model
7.编写属性,db.Colomn(类型,约束信息)表示⼀列
8.操作(数据库的增删改查)
二.注意点
1.ORM不能创建数据库,只能创建表
2.默认情况下,⽣成的表名称是类名称的⼩写形式,如果需要指定,设置tablename
3.链接数据库的格式:
<协议名称>://<⽤户名>:<密码>@<ip地址>:<端⼝>/<数据库名>
如果使⽤的是mysqldb驱动,协议名: mysql
如果使⽤的是pymysql驱动,协议名: mysql+pymysql
三.创建数据表类(继承db.Model)
1.设置表名： __tablename__ = 表名(字符串)
2.设置字段：字段名 = db.Column(db.数据类型,约束)
3设置外键：字段名 = db.Column(db.数据类型,db.ForeignKey(关联的表名.字段名))
注意：应设置__repr__方法，返回打印输出的格式，否则按默认方式返回
例：
from flask import Flask
from flask_sqlalchemy import SQLAlchemy
app = Flask(__name__)
# 指定数据库的链接信息
app.config["SQLALCHEMY_DATABASE_URI"] = "mysql+pymysql://root:[email protected]:3306/basic12"
# 这个配置将来会被禁用,设置为True或者False可以解除警告信息,建议设置False
app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False
db = SQLAlchemy(app)
# 角色模型类(一方)
class Role(db.Model):
__tablename__ = "roles"
# db.Colomn()表示模型类的属性,
# 主键
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), unique=True)
def __repr__(self):
return "<Role:%s,%s>" % (self.id, self.name)
# 用户模型类(多方)
class User(db.Model):
__tablename__ = "users"
# db.Colomn()表示模型类的属性,
# 主键
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), unique=True)
email = db.Column(db.String(64), unique=True)
password = db.Column(db.String(64), unique=True)
# 外键,关联的是Role表中的主键id
role_id = db.Column(db.Integer, db.ForeignKey(Role.id))
# 如果继承自object的类,使用__str__可以方便的查询对象的输出内容
# 如果继承自db.Model的类,使用__repr__可以方便的查询对象的输出内容
def __repr__(self):
return "<User:%s,%s,%s,%s>" % (self.id, self.name, self.email, self.password)
print(User.query.all())
四.增删改操作
| 方法 | 描述 |
|---|---|
| db.create_all() | 创建所有继承⾃db.Model的类 |
| db.drop_all() | 删除所有继承⾃db.Model的类 |
| db.session.add(obj) | 添加对象 |
| db.session.add_all([obj1,obj2,…]) | 添加多个对象 |
| db.session.delete(obj) | 删除对象 |
| 模型类.属性名 = xxx | 修改对象 |
| db.session.commit() | 提交会话 |
| db.session.rollback() | 回滚 |
| db.session.remove() | 移除会话 |
注意：所有使数据库发生改变的操作都需要提交回话(db.session.commit())才会改变数据库
五.查询数据库
格式：User.query.查询过滤器.查询执行器
1.常用查询过滤器
| 过滤器 | 说明 |
|---|---|
| filter() | 把过滤器添加到原查询上，返回一个新查询 |
| filter_by() | 把等值过滤器添加到原查询上，返回一个新查询 |
| limit | 使用指定的值限定原查询返回的结果 |
| offset() | 偏移原查询返回的结果，返回一个新查询 |
| order_by() | 根据指定条件对原查询结果进行排序，返回一个新查询 |
| group_by() | 根据指定条件对原查询结果进行分组，返回一个新查询 |
2.常用执行过滤器
| 方法 | 说明 |
|---|---|
| all() | 以列表形式返回查询的所有结果 |
| first() | 返回查询的第一个结果，如果未查到，返回None |
| first_or_404() | 返回查询的第一个结果，如果未查到，返回404 |
| get() | 返回指定主键对应的行，如不存在，返回None |
| get_or_404() | 返回指定主键对应的行，如不存在，返回404 |
| count() | 返回查询结果的数量 |
| paginate() | 返回一个Paginate对象，它包含指定范围内的结果 |
例：
查询id为4的用户[3种方式]
User.query.get(4)
User.query.filter_by(id = 4).first()
User.query.filter(User.id == 4).first()
查询名字结尾字符为g的所有数据[开始/包含]
User.query.filter(User.name.endswith('g')).all()
User.query.filter(User.name.starstswith('g')).all()
User.query.filter(User.name.contains('g')).all()
查询名字不等于wang的所有数据[2种方式]
查询名字和邮箱都以 li 开头的所有数据[2种方式]
User.query.filter(User.name.startswith('li'),User.email.startswith('li')).all()
User.query.filter(and_(User.name.startswith('li'),User.email.startswith('li'))).all()
查询password是 `123456` 或者 `email` 以 `itheima.com` 结尾的所有数据
User.query.filter(or_(User.password == '123456',User.email.endswith('itheima.com'))).all()
查询id为 [1, 3, 5, 7, 9] 的用户列表
User.query.filter(User.id.in_([1,3,5,7,9])).all()
查询name为liu的角色数据
user = User.query.filter(User.name == 'liu').first()
role = Role.query.filter(Role.id == user.role_id).first()
查询所有用户数据，并以邮箱排序
User.query.order_by(User.email).all()
User.query.order_by(User.email.desc()).all()
每页3个，查询第2页的数据
paginate = User.query.paginate(page, per_page,Error_out)
paginate = User.query.paginate(2,3,False)
page: 哪一个页
per_page: 每页多少条数据
Error_out: False 查不到不报错
pages: 共有多少页
items: 当前页数的所有对象
page: 当前页
六.relationship关联
1.一对多(有外键连接的前提)：
一对多的数据库关系映射中，多方定义外键，一方定义关系
角色表：
class Role(db.Model):
__tablename__ = "roles"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(32))
# 给Role添加关系属性users, 查询的方式: role.users
# 给User添加关系属性role, 查询的方式: user.role
users = db.relationship("User", backref="role", lazy="dynamic")
# 为了方便查看对象输出内容,重写repr
def __repr__(self):
return "<Role:%s,%s>" % (self.id, self.name)
用户表：
class User(db.Model):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(32))
email = db.Column(db.String(32))
password = db.Column(db.String(32))
# 关键
role_id = db.Column(db.Integer, db.ForeignKey(Role.id))
# 为了方便查看对象输出内容,重写repr
def __repr__(self):
return "<User:%s,%s,%s,%s>" % (self.id, self.name, self.email, self.password)
用户表通过外键绑定角色表，从而知道用户的角色，设置relationship关联后，可以直接通过属性访问。
格式： users = db.relationship("User", backref="role", lazy="dynamic")
| 参数 | 描述 |
|---|---|
| users | 可以设置任意字符串，设置后users为角色类的一个属性，role.users可直接访问用户表中与role对象相关联的数据(role.users可查看角色为role的用户) |
| backref | 设置反向关联属性，role也会成为用户类的一个属性,user.role可直接访问角色表中与user对象相关联的数据(user.role可查看用户user的角色) |
| lazy | 使⽤关系属性之后,默认会做⼦查询(不管⽤不⽤的到都会查询), 可以将lazy设置动态查询 |
默认: lazy = “subquery”，不管⽤不⽤的到都会查询
建议设置: lazy = “dynamic”，只有⽤到了才去查
格式：关联属性 = db.relationship(连接的数据库类名, backref=反向绑定属性)
(1)原始写法：
user = User.query.get(1)
role = Role.query.get(user.role_id)
(2)快速查询方式：
users = db.relationship("User",backref="role")
(设置后可通过users属性直接访问连接的User属性)
user = User.query.get(1)
role = user.role
2.多对多：
多对多需要创建一个中间表，将两张表的主键存储为中间表的外键进行连接。
中间表格式：
表名称 = db.Table( "表名称",字段1,字段2 )
其中一方表：
db.relationship("模型类名",backref="属性",secondary="中间表名")
例：
#学生,课程,中间表
student_course_tb = db.Table(
"student_course_tb",
db.Column("student_id",db.Integer,db.ForeignKey("students.id")),
db.Column("course_id",db.Integer,db.ForeignKey("courses.id"))
)
#编写模型类
#学生模型
class Student(db.Model):
__tablename__ = "students"
id = db.Column(db.Integer,primary_key=True)
name = db.Column(db.String(32))
#关系属性
courses = db.relationship("Course",backref="students",secondary="student_course_tb")
#为了方便,查看对象输出内容
def __repr__(self):
return "<Student:%s,%s>"%(self.id,self.name)
#课程模型
class Course(db.Model):
__tablename__ = "courses"
id = db.Column(db.Integer,primary_key=True)
name = db.Column(db.String(32))
#为了方便,查看对象输出内容
def __repr__(self):
return "<Class:%s,%s>"%(self.id,self.name)
Student对象.courses可访问关联的课程，Course对象.students可访问选该课的学生
七.数据库迁移
1.目的：备份表的结构
2.过程：
(1)安装扩展：
pip install flask_migrate
pip install flask_script
(2)导入类：
from flask_migrate import Migrate, MigrateCommand
from flask_script import Manager
Manager：管理app
Migrate：关联app,db
MigrateCommand：用manager添加操作命令使用MigrateCommand进行迁移(manager.add_command(“db”,MigrateCommand))
(3)终端指令：
⽣成迁移⽂件 (⼀次就好)
python xxx.py db init
将模型类,⽣成迁移脚本 (重复执⾏)
python xxx.py db migrate -m '注释'
将迁移脚本更新到数据库 (重复执⾏)
python xxx.py db upgrade / downgrade [version]
查看所有的版本号
pythoh xxx.py db history
查看当前版本号
python xxx.py db current
3.注意点：
(1)数据库迁移是为了备份表结构,⽽不是数据
(2)如果要备份数据,需要使⽤⼯具, ⽐如: navicat, mysqlworkbench等等⼯具
(3)如果进⾏降级的时候,会丢失数据,所以谨慎操作. 升级不会
例：
from flask import Flask
from flask_migrate import Migrate, MigrateCommand
from flask_script import Manager
from flask_sqlalchemy import SQLAlchemy
app = Flask(__name__)
# 设置数据库配置信息
app.config["SQLALCHEMY_DATABASE_URI"] = "mysql+pymysql://root:zsh123@localhost:3306/basic12"
app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False
# 创建SQLAlchemy对象,关联app
db = SQLAlchemy(app)
# 通过Manager管理app
manager = Manager(app)
# - 使用Migrate,关联app,db
Migrate(app, db)
# 给manager添加操作命令,使用MigrateCommand
manager.add_command("db", MigrateCommand)
# 模型类
class Student(db.Model):
__tablename__ = "students"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(32))
age = db.Column(db.Integer)
@app.route('/')
def hello_world():
return "helloworld"
if __name__ == '__main__':
manager.run()
八.蓝图
1.目的： 为模块化开发⽽⽣
2.优点：弱耦合
实际开发中会用很多视图和很多种类的视图，写在一个文件中耦合度太高，所以使用可以使用蓝图分多模块编写代码，然后将每个模块的蓝图对象在app上注册。
3.操作步骤：
(1)导入蓝图：
from flask import Blueprint
(2)创建蓝图对象：
blue = Blueprint("蓝图名称",__name__)
可选参数:
static_folder: 静态⽂件夹
url_prefix: 蓝图资源访问前缀
template_folder: 蓝图模板⽂件夹
(3)使⽤蓝图装饰视图函数
@blue.route("/路径")
(4)将蓝图对象注册到app
app.register_blueprint(blue)