志愿服务网站建设方案,wordpress网站布局,简单的网站设计开发,个人淘宝开店流程步骤文章目录 ORMFlask-SQLAlchemySQLAlchemy中的session对象数据库连接设置常用的SQLAlchemy字段类型常用的SQLAlchemy列约束选项 数据库基本操作模型类定义 数据表操作创建和删除表 数据操作基本查询SQLAlchemy常用的查询过滤器SQLAlchemy常用的查询结果方法多条件查询分页器聚合… 文章目录 ORMFlask-SQLAlchemySQLAlchemy中的session对象数据库连接设置常用的SQLAlchemy字段类型常用的SQLAlchemy列约束选项 数据库基本操作模型类定义 数据表操作创建和删除表 数据操作基本查询SQLAlchemy常用的查询过滤器SQLAlchemy常用的查询结果方法多条件查询分页器聚合分组执行原生SQL语句 关联查询常用的SQLAlchemy关系选项模型之间的关联一对一关联属性声明在主模型中【最常用】在外键模型中声明关联属性 一对多多对多基于第三方关系表构建多对多基于第三方关系模型构建多对多 逻辑外键 数据迁移创建迁移版本仓库创建迁移版本升级版本库的版本降级版本库的版本版本库的历史管理回滚到指定版本 常用模块Fakerflask-sessionSQLAlchemy存储session的基本配置redis保存session的基本配置 蓝图 Blueprint模块化蓝图运行机制蓝图的url拼接注册蓝图下的静态文件[很少使用]设置蓝图下的html模版[很少使用] ORM
ORM 全拼Object-Relation Mapping中文意为 对象-关系映射。主要实现模型对象到关系数据库数据的映射。
ORM提供了一种面向对象操作数据库的方式给开发者。不需要编写原生SQL语句也能操作数据库实现了业务代码与底层数据的解耦。
优点
只需要面向对象编程, 不需要面向数据库编写SQL. 对数据库的操作都转化成对类/对象的属性和方法的操作. 表字段—对象属性, SQL关键字- 操作方法不用编写各种数据库的原生sql语句当然也可以编写原生SQL语句。 实现了数据模型代码与数据库数据的解耦, 屏蔽了不同数据库操作上的差异 不再需要关注当前项目使用的是哪种数据库。通过简单的配置就可以轻松更换数据库, 而不需要修改业务代码.
缺点
相比较直接使用SQL语句操作数据库,ORM需要把操作转换成SQL语句所以有性能损失.根据对象的操作转换成SQL语句,根据查询的结果转化成模型实例对象, 在映射过程中有性能损失.不同的ORM提供的操作不一样增加了学习成本
Flask-SQLAlchemy
flask默认不提供模型操作但是并没有提供ORM所以一般开发的时候我们会采用flask-SQLAlchemy模块来实现ORM操作。
SQLAlchemy是一个python语言编写的高性能的关系型数据库ORM框架它提供了高层的 ORM 和底层的原生数据库的操作。
我们使用sqlalchemy 不需要调用sqlalchemy 本身这个模块而是采用flask-sqlalchemy 这是一个简化了 SQLAlchemy 操作的flask扩展模块。主要是简化了sqlalchemy初始化代码和分页操作等
SQLAlchemyhttps://docs.sqlalchemy.org/en/14/
中文文档https://www.osgeo.cn/sqlalchemy/orm/index.html
flask-SQLAlchemyhttps://flask-sqlalchemy.palletsprojects.com/en/2.x/quickstart/
安装 flask-sqlalchemy【清华源】
pip install flask-sqlalchemy -i https://pypi.tuna.tsinghua.edu.cn/simple如果sqlalchemy连接的是 mysql /MariaDB数据库需要安装 mysqldb 或pymysql驱动
conda install flask-mysqldb -c conda-forge安装flask-mysqldb时注意
使用pip install 安装 flask-mysqldb的时候python底层依赖于一个底层的模块 mysqlclient 模块
如果没有这个模块则会报错如下Command python setup.py egg_info failed with error code 1 in /tmp/pip-install-21hysnd4/mysqlclient/解决方案
sudo apt-get install -y libmysqlclient-dev python3-dev# 运行上面的安装命令如果再次报错如下
# dpkg 被中断您必须手工运行 ‘sudo dpkg --configure -a’ 解决此问题。# 则根据提示执行命令以下命令再次安装mysqlclient
# sudo dpkg --configure -a
# apt-get install libmysqlclient-dev python3-dev解决了mysqlclient问题以后重新安装 flask-mysqldb即可。
pip install flask-mysqldb -i https://pypi.tuna.tsinghua.edu.cn/simpleSQLAlchemy中的session对象 在SQLAlchemy中Session 对象是ORM的核心概念之一它主要负责以下几项工作 对象的生命周期管理Session 负责管理对象的生命周期。当一个对象被添加到 Session 中时它就处于挂起状态直到被提交commit到数据库。如果对象被删除或修改Session 也会跟踪这些变化。 事务管理Session 提供了事务管理功能。当你调用 session.commit() 时所有挂起的更改插入、更新、删除都会被提交到数据库。如果在提交过程中发生错误你可以调用 session.rollback() 来回滚事务撤销所有更改。 查询和持久化Session 允许你查询数据库并获取结果。你可以使用 Session 来执行查询并获取对象或对象集合。 一级缓存Session 实现了一级缓存这意味着同一个 Session 中的对象是唯一的。如果你查询同一个对象两次Session 会返回同一个实例而不是创建一个新的实例。 脏检查Session 会跟踪对象的属性变化这样在提交事务时只有那些被修改过的对象会被更新到数据库。 身份映射Session 维护了一个对象到数据库行的映射。当你从数据库中检索对象时Session 会记住这个映射这样你就可以在不查询数据库的情况下访问和修改对象。 会话的生命周期Session 应该被视为短暂的通常每个请求或事务都会创建一个新的 Session并且在使用完毕后关闭它。这样可以避免长时间持有数据库连接提高资源利用率。 在实际使用中你通常会这样操作 创建一个新的 Session。使用这个 Session 来添加、查询、更新或删除对象。提交事务session.commit()以保存更改到数据库。关闭 Sessionsession.close()以释放资源。 下面是一个简单的例子 # 创建Session
session DbSession()# 创建一个新的对象
new_user User(nameJohn Doe, emailjohnexample.com)# 添加对象到Session
session.add(new_user)# 提交事务保存到数据库
session.commit()# 查询用户
user session.query(User).filter_by(nameJohn Doe).first()# 更新用户信息
user.email newemailexample.com# 提交更新
session.commit()# 删除用户
session.delete(user)# 提交删除操作
session.commit()# 关闭Session
session.close()在这个例子中Session 负责管理用户对象的生命周期并确保所有的更改都被正确地提交到数据库。 原生SQLAlchemy连接配置操作
db.py代码
from sqlalchemy import create_engine # 驱动引擎
from sqlalchemy.ext.declarative import declarative_base # 数据库基类
from sqlalchemy import Column, Integer, String, Boolean, Numeric, Text # 字段、整型
from sqlalchemy.orm import sessionmaker # 连接会话engine create_engine(# 连接数据库的URL# urlmysqlpymysql://root:123127.0.0.1:3306/students?charsetutf8mb4, # 如果底层驱动是pymysqlurlmysql://root:123127.0.0.1:3306/students?charsetutf8mb4, # 如果底层驱动是MysqlDBechoTrue, # 当设置为True时会将orm语句转化为sql语句打印一般debug的时候可用pool_size8, # 连接池的大小默认为5个设置为0时表示连接无限制pool_recycle60*30 # 设置时间以限制数据库多久没连接自动断开
)DbSession sessionmaker(bindengine)
session DbSession()# 创建数据基类
Model declarative_base()manage.py代码
import db
class Student(db.Model):__tablename__ tb_studentid db.Column(db.Integer, primary_keyTrue)name db.Column(db.String(255))sex db.Column(db.Boolean)age db.Column(db.Integer)class_name db.Column(class, db.String(255),)description db.Column(db.Text)is_delete db.Column(db.Boolean, nullableTrue, defaultFalse)if __name__ __main__:# 如果没有提前声明模型中的数据表则可以采用以下代码生成数据表# 如果数据库中已经声明了有数据表则不会继续生成db.Model.metadata.create_all(db.engine)# 根据ID查询一条数据# ret db.session.query(Student).get(19)# print(ret)# print(ret.name)# print(ret.class_name)## # 查询所有数据# data_list db.session.query(Student).all()# print(data_list)# for data in data_list:# print(data.name)# # 按条件查询# data_list db.session.query(Student).filter(Student.sexTrue, Student.class_name301).all()# print(data_list)# for data in data_list:# print(data.sex, data.name)# 添加一条数据# student Student(# namexiaohua,# class_name305,# sexFalse,# age18,# description美美的..,# )# db.session.add(student)# db.session.commit()## # 添加多条数据# student_list [# Student(namexiaohei, class_name305, sexFalse, age18, description美美的..,),# Student(namexiaobai, class_name304, sexTrue, age18, description美美的..,),# Student(namexiaohui, class_name303, sexFalse, age18, description美美的..,),# ]## db.session.add_all(student_list)# db.session.commit()# 更新一条数据# student db.session.query(Student).get(35)# student.name 小会# db.session.commit()# 更新多条数据# db.session.query(Student).filter(Student.class_name303).update({Student.age:Student.age1})# db.session.commit()# 删除一条数据# student db.session.query(Student).get(35)# db.session.delete(student)# db.session.commit()# 删除多条数据db.session.query(Student).filter(Student.class_name 401).delete()# 原生SQL语句# 读cursor db.session.execute(select * from tb_student)# 一条# data cursor.fetchone()# print(data)# 多条# data_list cursor.fetchall()# print(data_list)# 写[添加、删除、修改]cursor db.session.execute(insert into tb_student(name, class, age, sex, description) values(:name, :class, :age, :sex, :description),params{name: xiaohong,class: 307,age: 19,sex: 0,description: .....,})db.session.commit()print(cursor.lastrowid) # 获取最后添加的主键ID数据库连接设置
在 Flask-SQLAlchemy 中数据库的链接配置信息使用URL指定而且程序使用的数据库必须保存到Flask的 SQLALCHEMY_DATABASE_URI 配置项中
manage.py代码
# SQLAlchemy的链接配置数据库名://账户名:密码服务器地址:端口/数据库名称?配置参数选项
app.config[SQLALCHEMY_DATABASE_URI] mysql://root:123127.0.0.1:3306/flaskdemo?charsetutf8mb4# 如果不使用mysqldb改用pymysql则需要在连接时指定pymysql
# app.config[SQLALCHEMY_DATABASE_URI] mysqlpymysql://root:123127.0.0.1:3306/flaskdemo?charsetutf8mb4其他设置项
# 动态追踪修改设置如未设置只会提示警告
SQLALCHEMY_TRACK_MODIFICATIONS True
#查询时会显示原始SQL语句
SQLALCHEMY_ECHO True配置完成需要去 MySQL 中创建项目所使用的数据库
mysql -uroot -p123
create database flaskdemo charsetutf8mb4;常用的SQLAlchemy字段类型
模型字段类型名python中数据类型说明Integerint普通整数一般是32位SmallIntegerint取值范围小的整数一般是16位BigIntegerint不限制精度的整数Floatfloat浮点数Numericdecimal.Decimal普通数值一般是32位Stringstr变长字符串Textstr变长字符串对较长或不限长度的字符串做了优化Unicodeunicode变长Unicode字符串UnicodeTextunicode变长Unicode字符串对较长或不限长度的字符串做了优化Booleanbool布尔值DateTimedatetime.datetime日期和时间Datedatetime.date日期Timedatetime.time时间LargeBinarybytes二进制文件内容Enumenum.Enum枚举类型相当于django的choices但是功能没有choices那么强大
常用的SQLAlchemy列约束选项
选项名说明primary_key如果为True代表当前数据表的主键unique如果为True为这列创建唯一 索引代表这列不允许出现重复的值index如果为True为这列创建普通索引提高查询效率nullable如果为True允许有空值如果为False不允许有空值default为这列定义默认值
数据库基本操作
在SQLAlchemy中添加、修改、删除操作均由数据库会话(sessionSM)管理。 会话用 db.session 表示。在准备把数据写入数据库前要先将数据添加到会话中然后调用 db.commit() 方法提交会话。 在SQLAlchemy 中查询操作是通过 query 对象操作数据。 最基本的查询是返回表中所有数据也可以通过filter过滤器进行更精确的数据库查询。
模型类定义
我们后面会把模型创建到单独的文件中但是现在我们先把模型类写在main.py文件中。
from flask import Flask
from flask_sqlalchemy import SQLAlchemyapp Flask(__name__)
class Config(object):DEBUG True# 数据库链接配置 数据库名称://登录账号:登录密码数据库主机IP:数据库访问端口/数据库名称?charset编码类型SQLALCHEMY_DATABASE_URI mysql://root:123127.0.0.1:3306/flaskdemo?charsetutf8mb4# 动态追踪修改设置如未设置只会提示警告SQLALCHEMY_TRACK_MODIFICATIONS False# ORM运行时会显示ORM生成的原始SQL语句[调试]SQLALCHEMY_ECHO Trueapp.config.from_object(Config)模型类定义
db SQLAlchemy(appapp)
# 等同于
# db SQLAlchemy()
# db.init_app(app) # 加载配置并完成初始化过程class Student(db.Model):学生信息模型# 声明与当前模型绑定的数据表名称__tablename__ tb_student# 企业中往往大部分的公司会出现以下2种不同的数据库开发情况。# 1. 企业中有DBADBA会提前创建数据库和项目中具体业务的数据表。也就是说我们不需要自己手动建库建表只需要根据数据库表结构使用python声明对应的模型与之匹配就可以操作数据库了。# 2. 企业没有DBA比较坑爹# 2.1 开发人员自己手撸SQL语句手动建库建表。# 2.2 开发人员编写模型使用数据迁移手动建库和数据迁移建表。# 原生SQL语句create table db_student(id int primary key auto_increment comment 主键,name varchar(15) comment 姓名,age smallint comment 年龄,sex tinyint default 1 comment 性别,email varchar(128) comment 邮箱地址,money NUMERIC(10,2) default 0.0 comment 钱包,key (name),unique key (email));# 字段根据SQL语句来声明id db.Column(db.Integer, primary_keyTrue,comment主键)name db.Column(db.String(15), indexTrue, comment姓名)age db.Column(db.SmallInteger, comment年龄)sex db.Column(db.Boolean, defaultTrue, comment性别)email db.Column(db.String(128), uniqueTrue, comment邮箱地址)money db.Column(db.Numeric(10,2), default0.0, comment钱包)def __repr__(self): # 相当于django的__str__return f{self.name}{self.__class__.__name__}# 所有的模型必须直接或间接继承于db.Model
class Course(db.Model):课程数据模型__tablename__ db_course# 原生SQL语句create table db_course (id int primary key auto_increment comment 主键,name varchar(64) comment 课程,price NUMERIC(7,2) comment 价格,unique (name));# 字段根据SQL语句来声明id db.Column(db.Integer, primary_keyTrue, comment主键)name db.Column(db.String(64), uniqueTrue, comment课程)price db.Column(db.Numeric(7, 2), comment价格)# repr()方法类似于django的__str__用于打印模型对象时显示的字符串信息def __repr__(self):return f{self.name}{self.__class__.__name__}class Teacher(db.Model):老师数据模型__tablename__ db_teacher# 原生SQL语句create table db_teacher (id int primary key auto_increment comment 主键,name varchar(64) comment 姓名,option enum(讲师, 助教, 班主任) comment 职位,unique (name));# 字段根据SQL语句来声明id db.Column(db.Integer, primary_keyTrue, comment主键)name db.Column(db.String(64), uniqueTrue, comment姓名)option db.Column(db.Enum(讲师, 助教, 班主任), default讲师)def __repr__(self):return f{self.name}{self.__class__.__name__}app.route(/)
def index():return okif __name__ __main__:app.run()数据表操作
创建和删除表
创建表
# 在视图内调用
app.route(/create)
def create_table():db.create_all() # 为项目中被识别的所有模型创建数据表return ok# 在视图以外的地方调用with app.app_context():# create_all()方法执行的时候需要放在模型的后面# 检测数据库中是否存在和模型匹配的数据表。# 如果没有则根据模型转换的建表语句进行建表。# 如果找到则不会进行额外处理db.create_all()删除表
# 在视图内调用
app.route(/drop)
def drop_table():db.drop_all() # 为项目中被识别的所有模型删除数据表return ok# 在视图以外的地方调用with app.app_context():db.drop_all() # 慎用很给力的这表示删除数据库中所有模型对应的表。代码
from flask import Flask, render_template
from flask_sqlalchemy import SQLAlchemydb SQLAlchemy()
app Flask(__name__, template_foldertemplates, static_folderstatic)# 配置
app.config.update({DEBUG: True,SQLALCHEMY_DATABASE_URI: mysql://root:123127.0.0.1:3306/flaskdemo?charsetutf8mb4,# 如果使用pymysql则需要在连接时指定pymysql# SQLALCHEMY_DATABASE_URI: mysqlpymysql://root:123127.0.0.1:3306/flaskdemo?charsetutf8mb4# 动态追踪修改设置如未设置只会提示警告设置False即可SQLALCHEMY_TRACK_MODIFICATIONS: False,# ORM执行SQL查询时是哦否显示原始SQL语句debug模式下可以开启SQLALCHEMY_ECHO: True,
})db.init_app(app)class Student(db.Model):学生管理__tablename__ db_student # 表名# __abstract__ True # 抽象模型数据迁移/建表的时候不会认为这是一个模型也就不会建表往往用于设置公共模型保存公共字段# 企业中往往大部分的公司会出现以下2种不同的数据库开发情况。# 1. 企业中有DBADBA会提前创建数据库和项目中具体业务的数据表。也就是说我们不需要自己手动建库建表只需要根据数据库表结构使用python声明对应的模型与之匹配就可以操作数据库了。# 2. 企业没有DBA比较坑爹# 2.1 开发人员自己手撸SQL语句手动建库建表。# 2.2 开发人员编写模型使用数据迁移或者ORM提供建表方法手动建库和数据迁移建表。# 原生SQL语句create table db_student(id int primary key auto_increment comment 主键,name varchar(15) comment 姓名,age smallint comment 年龄,sex tinyint(1) default 1 comment 性别,email varchar(255) comment 邮箱地址,money NUMERIC(10,2) default 0.0 comment 钱包,key (name),unique key (email));# 字段根据SQL语句来声明# 属性名 db.Column(字段类型, 字段列约束选项)# 如果SQL语句中的字段名在python中是关键字/保留字则建议改写绑定字段名# 属性名 db.Column(字段名, 字段类型, 字段列约束选项)id db.Column(student_id, db.Integer, primary_keyTrue, comment主键)name db.Column(db.String(15), indexTrue, comment姓名)age db.Column(db.SmallInteger, comment年龄)sex db.Column(db.SmallInteger, comment性别)email db.Column(db.String(255), uniqueTrue, comment邮箱地址)money db.Column(db.Numeric(10,2), default0.0, comment钱包)# repr()方法类似于django的__str__用于打印模型对象时显示的字符串信息def __repr__(self):return f{self.name}{self.__class__.__name__}# 所有的模型必须直接或间接继承于db.Model
class Course(db.Model):课程数据模型__tablename__ db_course# 原生SQL语句create table db_course (id int primary key auto_increment comment 主键,name varchar(64) comment 课程,price NUMERIC(7,2) comment 价格,unique (name));# 字段根据SQL语句来声明id db.Column(db.Integer, primary_keyTrue, comment主键)name db.Column(db.String(64), uniqueTrue, comment课程)price db.Column(db.Numeric(7, 2), comment价格)# repr()方法类似于django的__str__用于打印模型对象时显示的字符串信息def __repr__(self):return f{self.name}{self.__class__.__name__}class Teacher(db.Model):老师数据模型__tablename__ db_teacher# 原生SQL语句create table db_teacher (id int primary key auto_increment comment 主键,name varchar(64) comment 姓名,option enum(讲师, 助教, 班主任) comment 职位,unique (name));# 字段根据SQL语句来声明id db.Column(db.Integer, primary_keyTrue, comment主键)name db.Column(db.String(64), uniqueTrue, comment姓名)option db.Column(db.Enum(讲师, 助教, 班主任), default讲师)def __repr__(self):return f{self.name}{self.__class__.__name__}app.route(/)
def index():title 网站首页return render_template(index.html, **locals())app.route(/create)
def create_table():db.create_all() # 为项目中被识别的所有模型创建数据表return okapp.route(/drop)
def drop_table():db.drop_all() # 为项目中被识别的所有模型删除数据表return okif __name__ __main__:app.run()
数据操作
添加一条数据
# 添加一条数据
student Student(name小明, age17, emailxiaomingqq.com, money100) # 实例化模型对象
db.session.add(student) # 把模型对象添加数据库session会话对象中。db.session是SQLAlchemy中内置的会话管理对象sessionSM的成员
db.session.commit() # 提交会话# 再次插入一条数据
student2 Student(name小红, sexFalse, age13, email16565666qq.com, money600)
db.session.add(student2)
db.session.commit() # 提交会话一次插入多条数据
# 1. 先实例化要创建的模型对象
student Student(name小红, age17, emailxiaohongqq.com, money200)
# 2. 把实例对象添加到连接会话
db.session.add(student)
# 1. 先实例化要创建的模型对象
student Student(name小花, age16, emailxiaohuaqq.com, money200)
# 2. 把实例对象添加到连接会话
db.session.add(student)
# 3. 只需要在结束的时候提交事务即可
db.session.commit()# 1. 先创建的列表要添加的实例化模型对象列表
student_list [Student(namewang, emailwang163.com, age20),Student(namezhang, emailzhang189.com, age21),Student(namechen, emailchen126.com, age19),Student(namezhou, emailzhou163.com, age18),Student(nametang, emailtang163.com, age16),Student(namewu, emailwugmail.com, age20),Student(nameqian, emailqiangmail.com, age21),Student(nameliu, emailliu163.com, age21),Student(nameli, emailli163.com, age18),Student(namesun, emailsun163.com, age17),
]# 2. 一次性添加到连接会话中
db.session.add_all(student_list)
db.session.commit()删除数据
# 方法1[先查询后删除2条语句完成删除操作]
# 先查询出来
student Student.query.first()
print(student)
# 再进行删除
db.session.delete(student)
db.session.commit()# 方法2【1条语句完成删除操作性能更好更高效】
# 类似乐观锁在数据改动时添加条件并判断条件成立以后才进行数据操作这种用法就是乐观锁
Student.query.filter(Student.id 5).delete()
db.session.commit()
悲观锁是属于数据库中的一种锁机制但是乐观锁并非真正的数据库锁。
2种锁都是数据库在应对并发操作时防止出现资源抢夺的基于不同人生观所实现2种解决方案。
悲观锁的基本使用 数据库终端开始begin; -- 开启事务select * from db_student where student_id 5 for update; -- 添加一把更新锁【悲观锁】.... -- 在事务提交之前任何第三方连接都不能修改 student_id 5这条数据 commit; -- 提交事务 数据库终端开始悲观锁的问题
1. 提前锁定数据形成串行化形成阻塞不利于性能发挥不适用高并发场景。
2. 悲观锁只能保证数据的一致性不能保证脏数据的出现乐观锁的出现就是为了解决悲观锁的问题。
举例双11活动商城里面id5的商品的库存10了现在我们要基于乐观锁和悲观锁来解决下单过程中出现的资源抢夺现象避免出现超卖商品数量不能为负数。乐观锁
--- begin; 开启事务
--- 先查看库存记录当前库存 num10
--- 进行下单操作买6件
--- 付款
--- 扣除库存 update goods set numnum-6 where num10 and id5; # 增加更新条件判断库存是否还是原来
--- 如果执行成功则表示没有人抢购买成功如果执行事变则表示已经有人先抢购
--- commit;悲观锁
--- begin; 开启事务
--- 先给id5的数据加锁select * from goods where id5 for update;
--- 进行下单操作买6件
--- 付款
--- 扣除库存 update goods set numnum-6 where id5
--- 执行成功解锁
---- commit; 提交事务更新数据
from flask import Flask, render_template
from flask_sqlalchemy import SQLAlchemydb SQLAlchemy()
app Flask(__name__, template_foldertemplates, static_folderstatic)# 配置
app.config.update({DEBUG: True,SQLALCHEMY_DATABASE_URI: mysql://root:123127.0.0.1:3306/flaskdemo?charsetutf8mb4,# 如果使用pymysql则需要在连接时指定pymysql# SQLALCHEMY_DATABASE_URI: mysqlpymysql://root:123127.0.0.1:3306/flaskdemo?charsetutf8mb4# 动态追踪修改设置如未设置只会提示警告设置False即可SQLALCHEMY_TRACK_MODIFICATIONS: False,# ORM执行SQL查询时是哦否显示原始SQL语句debug模式下可以开启SQLALCHEMY_ECHO: True,
})db.init_app(app)class Student(db.Model):学生管理__tablename__ db_student # 表名# 属性名 db.Column(字段类型, 字段列约束选项)# 如果SQL语句中的字段名在python中是关键字/保留字则建议改写绑定字段名# 属性名 db.Column(字段名, 字段类型, 字段列约束选项)id db.Column(student_id, db.Integer, primary_keyTrue, comment主键)name db.Column(db.String(15), indexTrue, comment姓名)age db.Column(db.SmallInteger, comment年龄)sex db.Column(db.SmallInteger, comment性别)email db.Column(db.String(255), uniqueTrue, comment邮箱地址)money db.Column(db.Numeric(10,2), default0.0, comment钱包)# repr()方法类似于django的__str__用于打印模型对象时显示的字符串信息def __repr__(self):return f{self.name}{self.__class__.__name__}# 所有的模型必须直接或间接继承于db.Model
class Course(db.Model):课程数据模型__tablename__ db_course# 原生SQL语句create table db_course (id int primary key auto_increment comment 主键,name varchar(64) comment 课程,price NUMERIC(7,2) comment 价格,unique (name));# 字段根据SQL语句来声明id db.Column(db.Integer, primary_keyTrue, comment主键)name db.Column(db.String(64), uniqueTrue, comment课程)price db.Column(db.Numeric(7, 2), comment价格)# repr()方法类似于django的__str__用于打印模型对象时显示的字符串信息def __repr__(self):return f{self.name}{self.__class__.__name__}class Teacher(db.Model):老师数据模型__tablename__ db_teacher# 原生SQL语句create table db_teacher (id int primary key auto_increment comment 主键,name varchar(64) comment 姓名,option enum(讲师, 助教, 班主任) comment 职位,unique (name));# 字段根据SQL语句来声明id db.Column(db.Integer, primary_keyTrue, comment主键)name db.Column(db.String(64), uniqueTrue, comment姓名)option db.Column(db.Enum(讲师, 助教, 班主任), default讲师)def __repr__(self):return f{self.name}{self.__class__.__name__}app.route(/)
def index():return okapp.route(/create)
def create_table():db.create_all() # 为项目中被识别的所有模型创建数据表return okapp.route(/drop)
def drop_table():db.drop_all() # 为项目中被识别的所有模型删除数据表return ok一次添加一条数据
app.route(/add)
def add_student():# 1. 先实例化要创建的模型对象student Student(name小明, age17, emailxiaomingqq.com, money100) # 实例化模型对象# 2. 把实例对象添加到连接会话db.session.add(student)# 3. 提交事务db.session.commit()return ok一次添加多条数据
app.route(/madd)
def multi_add():# 1. 先实例化要创建的模型对象student Student(name小红, age17, emailxiaohongqq.com, money200)# 2. 把实例对象添加到连接会话db.session.add(student)# 1. 先实例化要创建的模型对象student Student(name小花, age16, emailxiaohuaqq.com, money200)# 2. 把实例对象添加到连接会话db.session.add(student)# 3. 只需要在结束的时候提交事务即可db.session.commit()return okapp.route(/madd2)
def multi_add2():# 1. 先创建的列表要添加的实例化模型对象列表student_list [Student(namewang, emailwang163.com, age20),Student(namezhang, emailzhang189.com, age21),Student(namechen, emailchen126.com, age19),Student(namezhou, emailzhou163.com, age18),Student(nametang, emailtang163.com, age16),Student(namewu, emailwugmail.com, age20),Student(nameqian, emailqiangmail.com, age21),Student(nameliu, emailliu163.com, age21),Student(nameli, emailli163.com, age18),Student(namesun, emailsun163.com, age17),]# 2. 一次性添加到连接会话中db.session.add_all(student_list)db.session.commit()return okapp.route(/del)
def delete_student():删除一条数据# 先查询出来student Student.query.first()# student db.session.query(Student).first()# 再进行删除db.session.delete(student)db.session.commit()return okapp.route(/mdel)
def multi_delete_student():按条件删除多条数据Student.query.filter(Student.id 5).delete()# db.session.query(Student).filter(Student.id 5).delete()db.session.commit()return okapp.route(/update)
def update():更新一条# 先查询出来student Student.query.filter(Student.id 4).first()student.name 小白db.session.commit()return okapp.route(/update2)
def update2():直接根据条件更新一条或多条数据Student.query.filter(Student.name zhang, Student.money -99.00).update({money: 1998})db.session.commit()return okapp.route(/update3)
def update3():# 字段引用[利用当前一条数据的字典值进行辅助操作,实现类似django里面F函数的效果]# 每次自增100Student.query.filter(Student.name 小花).update({money: Student.money 100})db.session.commit()return okapp.route(/update4)
def update4():# 字段引用[利用当前一条数据的字典值进行辅助操作,实现类似django里面F函数的效果]# 在原有money的基础上按age补贴1000*ageStudent.query.filter(Student.name zhang).update({money: Student.money 1000 * Student.age})db.session.commit()return okif __name__ __main__:app.run()基本查询
SQLAlchemy常用的查询过滤器
过滤器说明filter()把过滤器添加到原查询上返回一个新查询filter_by()把等值过滤器添加到原查询上返回一个新查询limit()使用指定的值限定原查询返回的结果数量offset()设置结果范围的开始位置偏移原查询返回的结果返回一个新查询order_by()根据指定条件对原查询结果进行排序返回一个新查询group_by()根据指定条件对原查询结果进行分组返回一个新查询
SQLAlchemy常用的查询结果方法
方法说明all()以列表形式返回查询的所有结果first()返回查询的第一个结果模型对象如果未查到返回Nonefirst_or_404()返回查询的第一个结果模型对象如果未查到通过abort 返回404异常get()返回指定主键对应的模型对象如不存在返回Noneget_or_404()返回指定主键对应的行如不存在abort 返回404count()返回查询结果的数量paginate()返回一个Paginate分页器对象它包含指定范围内的结果having()返回结果中符合条件的数据必须跟在group by后面其他地方无法使用。
get():参数为主键表示根据主键查询数据如果主键不存在返回None
app.route(/get)
def get():按主键获取一条# student Student.query.get({id: 5})# student Student.query.get((5,))# student db.session.query(Student).get(5)student Student.query.get(5)print(student)return ok
课堂代码
# 前面代码省略app.route(/)
def index():return okapp.route(/create)
def create_table():db.create_all() # 为项目中被识别的所有模型创建数据表return okapp.route(/drop)
def drop_table():db.drop_all() # 为项目中被识别的所有模型删除数据表return okapp.route(/query)
def query():query1 Student.query # 简写操作query2 db.session.query(Student)print(type(query1), query1)print(type(query2), query2)return okapp.route(/get)
def get():get根据主键获取数据 # student1 Student.query.get({id:10})student1 Student.query.get(30)# student2 db.session.query(Student).get({id:10})student2 db.session.query(Student).get(30)# 结果是模型对象print(type(student1), student1)print(type(student2), student2)# 查询不到结果则返回值为Noneif student1:print(student1.name, student1.age)if student2:print(student2.name, student2.age)return okif __name__ __main__:app.run()
all()返回查询到的所有对象
模型类.query.all()获取多个数据
student Student.query.all()
print(student) # [dongStudent, 小红Student, wangStudent, chenStudent, zhouStudent, tangStudent, wuStudent, qianStudent, liuStudent, liStudent, sunStudent]student Student.query.filter(Student.id5).all() # 没有结果返回空列表[]
print(student) # [dongStudent, 小红Student, wangStudent]# all()的返回值是一个python列表可以直接使用切片与django的QuerySet完全不是一回事。
student Student.query.filter(Student.id 5).all()[:-1] # 没有结果返回空列表[]
print(student) # [dongStudent, 小红Student]count 返回结果的数量
# 返回结果的数量
ret Student.query.filter(Student.id 5).count()
print(fret{ret})first()返回查询到的第一个对象【first获取一条数据,all获取多条数据】
模型类.query.first()获取第一个数据
student Student.query.first()
print(student)student Student.query.filter(Student.id5).first() # 没有结果返回None
print(student)filter条件查询支持各种运算符和查询方法或者模糊查询方法。
返回名字结尾字符为g的所有数据。
# 模糊查询
# 使用163邮箱的所有用户
student_list Student.query.filter(Student.email.endswith(163.com)).all()
print(student_list)# 姓名以zh开头的
student_list Student.query.filter(Student.name.startswith(zh)).all()
print(student_list)# 名字中带有a字母的数据
student_list Student.query.filter(Student.name.contains(a)).all()
print(student_list)单条件比较
# 则需要指定条件格式为: filter(模型.字段 比较运算符 值)。
# 运算符可以是: 表示相等, !不相等 表示大于 表示小于大于等于小于等于
# student_list Student.query.filter(Student.age 18).all()
# print(student_list) # [wangStudent, chenStudent, zhouStudent,...]多条件比较
# 要求多个条件都要满足相当于逻辑查询中的 并且(and)
student_list Student.query.filter(Student.age 18, Student.sex True).all()
print(student_list) # [wangStudent, chenStudent, qianStudent, liuStudent]filter_by精确条件查询
filter_by 只支持字段的值是否相等的情况对于大于、等于、等等其他条件是不支持的。
例如返回age等于22的学生
# 单条件
student_list Student.query.filter_by(age22).all() # 字段添加不需要附带模型类
print(student_list)# 多条件
student_list Student.query.filter_by(age22,sexTrue).all()
print(student_list)练习
查询所有男生[Student.sexTrue]数据查询id为4的学生[3种方式]查询年龄等于22的所有学生数据查询name为小白的学生数据查询20岁的男生代码
from flask import Flask, render_template
from flask_sqlalchemy import SQLAlchemydb SQLAlchemy()
app Flask(__name__, template_foldertemplates, static_folderstatic)# 配置
app.config.update({DEBUG: True,SQLALCHEMY_DATABASE_URI: mysql://root:123127.0.0.1:3306/flaskdemo?charsetutf8mb4,# 如果使用pymysql则需要在连接时指定pymysql# SQLALCHEMY_DATABASE_URI: mysqlpymysql://root:123127.0.0.1:3306/flaskdemo?charsetutf8mb4# 动态追踪修改设置如未设置只会提示警告设置False即可SQLALCHEMY_TRACK_MODIFICATIONS: False,# ORM执行SQL查询时是哦否显示原始SQL语句debug模式下可以开启SQLALCHEMY_ECHO: True,
})db.init_app(app)class Student(db.Model):学生管理__tablename__ db_student # 表名# 属性名 db.Column(字段类型, 字段列约束选项)# 如果SQL语句中的字段名在python中是关键字/保留字则建议改写绑定字段名# 属性名 db.Column(字段名, 字段类型, 字段列约束选项)id db.Column(student_id, db.Integer, primary_keyTrue, comment主键)name db.Column(db.String(15), indexTrue, comment姓名)age db.Column(db.SmallInteger, comment年龄)sex db.Column(db.SmallInteger, comment性别)email db.Column(db.String(255), uniqueTrue, comment邮箱地址)money db.Column(db.Numeric(10,2), default0.0, comment钱包)# repr()方法类似于django的__str__用于打印模型对象时显示的字符串信息def __repr__(self):return f{self.__class__.__name__} {self.name}# 所有的模型必须直接或间接继承于db.Model
class Course(db.Model):课程数据模型__tablename__ db_course# 原生SQL语句create table db_course (id int primary key auto_increment comment 主键,name varchar(64) comment 课程,price NUMERIC(7,2) comment 价格,unique (name));# 字段根据SQL语句来声明id db.Column(db.Integer, primary_keyTrue, comment主键)name db.Column(db.String(64), uniqueTrue, comment课程)price db.Column(db.Numeric(7, 2), comment价格)# repr()方法类似于django的__str__用于打印模型对象时显示的字符串信息def __repr__(self):return f{self.name}{self.__class__.__name__}class Teacher(db.Model):老师数据模型__tablename__ db_teacher# 原生SQL语句create table db_teacher (id int primary key auto_increment comment 主键,name varchar(64) comment 姓名,option enum(讲师, 助教, 班主任) comment 职位,unique (name));# 字段根据SQL语句来声明id db.Column(db.Integer, primary_keyTrue, comment主键)name db.Column(db.String(64), uniqueTrue, comment姓名)option db.Column(db.Enum(讲师, 助教, 班主任), default讲师)def __repr__(self):return f{self.name}{self.__class__.__name__}app.route(/)
def index():return okapp.route(/create)
def create_table():db.create_all() # 为项目中被识别的所有模型创建数据表return okapp.route(/drop)
def drop_table():db.drop_all() # 为项目中被识别的所有模型删除数据表return okapp.route(/exam)
def exam():# 查询所有男生[Student.sex True]数据# student_list Student.query.filter(Student.sex True).all()# print(student_list)# 查询id为4的学生[3种方式]# 1. get# student Student.query.get(4)# print(student)# 2. filterfirst# student Student.query.filter(Student.id 4).first()# print(student)# 3. filter_by first# student Student.query.filter_by(id4).first()# print(student)# 查询年龄等于20的所有学生数据# student_list Student.query.filter(Student.age 20).all()# print(student_list)# 查询name为小白的学生数据# student Student.query.filter(Student.name 小白).first()# print(student)# 查询20岁的男生student_list Student.query.filter(Student.age 20, Student.sex True).all()print(student_list)return okif __name__ __main__:app.run()
多条件查询
逻辑与需要导入and_返回and_()条件满足的所有数据
from sqlalchemy import and_
Student.query.filter(and_(Student.name!wang,Student.email.endswith(163.com))).all()# # and_(条件1,条件2,....) 等价于 filter(条件1,条件2,.....)
# # age 18 and email like %163.com
# # student_list Student.query.filter(Student.age 18, Student.email.endswith(163.com)).all()
#
# student_list Student.query.filter(
# and_(
# Student.age 18,
# Student.email.endswith(163.com)
# )
# ).all()逻辑或需要导入or_
from sqlalchemy import or_
Student.query.filter(or_(Student.name!wang,Student.email.endswith(163.com))).all()# 查询年龄在20岁使用的邮箱是qq或者163邮箱的
student_list Student.query.filter(Student.age 20,or_(Student.email.endswith(qq.com),Student.email.endswith(163.com))
).all()# 复合条件的查询情况
# 查询年龄17岁的女生或者年龄18岁的男生
student_list Student.query.filter(or_(and_(Student.age 17, Student.sex False),and_(Student.age 18, Student.sex True),)
).all()
print(student_list)print(student_list)逻辑非返回名字不等于小白的所有数据
Student.query.filter(Student.name!小白).all()not_ 相当于取反
from sqlalchemy import not_
Student.query.filter(not_(Student.name小白)).all()# # 查询年龄不等于22
# student_list Student.query.filter(Student.age ! 22).all()
# print(student_list)
# student_list Student.query.filter(not_(Student.age22)).all()
# print(student_list)in_范围查询
# 查询id是 5, 7, 10 的学生信息
student_list Student.query.filter(Student.id.in_([5, 7, 10])).all()
print(student_list)# 查询id不是 1 3 5 的学生信息
student_list Student.query.filter(not_(Student.id.in_([1, 3, 5]))).all()
print( student_list )is_判断值查询 判断值查询student_list Student.query.filter(Student.email.is_(None)).all()print(student_list)student_list Student.query.filter(Student.email None).all()print(student_list)order_by 排序
# 倒序[值从大到小]
student_list Student.query.order_by(Student.id.desc()).all()
# 升序[值从小到大]
student_list Student.query.order_by(Student.id.asc()).all()# 多字段排序[第一个字段值一样时比较第二个字段进行排序]
student_list Student.query.order_by(Student.money.asc(), Student.age.asc(), Student.id.asc()).all()
print(student_list)count统计
# 查询age19的男生的数量
from sqlalchemy import and_
# ret Student.query.filter( and_(Student.age19,Student.sexTrue) ).count()
ret Student.query.filter( Student.age19, Student.sexTrue ).count()对结果进行偏移量和数量的限制
# 查询年龄最大的3个学生
student_list Student.query.order_by(Student.age.desc()).limit(3).all()
print(student_list)# 查询年龄排第4到第7名的学生
student_list Student.query.order_by(Student.age.desc()).offset(3).limit(4).all()
print(student_list)# 查询年龄最小的3个人
student_list Student.query.order_by(Student.age.asc()).limit(3).all()
print(student_list)SQL
# 查询年龄最大的3个学生
# select * from db_student order by age desc limit 3;# 查询年龄排第4到第7名的学生
select * from db_student order by age desc limit 3, 4;
# select * from db_student order by age desc limit 4 offset 3;# 查询年龄最小的3个人
# select * from db_student order by age asc limit 3;练习
# 查询age是18 或者 使用163邮箱的所有学生
Student.query.filter(or_(Student.age18,Student.email.endswith(163.com))).all()
# 查询id为 [1, 3, 5, 7, 9] 的学生列表
student_list Student.query.filter(Student.id.in_([1, 3, 5, 7, 9])).all()
print(student_list)分页器
manage.py代码
from flask import Flask
from flask_sqlalchemy import SQLAlchemyapp Flask(__name__)
class Config(object):DEBUG True# 数据库链接配置 数据库名称://登录账号:登录密码数据库主机IP:数据库访问端口/数据库名称?charset编码类型SQLALCHEMY_DATABASE_URI mysql://root:123127.0.0.1:3306/flaskdemo?charsetutf8mb4# 动态追踪修改设置如未设置只会提示警告SQLALCHEMY_TRACK_MODIFICATIONS False# ORM运行时会显示ORM生成的原始SQL语句[调试]SQLALCHEMY_ECHO Trueapp.config.from_object(Config)模型类定义
db SQLAlchemy(appapp)class Student(db.Model):学生信息模型# 声明与当前模型绑定的数据表名称__tablename__ db_studentid db.Column(db.Integer, primary_keyTrue,comment主键)name db.Column(db.String(15), indexTrue, comment姓名)age db.Column(db.SmallInteger, comment年龄)sex db.Column(db.Boolean, defaultTrue, comment性别)email db.Column(db.String(128), uniqueTrue, comment邮箱地址)money db.Column(db.Numeric(10,2), default0.0, comment钱包)def __repr__(self): # 相当于django的__str__return f{self.name}{self.__class__.__name__}# 所有的模型必须直接或间接继承于db.Model
class Course(db.Model):课程数据模型__tablename__ db_courseid db.Column(db.Integer, primary_keyTrue, comment主键)name db.Column(db.String(64), uniqueTrue, comment课程)price db.Column(db.Numeric(7, 2), comment价格)def __repr__(self):return f{self.name}{self.__class__.__name__}class Teacher(db.Model):老师数据模型__tablename__ db_teacherid db.Column(db.Integer, primary_keyTrue, comment主键)name db.Column(db.String(64), uniqueTrue, comment姓名)option db.Column(db.Enum(讲师, 助教, 班主任), default讲师)def __repr__(self):return f{self.name}{self.__class__.__name__}from flask import request,render_templateapp.route(/)
def index():# 分页器page int(request.args.get(page, 1))size int(request.args.get(size, 3))pagination Student.query.paginate(page, size)print(pagination)from flask_sqlalchemy import Pagination# 常用属性total 总数据量items 每一页数据项列表pages 总页码 math.ceil( total/per_page )# 常用方法prev 上一页分页对象prev_num 上一页页码has_prev 是否有上一页next 下一页分页对象next_num 下一页页码has_next 是否有下一页print(pagination.items) # 当前页的数据项列表print(pagination.total) # 总数据量print(pagination.pages) # 总页码数量print(pagination.prev_num) # 上一页页码print(pagination.next_num) # 下一页页码print(pagination.has_prev) # 是否有上一页print(pagination.has_next) # 是否有下一页print(pagination.prev()) # 上一页的分页对象print(pagination.next()) # 下一页的分页对象# 前后端分离# data {# page: pagination.page, # 当前页码# pages: pagination.pages, # 总页码# has_prev: pagination.has_prev, # 是否有上一页# prev_num: pagination.prev_num, # 上一页页码# has_next: pagination.has_next, # 是否有下一页# next_num: pagination.next_num, # 下一页页码# items: [{# id: item.id,# name: item.name,# age: item.age,# sex: item.sex,# money: item.money,# } for item in pagination.items]# }# return data前后端不分离return render_template(list.html,**locals())if __name__ __main__:with app.app_context():db.create_all()app.run()list.html代码
!DOCTYPE html
html langen
headmeta charsetUTF-8titleTitle/titlestyle.page a,.page span{padding: 2px 6px;color: #fff;background: #6666ff;text-decoration: none;}.page span{color: #fff;background: orange;}/style
/head
bodytable border1 aligncenter width600trthID/ththage/ththname/ththsex/ththmoney/th/tr{% for student in pagination.items %}trtd{{ student.id }}/tdtd{{ student.age }}/tdtd{{ student.name }}/tdtd{{ 男 if student.sex else 女 }}/tdtd{{ student.money }}/td/tr{% endfor %}tr aligncentertd colspan5 classpage{% if pagination.has_prev %}a href?page1首 页/aa href?page{{ pagination.page-1 }}上一页/aa href?page{{ pagination.page-1 }}{{ pagination.page-1 }}/a{% endif %}span{{ pagination.page }}/span{% if pagination.has_next %}a href?page{{ pagination.page1 }}{{ pagination.page1 }}/aa href?page{{ pagination.page1 }}下一页/aa href?page{{ pagination.pages }}尾 页/a{% endif %}/td/tr/table
/body
/html聚合分组
分组查询和分组查询结果过滤
一般分组都会结合聚合函数来一起使用。SQLAlchemy中所有的聚合函数都在func模块中声明的。
from sqlalchemy import func函数名说明func.count统计总数func.avg平均值func.min最小值func.max最大值func.sum求和
代码
聚合函数
from sqlalchemy import func
# 获取所有学生的money总数
# SELECT sum(db_student.money) AS sum_1 FROM db_student LIMIT %s
# ret db.session.query(func.sum(Student.money)).first()[0]
# print(ret) # 3998.0
# # 查询女生的数量
# ret db.session.query(func.count(Student.id)).filter(Student.sexFalse).first()[0]
# print(ret) # 7
# # 查询所有学生的平均年龄
# ret db.session.query(func.avg(Student.age)).first()[0]
# print(ret) # 18.2727
聚合分组
在聚合分组的情况下db.session.query中的参数只能是被分组的字段或者是被聚合的数据# # 查询当前所有男生女生的数量
# ret db.session.query(Student.sex,func.count(Student.id)).group_by(Student.sex).all()
# print(ret) # [(False, 7), (True, 4)]# # 查询各个年龄段的学生数量
# ret db.session.query(Student.age, func.count(Student.id)).group_by(Student.age).all()
# print(ret) # [(15, 2), (13, 1), (22, 4), (19, 1), (18, 1), (16, 1), (17, 1)]
#
# # 查看当前男生女生的平均年龄
# ret db.session.query(Student.sex, func.avg(Student.age)).group_by(Student.sex).all()
# ret [{sex:男 if item[0] else 女,age:float(item[1])} for item in ret]
# print(ret) # [{sex: 女, age: 18.0}, {sex: 男, age: 18.75}]# # 分组后的过滤操作 having
# # 在所有学生中找出各个年龄中拥有最多钱的同学并在这些同学里面筛选出money 500的数据
# subquery func.max(Student.money)
# print(subquery) # max(db_student.money)
# ret db.session.query(Student.age, subquery).group_by(Student.age).having(subquery 500).all()
# print(ret) # [(18, Decimal(1000.00)), (22, Decimal(26000.00)), (23, Decimal(1998.00))]
多字段分组字段1 字段21 32 4分组如下13142324# 各个年龄里男生和女生的money总数
subquery func.sum(Student.money)
ret db.session.query(Student.sex, Student.age, subquery).group_by(Student.sex, Student.age).all()
print(ret) # [(False, 15, 1000.0), (False, 13, 600.0), (True, 15, 0.0), (True, 22, 1998.0), (False, 19, 0.0), (False, 22, 400.0), (False, 18, 0.0), (True, 16, 0.0), (False, 17, 0.0)]SQL方法中的关键字顺序
模型.query. // db.session.query.
filter/ filter_by
group by
having
order_by
limit offset
all / get / first / count / paginate执行原生SQL语句
执行原生SQL语句
# # 查询多条数据
# ret db.session.execute(select * from db_student).fetchall()
# print(ret)
# # 查询一条数据
# ret db.session.execute(select * from db_student).fetchone()
# print(ret)name age achievement80小明 17 8183group_concat 逗号合并小明 17 80,81,83concat 字符串拼接小明 17 808183# # 添加数据
# db.session.execute(insert db_student (name,age,sex,email,money) select name,age,sex,concat(now(),email),money from db_student)
# db.session.commit()# # # 更新/删除
# db.session.execute(UPDATE db_student SET money(db_student.money %s) WHERE db_student.age %s % (200, 22))
# db.session.commit()分组合并
# 统计各个年龄段的学生人数并记录对应年龄段的学生ID
ret db.session.execute(select age,count(id),group_concat(id) from db_student group by age).fetchall()
print(ret)
return ok关联查询
常用的SQLAlchemy关系选项
选项名说明backref在关系的另一模型中添加反向引用,用于设置外键名称,在1查多的primary join明确指定两个模型之间使用的连表条件, 用于1对1 或者1对多连表中lazy指定如何加载关联模型数据的方式用于1对1或1对多链表中。参数值:select立即加载查询所有相关数据显示相当于lazyTruesubquery立即加载但使用子查询dynamic不立即加载但提供加载记录的查询对象uselist指定1对1或1对多连表时返回的数据结果是模型对象还是模型列表如果为False不使用列表而使用模型对象。1对1或多对1关系中需要设置relationship中的uselistFlase1对多或多对多关系中需要设置relationshio中的uselistTrue。secondary指定多对多关系中关系表的名字。多对多关系中需建立关系表设置 secondary关系表secondary join在SQLAlchemy中无法自行决定时指定多对多关系中的二级连表条件绑定主外键。
范式理论一套提供给数据库开发者设置标准、规范的数据库的理论。
1NF. 数据不可再分必须保证原子性。数据的值保证可以方便存储不可再分。
2NF. 数据不能重复必须保证唯一性。必须使用主键来进行区分每一行数据。
3NF. 数据不能冗余必须保证关联性。冗余的数据必须使用另外的数据表存放并与当前表进行关联。基于实际业务的角度出发设计出违背了范式理论的表结构。
逆范式以空间换时间class table:id name teacher 1 301班 李老师 2 302班 王老师 student table:id name class_id1 xiaoming 12 xiaohong 23 xiaohui 3
三范式逆范式
第三范式数据不能冗余把关联性不强的数据可以移除到另一个表中。使用外键进行管理。
1对1把主表的主键放到附加表中作为外键存在。商品信息表id name price image 描述 售后 配置 包装1 PC-1-gr 100 1.png 2 PC-1-re 100 1.png3 PC-1-he 100 1.png4 PC-1-bu 100 1.png1对多把主表(1) 的主键放到附加表(多)作为外键存在。订单信息表 订单详情表1个订单 ---- 多个商品多对多把主表(多)的主键和附加表的(多)主键放到第三方表(关系表)中作为外键。用户表 课程表1 xiaoming 1 python2 xiaohong 2 django3 xiaolong 3 flask用户与课程的购买关系表user_id course1 11 21 3模型之间的关联
一对一
常见的业务主表和详情表用户、会员、学生、商品、文章、主机
class Student(db.Model):个人信息主表....# 关联属性这个不会被视作表字段只是模型对象的属性。# 因为StudentInfo和Student是一对一的关系所以uselistFalse表示关联一个数据info db.relationship(StudentInfo, uselistFalse, backrefown)class StudentInfo(db.Model):个人信息附加表# 外键# 如果是一对一则外键放在附加表对应的模型中# 如果是一对多则外键放在多的表对象的模型中# sid db.Column(db.Integer, db.ForeignKey(Student.id),comment外键)sid db.Column(db.Integer, db.ForeignKey(student表名.主键),comment外键)关联属性声明在主模型中【最常用】
代码
import json
from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from sqlalchemy import funcdb SQLAlchemy()
app Flask(__name__, template_foldertemplates, static_folderstatic)# 配置
app.config.update({DEBUG: True,SQLALCHEMY_DATABASE_URI: mysql://root:123127.0.0.1:3306/flaskdemo?charsetutf8mb4,# 如果使用pymysql则需要在连接时指定pymysql# SQLALCHEMY_DATABASE_URI: mysqlpymysql://root:123127.0.0.1:3306/flaskdemo?charsetutf8mb4# 动态追踪修改设置如未设置只会提示警告设置False即可SQLALCHEMY_TRACK_MODIFICATIONS: False,# ORM执行SQL查询时是哦否显示原始SQL语句debug模式下可以开启SQLALCHEMY_ECHO: True,
})db.init_app(app)class Student(db.Model):学生管理__tablename__ tb_student # 表名id db.Column(db.Integer, primary_keyTrue, comment主键)name db.Column(db.String(15), indexTrue, comment姓名)age db.Column(db.SmallInteger, comment年龄)sex db.Column(db.SmallInteger, comment性别)email db.Column(db.String(255), uniqueTrue, comment邮箱地址)money db.Column(db.Numeric(10,2), default0.0, comment钱包)# 模型的关联属性不会在数据表创建字段# 因为StudentInfo和Student是一对一的关系所以uselistFalse表示关联一个数据info db.relationship(StudentInfo, uselistFalse, backrefstudent)def __repr__(self):return json.dumps(self.__to_dict__, ensure_asciiFalse)propertydef __to_dict__(self):return {id: self.id,name: self.name,age: self.age,sex: self.sex,email: self.email,money: float(self.money),}class StudentInfo(db.Model):__tablename__ tb_student_info # 表名id db.Column(db.Integer, primary_keyTrue, comment主键)# 附加表的外键就是主表的主键# 如果是一对一则外键放在附加表对应的模型中# 如果是一对多则外键放在多的附加表对应的模型中sid db.Column(db.Integer, db.ForeignKey(tb_student.id), comment外键) # mysql字段# student db.relationship(Student, uselistFalse, backrefinfo) # ORM关联属性mobile db.Column(db.String(15), indexTrue, comment手机号码)address db.Column(db.String(255), nullableTrue, comment家庭地址)def __repr__(self):return json.dumps(self.__to_dict__, ensure_asciiFalse)propertydef __to_dict__(self):return {id: self.id,sid: self.sid,mobile: self.mobile,address: self.address,}app.route(/create)
def create_table():db.create_all() # 为项目中被识别的所有模型创建数据表return okapp.route(/drop)
def drop_table():db.drop_all() # 为项目中被识别的所有模型删除数据表return okapp.route(/a1)
def a1():添加操作# 添加主表信息的时候通过关联属性db.relationship同步添加附件表信息student Student(namexiaolan01,age16,sexFalse,money10000,emailxiaolan01qq.com,infoStudentInfo(address北京市昌平区百沙路203号,mobile13312345672))db.session.add(student)db.session.commit()return okapp.route(/a2)
def a2():添加操作# 假设已经存在主表信息后面再补充附加表信息# student Student(# namexiaolan03,# age16,# sexFalse,# money10000,# emailxiaolan03qq.com,# )## db.session.add(student)# db.session.commit()# 上面代码先执行了现有1个学生没有附加信息的我们可以在后续代码通过查询主表的主键补充附加表数据student Student.query.get(3)if not student.info:添加附加表数据方式1# student.info StudentInfo(mobile13300010002, address北京市昌平区百沙路205号,)# db.session.commit()方式2# info StudentInfo(# studentstudent, # 关联属性# mobile13300010002,# address北京市昌平区百沙路205号,# )## db.session.add(info)# db.session.commit()方式3info StudentInfo(sidstudent.id, # 外键mobile13300010002,address北京市昌平区百沙路205号,)db.session.add(info)db.session.commit()return okapp.route(/a3)
def a3():添加操作# 添加附加模型数据的同时把主模型也进行添加info StudentInfo(mobile13300010003,address北京市昌平区百沙路206号,studentStudent(namexiaolan04,age17,sexFalse,money10000,emailxiaolan04qq.com,),)db.session.add(info)db.session.commit()return okapp.route(/g1)
def g1():查询操作# # 正向关联---- 从主模型查询外键模型# student Student.query.get(2)# print(student.name) # xiaolan01# # 如果主模型没有调用关联属性查询附加模型对象则ORM不会执行查询关联模型的SQL语句# print(student.info) # {id: 2, sid: 2, mobile: 13312345672, address: 北京市昌平区百沙路203号}# print(student.info.address) # 北京市昌平区百沙路203号# 反向关联---- 从外键模型查询主模型student_info StudentInfo.query.filter(StudentInfo.mobile 15012345678).first()print(student_info.address) # 北京市昌平区百沙路206号# 如果附加模型没有调用关联属性查询主模型对象则ORM不会执行查询主模型的SQL语句print(student_info.student) # {id: 4, name: xiaolan04, age: 17, sex: 0, email: xiaolan04qq.com, money: 10000.0}print(student_info.student.name) # xiaolan04print(student_info.sid) # 4return okapp.route(/u1)
def u1():修改数据# # 通过主模型使用关联属性修改附加模型的数据# student Student.query.get(2)# student.info.address 广州市天河区天河东路103号# db.session.commit()# 也可以通过附加模型直接修改主模型的数据student_info StudentInfo.query.filter(StudentInfo.mobile 13312345678).first()# 如果要修改的数据与数据表的没有改动则不会执行更新的SQL语句student_info.student.age 23db.session.commit()return okapp.route(/d1)
def d1():删除数据# # 1. 如果删除主模型数据则会先将附加模型的外键设置为null然后才会删除主模型对象# student Student.query.get(4)# db.session.delete(student)# db.session.commit()# 2. 如果删除附加模型数据则直接删除不会修改主模型数据StudentInfo.query.filter(StudentInfo.mobile 13312345678).delete()db.session.commit()return okif __name__ __main__:app.run()在外键模型中声明关联属性
代码
import json
from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from sqlalchemy.orm import backrefdb SQLAlchemy()
app Flask(__name__, template_foldertemplates, static_folderstatic)# 配置
app.config.update({DEBUG: True,SQLALCHEMY_DATABASE_URI: mysql://root:123127.0.0.1:3306/flaskdemo?charsetutf8mb4,# 如果使用pymysql则需要在连接时指定pymysql# SQLALCHEMY_DATABASE_URI: mysqlpymysql://root:123127.0.0.1:3306/flaskdemo?charsetutf8mb4# 动态追踪修改设置如未设置只会提示警告设置False即可SQLALCHEMY_TRACK_MODIFICATIONS: False,# ORM执行SQL查询时是哦否显示原始SQL语句debug模式下可以开启SQLALCHEMY_ECHO: True,
})db.init_app(app)class Student(db.Model):学生管理__tablename__ tb_student # 表名id db.Column(db.Integer, primary_keyTrue, comment主键)name db.Column(db.String(15), indexTrue, comment姓名)age db.Column(db.SmallInteger, comment年龄)sex db.Column(db.SmallInteger, comment性别)email db.Column(db.String(255), uniqueTrue, comment邮箱地址)money db.Column(db.Numeric(10, 2), default0.0, comment钱包)def __repr__(self):return json.dumps(self.__to_dict__, ensure_asciiFalse)propertydef __to_dict__(self):return {id: self.id,name: self.name,age: self.age,sex: self.sex,email: self.email,money: float(self.money),}class StudentInfo(db.Model):__tablename__ tb_student_info # 表名id db.Column(db.Integer, primary_keyTrue, comment主键)# 附加表的外键就是主表的主键# 如果是一对一则外键放在附加表对应的模型中# 如果是一对多则外键放在多的附加表对应的模型中sid db.Column(db.Integer, db.ForeignKey(tb_student.id), comment外键) # mysql字段# 模型的关联属性不会在数据表创建字段# 因为StudentInfo和Student是一对一的关系所以uselistFalse表示关联一个数据student db.relationship(Student, uselistFalse, backrefbackref(info, uselistFalse)) # ORM关联属性mobile db.Column(db.String(15), indexTrue, comment手机号码)address db.Column(db.String(255), nullableTrue, comment家庭地址)def __repr__(self):return json.dumps(self.__to_dict__, ensure_asciiFalse)propertydef __to_dict__(self):return {id: self.id,sid: self.sid,mobile: self.mobile,address: self.address,}app.route(/create)
def create_table():db.create_all() # 为项目中被识别的所有模型创建数据表return okapp.route(/drop)
def drop_table():db.drop_all() # 为项目中被识别的所有模型删除数据表return okapp.route(/a1)
def a1():添加操作# 添加主表信息的时候通过关联属性db.relationship同步添加附件表信息student Student(namexiaolan01,age16,sexFalse,money10000,emailxiaolan01qq.com,infoStudentInfo(address北京市昌平区百沙路203号,mobile13312345672))db.session.add(student)db.session.commit()return okapp.route(/a2)
def a2():添加操作# 假设已经存在主表信息后面再补充附加表信息# student Student(# namexiaolan03,# age16,# sexFalse,# money10000,# emailxiaolan03qq.com,# )## db.session.add(student)# db.session.commit()# 上面代码先执行了现有1个学生没有附加信息的我们可以在后续代码通过查询主表的主键补充附加表数据student Student.query.get(2)if student and not student.info:添加附加表数据方式1# student.info StudentInfo(mobile13300010002, address北京市昌平区百沙路205号,)# db.session.commit()方式2# info StudentInfo(# studentstudent, # 关联属性# mobile13300010002,# address北京市昌平区百沙路205号,# )## db.session.add(info)# db.session.commit()方式3info StudentInfo(sidstudent.id, # 外键mobile13300010002,address北京市昌平区百沙路205号,)db.session.add(info)db.session.commit()return okapp.route(/a3)
def a3():添加操作# 添加附加模型数据的同时把主模型也进行添加info StudentInfo(mobile13300010003,address北京市昌平区百沙路206号,studentStudent(namexiaolan04,age17,sexFalse,money10000,emailxiaolan04qq.com,),)db.session.add(info)db.session.commit()return okapp.route(/g1)
def g1():查询操作# # 正向关联---- 从主模型查询外键模型# student Student.query.get(2)# print(student.name) # xiaolan01# # 如果主模型没有调用关联属性查询附加模型对象则ORM不会执行查询关联模型的SQL语句# print(student.info) # {id: 2, sid: 2, mobile: 13312345672, address: 北京市昌平区百沙路203号}# print(student.info.address) # 北京市昌平区百沙路203号# 反向关联---- 从外键模型查询主模型student_info StudentInfo.query.filter(StudentInfo.mobile 13300010003).first()print(student_info.address) # 北京市昌平区百沙路206号# 如果附加模型没有调用关联属性查询主模型对象则ORM不会执行查询主模型的SQL语句print(student_info.student) # {id: 3, name: xiaolan04, age: 17, sex: 0, email: xiaolan04qq.com, money: 10000.0}print(student_info.student.name) # xiaolan04print(student_info.sid) # 3return okapp.route(/u1)
def u1():修改数据# 通过主模型使用关联属性修改附加模型的数据student Student.query.get(2)student.info.address 广州市天河区天河东路103号db.session.commit()# # 也可以通过附加模型直接修改主模型的数据# student_info StudentInfo.query.filter(StudentInfo.mobile 13312345672).first()# # 如果要修改的数据与数据表的没有改动则不会执行更新的SQL语句# student_info.student.age 23# db.session.commit()return okapp.route(/d1)
def d1():删除数据# # 1. 如果删除主模型数据则会先将附加模型的外键设置为null然后才会删除主模型对象student Student.query.get(2)db.session.delete(student)db.session.commit()# 2. 如果删除附加模型数据则直接删除不会修改主模型数据# StudentInfo.query.filter(StudentInfo.mobile 13312345672).delete()# db.session.commit()return okif __name__ __main__:app.run()
一对多
常见业务商品分类和商品、文章分类和文章、班级与学生、部门与员工、角色与会员、订单与订单详情、用户与收货地址。。。
class User(db.Model):...# 关联属性一的一方添加模型关联属性address_list db.relationship(UserAddress, uselistTrue, backrefuser, lazydynamic)class UsertAddress(db.Model):...# 外键多的一方模型中添加外间user_id db.Column(db.ForeignKey(User.id))其中realtionship描述了Student和StudentAddress的关系。第1个参数为对应参照的类StudentAddress第3个参数backref为类StudentAddress声明关联属性第4个参数lazy决定了什么时候SQLALchemy什么时候执行读取关联模型的SQL语句 lazy‘subquery’查询当前数据模型时采用子查询(subquery)把外键模型的属性也同时查询出来了。lazyTrue或lazy‘select’查询当前数据模型时不会把外键模型的数据查询出来只有操作到外键关联属性时才进行连表查询数据[执行SQL]lazy‘dynamic’查询当前数据模型时不会把外键模型的数据立刻查询出来只有操作到外键关联属性并操作外键模型具体字段时才进行连表查询数据[执行SQL] 常用的lazy选项dynamic和select
课堂代码
manage.py代码
import json
from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from sqlalchemy.orm import backrefdb SQLAlchemy()
app Flask(__name__, template_foldertemplates, static_folderstatic)# 配置
app.config.update({DEBUG: True,SQLALCHEMY_DATABASE_URI: mysql://root:123127.0.0.1:3306/flaskdemo?charsetutf8mb4,# 如果使用pymysql则需要在连接时指定pymysql# SQLALCHEMY_DATABASE_URI: mysqlpymysql://root:123127.0.0.1:3306/flaskdemo?charsetutf8mb4# 动态追踪修改设置如未设置只会提示警告设置False即可SQLALCHEMY_TRACK_MODIFICATIONS: False,# ORM执行SQL查询时是哦否显示原始SQL语句debug模式下可以开启SQLALCHEMY_ECHO: True,
})db.init_app(app)class User(db.Model):__tablename__ tb_userid db.Column(db.Integer, primary_keyTrue, comment主键)username db.Column(db.String(50), uniqueTrue, comment用户名)nickname db.Column(db.String(50), indexTrue, comment昵称)sex db.Column(db.Boolean, defaultTrue, comment性别)money db.Column(db.Numeric(8,2), default0.0, comment钱包余额)address_list db.relationship(UserAddress, uselistTrue, backrefuser, lazydynamic)def __repr__(self):return json.dumps(self.__to_dict__, ensure_asciiFalse)propertydef __to_dict__(self):return {id: self.id,username: self.username,nickname: self.nickname,sex: self.sex,money: float(self.money),}class UserAddress(db.Model):__tablename__ tb_user_addressid db.Column(db.Integer, primary_keyTrue, comment主键)name db.Column(db.String(50), default默认, comment名称)province db.Column(db.String(50), comment省份)city db.Column(db.String(50), comment城市)area db.Column(db.String(50), comment地区)address db.Column(db.String(500), comment详细地址)mobile db.Column(db.String(15), comment收货人电话)user_id db.Column(db.Integer, db.ForeignKey(tb_user.id), comment外键)def __repr__(self):return json.dumps(self.__to_dict__, ensure_asciiFalse)propertydef __to_dict__(self):return {id: self.id,name: self.name,province: self.province,city: self.city,area: self.area,address: self.address,mobile: self.mobile,user_id: self.user_id,}app.route(/create)
def create_table():db.create_all() # 为项目中被识别的所有模型创建数据表return okapp.route(/drop)
def drop_table():db.drop_all() # 为项目中被识别的所有模型删除数据表return okapp.route(/)
def index():return okapp.route(/a1)
def a1():添加数据# # 添加主模型的同时也会给附加模型添加数据这种情况附加模型的值可以以列表形式进行添加一次性添加多个附加模型数据进去。# user User(# usernamexiaolan001,# nicknamexiaolan001,# sexFalse,# money10000,# address_list[# UserAddress(name公司, province北京市, city北京市, area昌平区, address百沙路201, mobile13012345678),# UserAddress(name门口小卖部, province北京市, city北京市, area昌平区, address百沙路202, mobile13012345677),# UserAddress(name小区门口, province北京市, city北京市, area昌平区, address百沙路203, mobile13012345676),# ]# )# db.session.add(user)# db.session.commit()# 添加外键模型数据的同时添加主模型数据address UserAddress(province天津市,city天津市,area静海区,address静安路1103号,userUser(usernamexiaolan02,nicknamexiaolan02,money10000,sexFalse,))db.session.add(address)db.session.commit()return okapp.route(/q1)
def q1():# 正向关联---- 从主模型查询外键模型student User.query.filter(User.username xiaolan001).first()# 观察连表SQL语句的执行 lazyselect || lazyTrue # print(student) # 没有查询附加表# print(student.address_list) # 查询了附加表 lazysubquery # print(student) # 已经查询了附加表如果没有使用到外键模型的数据则本次查询存在资源浪费 lazydynamic # print(student) # 没有查询附加表# student.address_list # 没有查询附加模型的SQL语句# print( student.address_list ) # 只要访问关联模型的具体字段才真正执行如果海量数量查询则本次查询会影响返回数据给客户端的时间print( student.address_list[0] ) # 获取返回列表的第1个成员return okif __name__ __main__:app.run()多对多
常见业务用户收藏文章、用户与用户之间的好友关系、点赞、评论、关注、用户浏览商品的历史记录、订阅文章、专题与商品/文章的关系、活动与商品。。。。。
# 关系表[这种表无法提供给python进行操作的仅仅用于在数据库中记录两个模型之间的关系]
# 关系表[这种表无法提供给python进行操作的仅仅用于在数据库中记录两个模型之间的关系]
student_and_course db.Table(table_student_course,db.Column(id, db.Integer, primary_keyTrue, comment主键ID),db.Column(sid, db.Integer, db.ForeignKey(table_student.id), comment学生),db.Column(cid, db.Integer, db.ForeignKey(table_course.id), comment课程),db.Column(created_time, db.DateTime, defaultdatetime.now, comment购买时间), # 当前字段无法操作
)class Student(db.Model):id db.Column(db.Integer, primary_keyTrue,comment主键)...course_list db.relationship(Course, secondarystudent_and_course, backrefstudent_list, lazydynamic)class Course(db.Model):...# 关系模型[关系模型和关系表任选其一]
class Achievement(db.Model):...基于第三方关系表构建多对多
代码
import json
from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from sqlalchemy.orm import backref
from datetime import datetimedb SQLAlchemy()
app Flask(__name__, template_foldertemplates, static_folderstatic)# 配置
app.config.update({DEBUG: True,SQLALCHEMY_DATABASE_URI: mysql://root:123127.0.0.1:3306/flaskdemo?charsetutf8mb4,# 如果使用pymysql则需要在连接时指定pymysql# SQLALCHEMY_DATABASE_URI: mysqlpymysql://root:123127.0.0.1:3306/flaskdemo?charsetutf8mb4# 动态追踪修改设置如未设置只会提示警告设置False即可SQLALCHEMY_TRACK_MODIFICATIONS: False,# ORM执行SQL查询时是哦否显示原始SQL语句debug模式下可以开启SQLALCHEMY_ECHO: True,
})db.init_app(app)# 关系表[这种表无法提供给python进行操作的仅仅用于在数据库中记录两个模型之间的关系]
student_and_course db.Table(table_student_course,db.Column(id, db.Integer, primary_keyTrue, comment主键ID),db.Column(sid, db.Integer, db.ForeignKey(table_student.id), comment学生),db.Column(cid, db.Integer, db.ForeignKey(table_course.id), comment课程),db.Column(created_time, db.DateTime, defaultdatetime.now, comment购买时间), # 当前字段无法操作
)class Student(db.Model):学生信息模型# 声明与当前模型绑定的数据表名称__tablename__ table_studentid db.Column(db.Integer, primary_keyTrue,comment主键)name db.Column(db.String(15), comment姓名)age db.Column(db.SmallInteger, comment年龄)sex db.Column(db.Boolean, defaultTrue, comment性别)email db.Column(db.String(128), comment邮箱地址)money db.Column(db.Numeric(10, 2), default0.0, comment钱包)course_list db.relationship(Course, secondarystudent_and_course, backrefstudent_list, lazydynamic)def __repr__(self):return json.dumps(self.__to_dict__, ensure_asciiFalse)propertydef __to_dict__(self):return {id: self.id,name: self.name,age: self.age,sex: self.sex,email: self.email,money: float(self.money),}class Course(db.Model):课程数据模型__tablename__ table_courseid db.Column(db.Integer, primary_keyTrue, comment主键)name db.Column(db.String(64), uniqueTrue, comment课程)price db.Column(db.Numeric(7, 2), default0.0, comment价格)def __repr__(self):return json.dumps(self.__to_dict__, ensure_asciiFalse)propertydef __to_dict__(self):return {id: self.id,name: self.name,price: self.price,}app.route(/create)
def create_table():db.create_all() # 为项目中被识别的所有模型创建数据表return okapp.route(/drop)
def drop_table():db.drop_all() # 为项目中被识别的所有模型删除数据表return okapp.route(/)
def index():return okapp.route(/a1)
def a1():添加数据添加其中一个主模型数据时同时绑定添加另外一个主模型的数据这个过程中关系表会自动写入2者的关系数据绑定2个模型之间的关系# student Student(# namexiaozhao,# age13,# sexFalse,# money30000,# emailxiaozhaoqq.com,# course_list[# Course(namepython入门, price99.99),# Course(namepython初级, price199.99),# Course(namepython进阶, price299.99),# ]# )# db.session.add(student)# db.session.commit()在学生报读课程的基础上新增报读课程。# student Student(# namexiaohong,# age14,# sexFalse,# money30000,# email300000qq.com,# )# db.session.add(student)# db.session.commit()# student Student.query.filter(Student.namexiaohong).first()# # 直接采用python内置的list方法操作# student.course_list.append(Course.query.get(3)) # 新增已经存在的课程# student.course_list.append(Course(namepython顶级, price399.99)) # 已有课程并让当前学生报读该课程# db.session.commit()添加学生报读课程的测试数据# student1 Student.query.get(1)# course_list Course.query.filter(Course.id.in_([1,2])).all()# student1.course_list.extend(course_list)# db.session.commit()student2 Student.query.get(2)course_list Course.query.filter(Course.id.in_([3,2])).all()student2.course_list.extend(course_list)db.session.commit()return okapp.route(/q1)
def q1():查询操作# 查询ID4的学生报读的课程列表# student Student.query.get(2)# course_list [{name:item.name,price:float(item.price)} for item in student.course_list]# print(course_list)# 查询出2号课程都有那些学生在读course Course.query.get(2)student_list [{name:item.name,age:item.age} for item in course.student_list]print(student_list)return okapp.route(/u1)
def u1():更新数据# # 给报读了3号课程的同学返现红包200块钱# course Course.query.get(3)# for student in course.student_list:# student.money200# db.session.commit()# db.Table的缺陷: 无法通过主模型直接操作db.Table中的外键之外的其他字段例如报读课程的时间course Course.query.get(3)print(course.student_list)# 解决在声明2个模型是多对多的关联关系时把关联关系使用第三个模型来创建声明# 就是不要使用db.Table改成模型来绑定关系把模型的对多对拆分成2个1对多return okif __name__ __main__:app.run()
多对多也可以拆解成3个模型2个主模型1个关系模型关系模型保存了2个主模型的外键其中tb_achievement作为单独模型存在。
基于第三方关系模型构建多对多
在SQLAlchemy中基于db.Table创建的关系表如果需要新增除了外键以外其他字段无法操作。所以将来实现多对多的时候除了上面db.Table方案以外还可以把关系表声明成模型的方法如果声明成模型则原来课程和学生之间的多对多的关系就会变成远程的1对多了。
代码
import json
from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from sqlalchemy.orm import backref
from datetime import datetimedb SQLAlchemy()
app Flask(__name__, template_foldertemplates, static_folderstatic)# 配置
app.config.update({DEBUG: True,SQLALCHEMY_DATABASE_URI: mysql://root:123127.0.0.1:3306/flaskdemo?charsetutf8mb4,# 如果使用pymysql则需要在连接时指定pymysql# SQLALCHEMY_DATABASE_URI: mysqlpymysql://root:123127.0.0.1:3306/flaskdemo?charsetutf8mb4# 动态追踪修改设置如未设置只会提示警告设置False即可SQLALCHEMY_TRACK_MODIFICATIONS: False,# ORM执行SQL查询时是哦否显示原始SQL语句debug模式下可以开启SQLALCHEMY_ECHO: True,
})db.init_app(app)# 关系表[这种表无法提供给python进行操作的仅仅用于在数据库中记录两个模型之间的关系]
# student_and_course db.Table(
# demo_student_course,
# db.Column(id, db.Integer, primary_keyTrue, comment主键ID),
# db.Column(sid, db.Integer, db.ForeignKey(demo_student.id), comment学生),
# db.Column(cid, db.Integer, db.ForeignKey(demo_course.id), comment课程),
# db.Column(created_time, db.DateTime, defaultdatetime.now, comment购买时间), # 当前字段无法操作
# )class StudentCourse(db.Model):__tablename__ demo_student_courseid db.Column(db.Integer, primary_keyTrue, comment主键)sid db.Column(db.Integer, db.ForeignKey(demo_student.id))cid db.Column(db.Integer, db.ForeignKey(demo_course.id))created_time db.Column(db.DateTime, defaultdatetime.now, comment购买时间)# 关联属性student db.relationship(Student, uselistFalse, backrefbackref(to_relation, uselistTrue))course db.relationship(Course, uselistFalse, backrefbackref(to_relation, uselistTrue))class Student(db.Model):学生信息模型# 声明与当前模型绑定的数据表名称__tablename__ demo_studentid db.Column(db.Integer, primary_keyTrue,comment主键)name db.Column(db.String(15), comment姓名)age db.Column(db.SmallInteger, comment年龄)sex db.Column(db.Boolean, defaultTrue, comment性别)email db.Column(db.String(128), comment邮箱地址)money db.Column(db.Numeric(10, 2), default0.0, comment钱包)def __repr__(self):return json.dumps(self.__to_dict__, ensure_asciiFalse)propertydef __to_dict__(self):return {id: self.id,name: self.name,age: self.age,sex: self.sex,email: self.email,money: float(self.money),}class Course(db.Model):课程数据模型__tablename__ demo_courseid db.Column(db.Integer, primary_keyTrue, comment主键)name db.Column(db.String(64), uniqueTrue, comment课程)price db.Column(db.Numeric(7, 2), default0.0, comment价格)def __repr__(self):return json.dumps(self.__to_dict__, ensure_asciiFalse)propertydef __to_dict__(self):return {id: self.id,name: self.name,price: self.price,}app.route(/create)
def create_table():db.create_all() # 为项目中被识别的所有模型创建数据表return okapp.route(/drop)
def drop_table():db.drop_all() # 为项目中被识别的所有模型删除数据表return okapp.route(/)
def index():return okapp.route(/a1)
def a1():添加数据添加其中一个主模型数据时同时绑定添加另外一个主模型的数据# student Student(# namexiaozhao,# age13,# sexFalse,# money30000,# emailxiaozhaoqq.com,# to_relation[# StudentCourse(# courseCourse(namepython基础, price99.9)# )# ]# )# db.session.add(student)# db.session.commit()在学生报读课程的基础上新增报读课程。# student Student(# namexiaohong,# age14,# sexFalse,# money30000,# email300000qq.com,# )# db.session.add(student)# db.session.commit()# student Student.query.filter(Student.name xiaohong).first()# # 直接采用python内置的list方法操作# student.to_relation.extend([# StudentCourse(# courseCourse.query.get(1) # 已经存在的课程给学生报读# ),# StudentCourse(# courseCourse(namepython进阶, price399.99) # 新增课程并让当前学生报读该课程# )# ])## db.session.commit()添加学生报读课程的测试数据student1 Student.query.get(1)course_list Course.query.filter(Course.id.in_([1,2])).all()student1.to_relation.extend([StudentCourse(coursecourse) for course in course_list])db.session.commit()return okapp.route(/q1)
def q1():查询操作# 查询ID2的学生报读的课程列表# student Student.query.get(2)# course_list [{name:item.course.name,price:float(item.course.price)} for item in student.to_relation]# print(course_list)# 查询出2号课程都有那些学生在读course Course.query.get(2)student_list [{name:item.student.name,age:item.student.age} for item in course.to_relation]print(student_list)return okapp.route(/u1)
def u1():更新数据# # 给报读了2号课程的同学返现红包200块钱# course Course.query.get(2)# for relation in course.to_relation:# relation.student.money 200# db.session.commit()# 获取中间的关系模型的字段course Course.query.get(2)for relation in course.to_relation:print(relation.created_time)return okif __name__ __main__:app.run()
relationship还有一个设置外键级联的属性cascade“all, delete, delete-orphan”
作业
1. 我们现在学习的flask框架集成SQLAlchemy操作数据库使用的是flask-SQLAlchemy模块。如果原生的python下面应该如何使用SQLAlchemy进行初始化数据库连接和声明模型并实现模型的基本操作[增删查改关联查询]2. flask中的SQLAlchemy如何进行自关联查询 这里自己写一个关于行政区划的自关联操作。逻辑外键
也叫虚拟外键。主要就是在开发中为了减少数据库的性能消耗提升系统运行效率一般项目中如果单表数据太大[千万级别]就不会使用数据库本身维护的物理外键而是采用由ORM或者我们逻辑代码进行查询关联的逻辑外键。
SQLAlchemy设置外键模型的虚拟外键有2种方案
方案1查询数据时临时指定逻辑外键的映射关系
模型类.query.join(模型类,主模型.主键外键模型.外键).join(模型类,主模型.主键外键模型.外键).with_entities(字段1,字段2.label(字段别名),....).all()方案2在模型声明时指定逻辑外键的映射关系(最常用这种设置方案在操作模型时与原来默认设置的物理外键的关联操作是一模一样的写法)
class Student(db.Model):id db.Column(db.Integer, primary_keyTrue, comment主键)# 虚拟外键原有参数不变新增2个表达关联关系的属性# primaryjoin, 指定2个模型之间的主外键关系相当于原生SQL语句中的join# foreign_keys指定外键address_list db.relationship(StudentAddress, uselistTrue, backrefstudent, lazysubquery, primaryjoinStudent.idStudentAddress.student_id, foreign_keysStudentAddress.student_id)class StudentAddress(db.Model):# 原来的外键设置为普通索引即可。student_id db.Column(db.Integer, comment学生id)例1虚拟外键使用的方案1代码
import json
from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from sqlalchemy.orm import backref
from datetime import datetimedb SQLAlchemy()
app Flask(__name__, template_foldertemplates, static_folderstatic)# 配置
app.config.update({DEBUG: True,SQLALCHEMY_DATABASE_URI: mysql://root:123127.0.0.1:3306/flaskdemo?charsetutf8mb4,# 如果使用pymysql则需要在连接时指定pymysql# SQLALCHEMY_DATABASE_URI: mysqlpymysql://root:123127.0.0.1:3306/flaskdemo?charsetutf8mb4# 动态追踪修改设置如未设置只会提示警告设置False即可SQLALCHEMY_TRACK_MODIFICATIONS: False,# ORM执行SQL查询时是哦否显示原始SQL语句debug模式下可以开启SQLALCHEMY_ECHO: True,
})db.init_app(app)class Student(db.Model):学生信息模型# 声明与当前模型绑定的数据表名称__tablename__ td_studentid db.Column(db.Integer, primary_keyTrue,comment主键)name db.Column(db.String(15), comment姓名)age db.Column(db.SmallInteger, comment年龄)sex db.Column(db.Boolean, defaultTrue, comment性别)email db.Column(db.String(128), comment邮箱地址)money db.Column(db.Numeric(10,2), default0.0, comment钱包)def __repr__(self):return f{self.name}Studentclass Course(db.Model):课程数据模型__tablename__ td_courseid db.Column(db.Integer, primary_keyTrue, comment主键)name db.Column(db.String(64), uniqueTrue, comment课程)price db.Column(db.Numeric(7, 2))def __repr__(self):return f{self.name}{self.__class__.__name__}class StudentCourse(db.Model):学生和课程之间的关系模型__tablename__ td_student_courseid db.Column(db.Integer, primary_keyTrue, comment主键)student_id db.Column(db.Integer, indexTrue)course_id db.Column(db.Integer, indexTrue)score db.Column(db.Numeric(4,1), default0, comment成绩)time db.Column(db.DateTime, defaultdatetime.now, comment考试时间)app.route(/create)
def create_table():db.create_all() # 为项目中被识别的所有模型创建数据表return okapp.route(/drop)
def drop_table():db.drop_all() # 为项目中被识别的所有模型删除数据表return okapp.route(/)
def index():return okapp.route(/a1)
def a1():# 添加测试数据stu0 Student(namexiaoming-0,age15,sexTrue,emailxiaoming0qq.com, money1000)stu1 Student(namexiaoming-1,age15,sexTrue,emailxiaoming1qq.com, money1000)stu2 Student(namexiaoming-2,age15,sexTrue,emailxiaoming2qq.com, money1000)stu3 Student(namexiaoming-3,age15,sexTrue,emailxiaoming3qq.com, money1000)stu4 Student(namexiaoming-4,age15,sexTrue,emailxiaoming4qq.com, money1000)db.session.add_all([stu0,stu1,stu2,stu3,stu4])course1 Course(namepython基础第1季, price1000)course2 Course(namepython基础第2季, price1000)course3 Course(namepython基础第3季, price1000)course4 Course(namepython基础第4季, price1000)course5 Course(namepython基础第5季, price1000)db.session.add_all([course1, course2, course3, course4, course5])data [StudentCourse(student_id1,course_id1,score60,timedatetime.now()),StudentCourse(student_id1,course_id2,score60,timedatetime.now()),StudentCourse(student_id1,course_id3,score60,timedatetime.now()),StudentCourse(student_id2,course_id1,score60,timedatetime.now()),StudentCourse(student_id2,course_id2,score60,timedatetime.now()),StudentCourse(student_id3,course_id3,score60,timedatetime.now()),StudentCourse(student_id3,course_id4,score60,timedatetime.now()),StudentCourse(student_id4,course_id5,score60,timedatetime.now()),StudentCourse(student_id4,course_id1,score60,timedatetime.now()),StudentCourse(student_id4,course_id2,score60,timedatetime.now()),StudentCourse(student_id5,course_id1,score60,timedatetime.now()),StudentCourse(student_id5,course_id2,score60,timedatetime.now()),StudentCourse(student_id5,course_id3,score60,timedatetime.now()),StudentCourse(student_id5,course_id4,score60,timedatetime.now()),]db.session.add_all(data)db.session.commit()return okapp.route(/q1)
def q1():# 使用逻辑外键来查询数据# 主模型.query.join(从模型类名, 关系语句)# 主模型.query.join(从模型类名, 主模型.主键从模型类名.外键)# 课程[python基础第3季]有多少学生在读# 分2步查询course Course.query.filter(Course.name python基础第3季).first()num StudentCourse.query.filter(StudentCourse.course_id course.id).count()print(course, num)# 关联查询, 2表关联# data Course.query.join(# StudentCourse,# Course.idStudentCourse.course_id# ).with_entities(# Course.id, Course.name, Course.price, StudentCourse.student_id, StudentCourse.score# ).filter(Course.name python基础第3季).all()# print(data)# 直接统计不需要任何字段ret Course.query.join(StudentCourse,Course.idStudentCourse.course_id).filter(Course.name python基础第3季).count()print(ret)return okapp.route(/q2)
def q2():# 查询课程[python基础第3季]有哪些学生在读3表关联# 正向查询和逆向查询都是通过声明临时外键关系来完成关联查询操作。student_list Course.query.join(StudentCourse,Course.id StudentCourse.course_id).join(Student,Student.id StudentCourse.student_id).with_entities(Course.name.label(course_name), StudentCourse.score.label(score), Student.name.label(student_name),).filter(Course.name python基础第3季).all()print(student_list)return okapp.route(/q3)
def q3():# xiaoming-2 购买了那些课程course_list Student.query.join(StudentCourse,Student.id StudentCourse.student_id).join(Course,Course.id StudentCourse.course_id).with_entities(Course.name.label(course_name),StudentCourse.score.label(score)).filter(Student.name xiaoming-2).all()print(course_list)return okif __name__ __main__:app.run()
例2虚拟外键使用的方案2代码
import json
from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from sqlalchemy.orm import backref
from datetime import datetimedb SQLAlchemy()
app Flask(__name__, template_foldertemplates, static_folderstatic)# 配置
app.config.update({DEBUG: True,SQLALCHEMY_DATABASE_URI: mysql://root:123127.0.0.1:3306/flaskdemo?charsetutf8mb4,# 如果使用pymysql则需要在连接时指定pymysql# SQLALCHEMY_DATABASE_URI: mysqlpymysql://root:123127.0.0.1:3306/flaskdemo?charsetutf8mb4# 动态追踪修改设置如未设置只会提示警告设置False即可SQLALCHEMY_TRACK_MODIFICATIONS: False,# ORM执行SQL查询时是哦否显示原始SQL语句debug模式下可以开启SQLALCHEMY_ECHO: True,
})db.init_app(app)class Student(db.Model):学生信息模型# 声明与当前模型绑定的数据表名称__tablename__ ts_studentid db.Column(db.Integer, primary_keyTrue,comment主键)name db.Column(db.String(15), comment姓名)age db.Column(db.SmallInteger, comment年龄)sex db.Column(db.Boolean, defaultTrue, comment性别)email db.Column(db.String(128), comment邮箱地址)money db.Column(db.Numeric(10,2), default0.0, comment钱包)def __repr__(self):return f{self.name}Studentclass Course(db.Model):课程数据模型__tablename__ ts_courseid db.Column(db.Integer, primary_keyTrue, comment主键)name db.Column(db.String(64), uniqueTrue, comment课程)price db.Column(db.Numeric(7, 2))def __repr__(self):return f{self.name}{self.__class__.__name__}class StudentCourse(db.Model):学生和课程之间的关系模型__tablename__ ts_student_courseid db.Column(db.Integer, primary_keyTrue, comment主键)student_id db.Column(db.Integer, indexTrue)course_id db.Column(db.Integer, indexTrue)score db.Column(db.Numeric(4,1), default0, comment成绩)time db.Column(db.DateTime, defaultdatetime.now, comment考试时间)student db.relationship(Student,uselistFalse,backrefbackref(to_course, uselistTrue),lazysubquery,primaryjoinStudent.idStudentCourse.student_id,foreign_keysStudentCourse.student_id)course db.relationship(Course,uselistFalse,backrefbackref(to_student, uselistTrue),lazysubquery,primaryjoinCourse.idStudentCourse.course_id,foreign_keysStudentCourse.course_id)app.route(/create)
def create_table():db.create_all() # 为项目中被识别的所有模型创建数据表return okapp.route(/drop)
def drop_table():db.drop_all() # 为项目中被识别的所有模型删除数据表return okapp.route(/)
def index():return okapp.route(/a1)
def a1():# 添加测试数据stu0 Student(namexiaoming-0,age15,sexTrue,emailxiaoming0qq.com, money1000)stu1 Student(namexiaoming-1,age15,sexTrue,emailxiaoming1qq.com, money1000)stu2 Student(namexiaoming-2,age15,sexTrue,emailxiaoming2qq.com, money1000)stu3 Student(namexiaoming-3,age15,sexTrue,emailxiaoming3qq.com, money1000)stu4 Student(namexiaoming-4,age15,sexTrue,emailxiaoming4qq.com, money1000)db.session.add_all([stu0,stu1,stu2,stu3,stu4])course1 Course(namepython基础第1季, price1000)course2 Course(namepython基础第2季, price1000)course3 Course(namepython基础第3季, price1000)course4 Course(namepython基础第4季, price1000)course5 Course(namepython基础第5季, price1000)db.session.add_all([course1, course2, course3, course4, course5])data [StudentCourse(student_id1,course_id1,score60,timedatetime.now()),StudentCourse(student_id1,course_id2,score60,timedatetime.now()),StudentCourse(student_id1,course_id3,score60,timedatetime.now()),StudentCourse(student_id2,course_id1,score60,timedatetime.now()),StudentCourse(student_id2,course_id2,score60,timedatetime.now()),StudentCourse(student_id3,course_id3,score60,timedatetime.now()),StudentCourse(student_id3,course_id4,score60,timedatetime.now()),StudentCourse(student_id4,course_id5,score60,timedatetime.now()),StudentCourse(student_id4,course_id1,score60,timedatetime.now()),StudentCourse(student_id4,course_id2,score60,timedatetime.now()),StudentCourse(student_id5,course_id1,score60,timedatetime.now()),StudentCourse(student_id5,course_id2,score60,timedatetime.now()),StudentCourse(student_id5,course_id3,score60,timedatetime.now()),StudentCourse(student_id5,course_id4,score60,timedatetime.now()),]db.session.add_all(data)db.session.commit()return okapp.route(/q1)
def q1():student Student.query.filter(Student.name xiaoming-0).first()# print(student.to_course)# [StudentCourse 1, StudentCourse 2, StudentCourse 3]print([{course_name: item.course.name,score: item.score,student_name: item.student.name,} for item in student.to_course])return okif __name__ __main__:app.run()数据迁移
在开发过程中需要修改数据库模型而且还要在修改之后更新数据库。最直接的方式就是删除旧表但这样会丢失数据所以往往更常见的方式就是使用alter来改变数据结构原有数据中的新字段值设置默认值或nullTrue.更好的解决办法是使用数据迁移它可以追踪数据库表结构的变化然后把变动应用到数据库中。在Flask中可以使用Flask-Migrate的第三方扩展来实现数据迁移。并且集成到Flask终端脚本中所有操作通过flask db 命令就能完成。为了导出数据库迁移命令Flask-Migrate提供了一个MigrateCommand类可以附加到flask框架中。
首先要在虚拟环境中安装Flask-Migrate。
pip install Flask-Migrate官网地址https://flask-migrate.readthedocs.io/en/latest/
代码文件内容
from flask import Flask
from flask_sqlalchemy import SQLAlchemy
# 导入数据迁移核心类
from flask_migrate import Migrateapp Flask(__name__)class Config(object):DEBUG True# 数据库连接配置# SQLALCHEMY_DATABASE_URI 数据库类型://数据库账号:密码数据库地址:端口/数据库名称?charsetutf8mb4SQLALCHEMY_DATABASE_URI mysql://root:123127.0.0.1:3306/flaskdemo?charsetutf8mb4# 动态追踪修改设置如未设置只会提示警告SQLALCHEMY_TRACK_MODIFICATIONS True# 查询时会显示原始SQL语句SQLALCHEMY_ECHO Trueapp.config.from_object(Config)db SQLAlchemy(appapp)# 初始化数据迁移
migrate Migrate(app, db)# migrate Migrate()
# migrate.init_app(app, db)模型类定义
# 关系表的声明方式
achieve db.Table(tb_achievement,db.Column(student_id, db.Integer, db.ForeignKey(tb_student.id)),db.Column(course_id, db.Integer, db.ForeignKey(tb_course.id))
)class Course(db.Model):# 定义表名__tablename__ tb_course# 定义字段对象id db.Column(db.Integer, primary_keyTrue)name db.Column(db.String(64), uniqueTrue)price db.Column(db.Numeric(6,2))teacher_id db.Column(db.Integer, db.ForeignKey(tb_teacher.id))students db.relationship(Student, secondaryachieve, backrefcourses, lazysubquery)# repr()方法类似于django的__str__用于打印模型对象时显示的字符串信息def __repr__(self):return Course:%s% self.nameclass Student(db.Model):__tablename__ tb_studentid db.Column(db.Integer, primary_keyTrue)name db.Column(db.String(64), uniqueTrue)email db.Column(db.String(64),uniqueTrue)age db.Column(db.SmallInteger,nullableFalse)sex db.Column(db.Boolean,default1)def __repr__(self):return Student:%s % self.nameclass Teacher(db.Model):__tablename__ tb_teacherid db.Column(db.Integer, primary_keyTrue)name db.Column(db.String(64), uniqueTrue)# 课程与老师之间的多对一关联courses db.relationship(Course, backrefteacher, lazysubquery)def __repr__(self):return Teacher:%s % self.nameapp.route(/)
def index():return okif __name__ __main__:app.run(debugTrue)创建迁移版本仓库
# 切换到项目根目录下
cd ~/Desktop/flaskdemo
# 设置flask项目的启动脚本位置例如我们现在的脚本叫manage.py
export FLASK_APPmanage.py
# 数据库迁移初始化这个命令会在当前项目根目录下创建migrations文件夹将来所有数据表相关的迁移文件都放在里面。
flask db init创建迁移版本
自动创建迁移版本文件中有两个函数用于进行数据迁移同步到数据库操作的。 upgrade()把迁移中的改动代码同步到数据库中。downgrade()则将改动代码从数据库中进行还原。 自动创建的迁移脚本会根据模型定义和数据库当前状态的差异生成upgrade()和downgrade()函数的内容。生成的迁移文件不一定完全正确有可能代码中存在细节遗漏导致报错需要开发者进行检查特别在多对多的时候
# 根据flask项目的模型生成迁移文件 -m的后面你不要使用中文
flask db migrate -m initial migration
# 这里等同于django里面的 makemigrations生成迁移版本文件
# 完成2件事情
# 1. 在migrations/versions生成一个数据库迁移文件
# 2. 如果是首次生成迁移文件的项目则迁移工具还会在数据库创建一个记录数据库版本的version表升级版本库的版本
把当前ORM模型中的代码改动同步到数据库。
# 从migations目录下的versions中根据迁移文件upgrade方法把数据表的结构同步到数据库中。
flask db upgrade降级版本库的版本
# 从migations目录下的versions中根据迁移文件downgrade把数据表的结构同步到数据库中。
flask db downgrade版本库的历史管理
可以根据history命令找到版本号,然后传给downgrade命令:
flask db history输出格式base - 版本号 (head), initial migration回滚到指定版本
flask db downgrade # 默认返回上一个版本
flask db downgrade 版本号 # 回滚到指定版本号对应的版本
flask db upgrade 版本号 # 升级到指定版本号对应的版本数据迁移的步骤
1. 初始化数据迁移的目录
export FLASK_APP4-manage.py
flask db init2. 数据库的数据迁移版本初始化生成迁移文件
flask db migrate -m initial migration3. 升级版本[新增一个迁移记录]
flask db upgrade 4. 降级版本[回滚一个迁移记录]
flask db downgrade常用模块
Faker
文档: https://faker.readthedocs.io/en/master/locales/zh_CN.html
批量生成测试数据: https://github.com/joke2k/faker
pip install faker -i https://pypi.douban.com/simple代码
from flask import Flask
from flask_sqlalchemy import SQLAlchemyapp Flask(__name__)class Config(object):DEBUG True# 数据库连接配置# SQLALCHEMY_DATABASE_URI 数据库类型://数据库账号:密码数据库地址:端口/数据库名称?charsetutf8mb4SQLALCHEMY_DATABASE_URI mysql://root:123127.0.0.1:3306/flaskdemo?charsetutf8mb4# 动态追踪修改设置如未设置只会提示警告SQLALCHEMY_TRACK_MODIFICATIONS False# 查询时会显示原始SQL语句SQLALCHEMY_ECHO Falseapp.config.from_object(Config)db SQLAlchemy(appapp)class Student(db.Model):学生信息模型__tablename__ db_studentid db.Column(db.Integer, primary_keyTrue,comment主键)name db.Column(db.String(15), comment姓名)age db.Column(db.SmallInteger, comment年龄)sex db.Column(db.Boolean, defaultTrue, comment性别)email db.Column(db.String(128), comment邮箱地址)money db.Column(db.Numeric(10,2), default0.0, comment钱包)def __repr__(self):return f{self.name}Student# 自定义批量生成学生
import random,click
from faker import Faker
# 自定义终端命令
app.cli.command(faker_user) # 指定终端命令的调用名称
click.argument(num, default5, typeint) # 命令的选项
def faker_user_command(num):生成测试学生信息faker Faker(localeZH_CN)for i in range(num):sex bool( random.randint(0,1) )student Student(name faker.name_male() if sex else faker.name_female(),agerandom.randint(15,60),sexsex,emailfaker.free_email(),money float( random.randint(100,100000) / 100 ),)db.session.add(student)# 在循环外面统一提交db.session.commit()app.route(/)
def index():return okif __name__ __main__:with app.app_context():db.create_all()app.run()
export FLASK_APPmanage.py
flask faker-user 10flask-session
flask-session允许设置session到指定的存储空间中例如redis/mongoDB/mysql。
文档: https://flask-session.readthedocs.io/en/latest/
pip install Flask-Session使用session之前,必须配置一下配置项:
# session秘钥
app.config[SECRET_KEY] *(%#4sxcz(^(#$#8423SQLAlchemy存储session的基本配置
需要手动创建session表在项目第一次启动的时候使用db.create_all()来完成创建。
from flask import Flask
from flask_sqlalchemy import SQLAlchemy
# 引入session存储驱动类
from flask_session import Session
# 引入sessio操作类注意引入路径不同大小写不同的。
from flask import sessionapp Flask(__name__, template_foldertemplates, static_folderstatic)db SQLAlchemy()# 实例化session存储类
session_store Session()# 配置
app.config.update({DEBUG: True,# 使用session之前,必须配置一下秘钥SECRET_KEY: *(%#4sxcz(^(#$#8423,# 要把存储到SQLAlchemy必须配置数据库连接# SQLALCHEMY_DATABASE_URI: 数据库类型://数据库账号:密码数据库地址:端口/数据库名称?charsetutf8mb4SQLALCHEMY_DATABASE_URI: mysql://root:123127.0.0.1:3306/flaskdemo?charsetutf8mb4,# 动态追踪修改设置如未设置只会提示警告SQLALCHEMY_TRACK_MODIFICATIONS: False,# 查询时会显示原始SQL语句SQLALCHEMY_ECHO: False,# 把session通过SQLAlchmey保存到mysql中SESSION_TYPE: sqlalchemy, # session类型为sqlalchemySESSION_SQLALCHEMY: db, # SQLAlchemy的数据库连接对象SESSION_SQLALCHEMY_TABLE: db_session, # session要保存的表名称SESSION_PERMANENT: True, # 如果设置为True则关闭浏览器session就失效SESSION_USE_SIGNER: True, # 是否对发送到浏览器上session的cookie值进行添加签名防止串改。SESSION_KEY_PREFIX: session: # session数据表中sessionID的前缀默认就是 session:
})db.init_app(app)# 务必保证在数据库配置初始化以后才进行session存储类的初始化
session_store.init_app(app)# 如果要把session保存到数据库中则必须先执行db.create_all() 让数据库提前创建session表。否则使用session时报错。
app.route(/create)
def create_table():db.create_all() # 为项目中被识别的所有模型创建数据表return okapp.route(/drop)
def drop_table():db.drop_all() # 为项目中被识别的所有模型删除数据表return okapp.route(/)
def index():return okapp.route(/set)
def set_session():session[uname] xiaomingsession[age] 18return okapp.route(/get)
def get_session():print(session.get(uname))print(session.get(age))return okapp.route(/del)
def del_session():# 此处的删除不是删除用户对应的session表记录而是删除session值而已。print(session.pop(uname))print(session.pop(age))return okif __name__ __main__:app.run()
redis保存session的基本配置
这个功能必须确保服务器必须已经安装了redis而且当前项目虚拟环境中已经安装了redis扩展库
pip install flask-redis -i https://pypi.douban.com/simpleflask-redis是第三方开发者为了方便我们在flask框架中集成redis数据库操作所封装一个redis操作库、
在flask中要基于flask-redis进行数据库则可以完成以下3个步骤即可
from flask import Flask
from flask_redis import FlaskRedis# 实例化
app Flask(__name__)
session_redis FlaskRedis(config_prefixSESSION)
user_redis FlaskRedis(config_prefixUSER)
order_redis FlaskRedis(config_prefixORDER)# 初始化 flask_redis
session_redis.init_app(app)
user_redis.init_app(app)
order_redis.init_app(app)app.route(/)
def q2():user_redis.setnx(doing, 100)return okif __name__ __main__:app.run(host0.0.0.0, port5000, debugTrue)在redis中保存session代码
from flask import Flask
from flask_redis import FlaskRedis
from flask_session import Session
from flask import sessionapp Flask(__name__, template_foldertemplates, static_folderstatic)redis0 FlaskRedis(config_prefixREDIS)
redis1 FlaskRedis(config_prefixSESSION_REDIS)
session_store Session()
# 配置
app.config.update({DEBUG: True,# 使用session之前,必须配置一下秘钥SECRET_KEY: *(%#4sxcz(^(#$#8423,REDIS_URL: redis://:123456127.0.0.1:6379/0,SESSION_REDIS_URL: redis://:123456127.0.0.1:6379/1,# 把session保存到redis中SESSION_TYPE: redis, # session类型为sqlalchemySESSION_PERMANENT: True, # 如果设置为True则关闭浏览器session就失效SESSION_USE_SIGNER: True, # 是否对发送到浏览器上session的cookie值进行添加签名防止串改。SESSION_KEY_PREFIX: session:, # session数据表中sessionID的前缀默认就是 session:# session保存数据到redis时启用的链接对象SESSION_REDIS: redis1, # 用于连接redis的配置
})redis0.init_app(app)
redis1.init_app(app)# 务必保证session存储类初始化之前redis已经完成初始化了。
session_store.init_app(app)app.route(/)
def index():return okapp.route(/set)
def set_session():session[uname] xiaomingsession[age] 18return okapp.route(/get)
def get_session():print(session.get(uname))print(session.get(age))return okapp.route(/del)
def del_session():# 此处的删除是直接删除保存在redis中的数据当所有session被删除则key也会消失了。print(session.pop(uname))print(session.pop(age))return okif __name__ __main__:app.run()蓝图 Blueprint
模块化
随着flask程序越来越复杂,我们需要对程序进行模块化的处理,之前学习过django的子应用管理,flask程序进行可以进行类似的模块化处理保存代码。
简单来说Blueprint 是一个存储视图方法/模型代码的容器目录这些操作在这个Blueprint 被注册到flask的APP实例对象应用之后就可以被调用Flask 可以通过Blueprint来组织URL以及处理客户端请求的视图。
Flask使用Blueprint让应用实现模块化在Flask中Blueprint具有如下属性
一个项目可以具有多个Blueprint可以将一个Blueprint注册到任何一个未使用的URL下比如 “/”、“/sample”或者子域名也就是说每一个蓝图都可以像django那样有属于自己的路由前缀在一个flask项目中同一个BluePrint模块可以注册多次也就是说一个蓝图可以对应多个不同的url地址。Blueprint目录可以保存单独属于自己的模板目录保存自己的模板文件、静态文件或者其它的通用操作方法它并不是必须要实现应用的视图和函数的在一个flask项目初始化时就应该要注册需要使用的Blueprint否则项目不识别Blueprint蓝图
注意flask中的Blueprint并不是一个完整的项目应用它不能独立运行而必须要把蓝图blueprint注册到某一个flask项目中才能使用。
在flask中要使用蓝图Blueprint可以分为四个步骤
手动创建一个蓝图的包目录,例如users,并在__init__.py文件中创建蓝图实例对象users_blueprint
from flask import Blueprint# 等同于 app Flask(__name__)只是这里并非一个独立的flask项目所以需要在第一个参数中指定蓝图名称其他参数与之前实例化app应用对象是一样的。
users_blueprint Blueprint(users, __name__)
# users_blueprint Blueprint(users,__name__,static_folderusers_static)在这个users蓝图目录下创建蓝图的子文件, 其中我们可以创建views.py文件,保存当前蓝图使用的视图函数
# 光写视图不用写路由
def login():return 用户登录视图def register():return 用户注册视图在users/__init__.py中引入views.py中所有的视图函数并绑定路由
from flask import Blueprint
from . import views# 等同于 app Flask(__name__)只是这里并非一个独立的flask项目所以需要在第一个参数中指定蓝图名称其他参数与之前实例化app应用对象是一样的。
users_blueprint Blueprint(users, __name__)
# users_blueprint Blueprint(users,__name__,static_folderusers_static)# 给蓝图注册视图与绑定视图的路由路由必须以/斜杠开头
users_blueprint.add_url_rule(/login, view_funcviews.login)
users_blueprint.add_url_rule(/reg, view_funcviews.register)# 子路由
print(users_blueprint.deferred_functions)在主应用下程序入口manage.py文件中把这个users_blueprint蓝图对象注册app实例对象中运行起来。
from flask import Flask
from users import users_blueprintapp Flask(__name__, template_foldertemplates, static_folderstatic)# 配置
app.config.update({DEBUG: True,
})app.route(/)
def index():return 我是okapp.register_blueprint(users_blueprint, url_prefix/users)if __name__ __main__:# 总路由print(app.url_map)app.run()
当这个应用启动后,通过/users/可以访问到蓝图中定义的视图函数
蓝图运行机制
蓝图Blueprint实际上的作用就是充当当前蓝图目录下的所有视图和url路由地址的绑定关系的临时容器在视图函数被蓝图的add_url_rule方法注册时,这个操作本质就是将视图和url地址的映射关系添加到蓝图的子路由列表deferred_functions中。蓝图对象根本没有路由表当我们在蓝图中的视图函数上调用route装饰器或者add_url_role函数注册路由时,它只是在蓝图对象的内部的deferred_functions子路由列表中添加了一个路由项路由项实际上就是一个绑定了视图和url地址的lambda匿名函数当执行app.register_blueprint()注册蓝图时app应用实例对象会将从蓝图对象的 deferred_functions列表中循环取出每一个之前注册的路由项并把app应用实例对象自己作为参数执行路由项对应的lambda匿名函数lambda匿名函数执行以后就会调用app.add_url_rule() 方法这就将蓝图下子路由列表之前暂存的路由全部添加到了app应用实例对象的url_map总路由表中了所以用户就可以在flask中访问到了蓝图中的视图。当然能访问蓝图下的视图自然也就可以通过视图调用其他的功能例如蓝图下的其他功能函数或其他的模型对象了。
蓝图的url拼接
当我们在app应用实例对象上注册一个蓝图时可以指定一个url_prefix关键字参数这个参数默认是/ 在app应用实例对象的最终的路由表 url_map中在蓝图上注册的路由URL自动被加上了这个路由前缀这个可以保证在多个蓝图中使用相同的子路由而不会最终引起冲突只要在注册蓝图时将不同的蓝图挂接到不同的自路径即可。
注意有了蓝图以后在flask使用url_for在使用时如果要生成一个蓝图里面的视图对应的路由地址则需要声明当前蓝图名称视图名称
# url_for(蓝图名称.视图函数名)
url_for(users.login) # /users /login /users就是蓝图中的路由前缀 /login就是子路由users/views.py代码
from flask import url_fordef login():return 用户登录视图def register():print(url_for(users.login))return 用户注册视图
访问 注册蓝图下的静态文件[很少使用]
和app应用对象不同蓝图对象创建时不会默认注册静态目录的路由。需要我们在创建时手动指定 static_folder 参数。
下面的代码将蓝图所在目录下的static_users目录设置为静态目录
users/__init__.py,代码
from flask import Blueprint
from . import views# 等同于 app Flask(__name__)只是这里并非一个独立的flask项目所以需要在第一个参数中指定蓝图名称其他参数与之前实例化app应用对象是一样的。
users_blueprint Blueprint(users, __name__, static_folderstatic)
# users_blueprint Blueprint(users,__name__,static_folderusers_static)# 给蓝图注册视图与绑定视图的路由路由必须以/斜杠开头
users_blueprint.add_url_rule(/login, view_funcviews.login)
users_blueprint.add_url_rule(/reg, view_funcviews.register)# 子路由
print(users_blueprint.deferred_functions)现在就可以使用http://127.0.0.1:5000/users/static/images/avatar.jpg 访问users/static/目录下的静态文件了.
当然也可以修改访问静态文件的路径 可以在创建蓝图对象时使用 static_url_path 来改变静态目录的url地址。
from flask import Blueprint
from . import views# 等同于 app Flask(__name__)只是这里并非一个独立的flask项目所以需要在第一个参数中指定蓝图名称其他参数与之前实例化app应用对象是一样的。
users_blueprint Blueprint(users, __name__, static_folderstatic, static_url_path/assets)
# users_blueprint Blueprint(users,__name__,static_folderusers_static)# 给蓝图注册视图与绑定视图的路由路由必须以/斜杠开头
users_blueprint.add_url_rule(/login, view_funcviews.login)
users_blueprint.add_url_rule(/reg, view_funcviews.register)# 子路由
print(users_blueprint.deferred_functions)现在就可以使用http://127.0.0.1:5000/users/static/assets/avatar.jpg访问users/static/目录下的静态文件了. 设置蓝图下的html模版[很少使用]
创建蓝图中的模板目录templatesusers/__init__.py代码
from flask import Blueprint
from . import views# 等同于 app Flask(__name__)只是这里并非一个独立的flask项目所以需要在第一个参数中指定蓝图名称其他参数与之前实例化app应用对象是一样的。
users_blueprint Blueprint(users, __name__, static_folderstatic, static_url_path/assets, template_foldertemplates)
# users_blueprint Blueprint(users,__name__,static_folderusers_static)# 给蓝图注册视图与绑定视图的路由路由必须以/斜杠开头
users_blueprint.add_url_rule(/login, view_funcviews.login)
users_blueprint.add_url_rule(/reg, view_funcviews.register)# 子路由
print(users_blueprint.deferred_functions)视图users/views.py代码
from flask import url_for
from flask import render_templatedef login():title 用户登录视图return render_template(login.html, **locals())def register():print(url_for(users.login))return 用户注册视图模板代码users/templates/index.html代码
!DOCTYPE html
html langen
headmeta charsetUTF-8titleTitle/title
/head
bodyh1{{ title }}/h1
/body
/html注意如果公司使用了flask1.x版本则不能出现项目根目录下和蓝图目录下2个templates目录的情况否则项目根目录下的templates模板会覆盖蓝图目录下的同名模板flask会优先加载项目根目录下的模板。 若有错误与不足请指出关注DPT一起进步吧
