基本查询
SQLAlchemy常用的查询过滤器
过滤器 | 说明 |
---|---|
filter() | 把过滤器添加到原查询上,返回一个新查询 |
filter_by() | 把等值过滤器添加到原查询上,返回一个新查询 |
limit() | 使用指定的值限定原查询返回的结果数量 |
offset() | 设置结果范围的开始位置,偏移原查询返回的结果,返回一个新查询 |
order_by() | 根据指定条件对原查询结果进行排序,返回一个新查询 |
group_by() | 根据指定条件对原查询结果进行分组,返回一个新查询 |
SQLAlchemy常用的查询结果方法
方法 | 说明 |
---|---|
all() | 以列表形式返回查询的所有结果 |
first() | 返回查询的第一个结果,模型对象,如果未查到,返回None |
first_or_404() | 返回查询的第一个结果,模型对象,如果未查到,通过abort 返回404异常 |
get() | 返回指定主键对应的模型对象,如不存在,返回None |
get_or_404() | 返回指定主键对应的行,如不存在,abort 返回404 |
count() | 返回查询结果的数量 |
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 "ok"
@app.route("/create")
def create_table():
db.create_all() # 为项目中被识别的所有模型创建数据表
return "ok"
@app.route("/drop")
def drop_table():
db.drop_all() # 为项目中被识别的所有模型删除数据表
return "ok"
@app.route("/query")
def query():
query1 = Student.query # 简写操作
query2 = db.session.query(Student)
print(type(query1), query1)
print(type(query2), query2)
return "ok"
@app.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)
# 查询不到结果,则返回值为None
if student1:
print(student1.name, student1.age)
if student2:
print(student2.name, student2.age)
return "ok"
if __name__ == '__main__':
app.run()
all()返回查询到的所有对象
模型类.query.all()
"""获取多个数据"""
student = Student.query.all()
print(student) # [dong<Student>, 小红<Student>, wang<Student>, chen<Student>, zhou<Student>, tang<Student>, wu<Student>, qian<Student>, liu<Student>, li<Student>, sun<Student>]
student = Student.query.filter(Student.id<5).all() # 没有结果返回空列表[]
print(student) # [dong<Student>, 小红<Student>, wang<Student>]
# all()的返回值是一个python列表,可以直接使用切片,与django的QuerySet完全不是一回事。
student = Student.query.filter(Student.id < 5).all()[:-1] # 没有结果返回空列表[]
print(student) # [dong<Student>, 小红<Student>]
count 返回结果的数量
# 返回结果的数量
ret = Student.query.filter(Student.id < 5).count()
print(f"ret={ret}")
first()返回查询到的第一个对象【first获取一条数据,all获取多条数据】
模型类.query.first()
"""获取第一个数据"""
student = Student.query.first()
print(student)
student = Student.query.filter(Student.id==5).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) # [wang<Student>, chen<Student>, zhou<Student>,...]
"""多条件比较"""
# 要求多个条件都要满足,相当于逻辑查询中的 并且(and)!!
student_list = Student.query.filter(Student.age > 18, Student.sex == True).all()
print(student_list) # [wang<Student>, chen<Student>, qian<Student>, liu<Student>]
filter_by精确条件查询
filter_by 只支持字段的值是否相等的情况,对于大于、等于、等等其他条件是不支持的。
例如:返回age等于22的学生
# 单条件
student_list = Student.query.filter_by(age=22).all() # 字段添加不需要附带模型类
print(student_list)
# 多条件
student_list = Student.query.filter_by(age=22,sex=True).all()
print(student_list)
练习:
查询所有男生[Student.sex==True]数据
查询id为4的学生[3种方式]
查询年龄等于22的所有学生数据
查询name为小白的学生数据
查询20岁的男生
代码:
from flask import Flask, render_template
from flask_sqlalchemy import SQLAlchemy
db = SQLAlchemy()
app = Flask(__name__, template_folder="templates", static_folder="static")
# 配置
app.config.update({
"DEBUG": True,
"SQLALCHEMY_DATABASE_URI": "mysql://root:123@127.0.0.1:3306/flaskdemo?charset=utf8mb4",
# 如果使用pymysql,则需要在连接时指定pymysql
# "SQLALCHEMY_DATABASE_URI": "mysql+pymysql://root:123@127.0.0.1:3306/flaskdemo?charset=utf8mb4"
# 动态追踪修改设置,如未设置只会提示警告,设置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_key=True, comment="主键")
name = db.Column(db.String(15), index=True, comment="姓名")
age = db.Column(db.SmallInteger, comment="年龄")
sex = db.Column(db.SmallInteger, comment="性别")
email = db.Column(db.String(255), unique=True, comment="邮箱地址")
money = db.Column(db.Numeric(10,2), default=0.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_key=True, comment="主键")
name = db.Column(db.String(64), unique=True, 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_key=True, comment="主键")
name = db.Column(db.String(64), unique=True, comment="姓名")
option = db.Column(db.Enum("讲师", "助教", "班主任"), default="讲师")
def __repr__(self):
return f"{self.name}<{self.__class__.__name__}>"
@app.route("/")
def index():
return "ok"
@app.route("/create")
def create_table():
db.create_all() # 为项目中被识别的所有模型创建数据表
return "ok"
@app.route("/drop")
def drop_table():
db.drop_all() # 为项目中被识别的所有模型删除数据表
return "ok"
@app.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. filter+first
# student = Student.query.filter(Student.id == 4).first()
# print(student)
# 3. filter_by + first
# student = Student.query.filter_by(id=4).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 "ok"
if __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.age==22)).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统计
# 查询age>=19的男生的数量
from sqlalchemy import and_
# ret = Student.query.filter( and_(Student.age>=19,Student.sex==True) ).count()
ret = Student.query.filter( Student.age>=19, Student.sex==True ).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.age==18,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 SQLAlchemy
app = Flask(__name__)
class Config(object):
DEBUG = True
# 数据库链接配置 = 数据库名称://登录账号:登录密码@数据库主机IP:数据库访问端口/数据库名称?charset=编码类型
SQLALCHEMY_DATABASE_URI = "mysql://root:123@127.0.0.1:3306/flaskdemo?charset=utf8mb4"
# 动态追踪修改设置,如未设置只会提示警告
SQLALCHEMY_TRACK_MODIFICATIONS = False
# ORM运行时会显示ORM生成的原始SQL语句[调试]
SQLALCHEMY_ECHO = True
app.config.from_object(Config)
"""模型类定义"""
db = SQLAlchemy(app=app)
class Student(db.Model):
"""学生信息模型"""
# 声明与当前模型绑定的数据表名称
__tablename__ = "db_student"
id = db.Column(db.Integer, primary_key=True,comment="主键")
name = db.Column(db.String(15), index=True, comment="姓名")
age = db.Column(db.SmallInteger, comment="年龄")
sex = db.Column(db.Boolean, default=True, comment="性别")
email = db.Column(db.String(128), unique=True, comment="邮箱地址")
money = db.Column(db.Numeric(10,2), default=0.0, comment="钱包")
def __repr__(self): # 相当于django的__str__
return f"{self.name}<{self.__class__.__name__}>"
# 所有的模型必须直接或间接继承于db.Model
class Course(db.Model):
"""课程数据模型"""
__tablename__ = "db_course"
id = db.Column(db.Integer, primary_key=True, comment="主键")
name = db.Column(db.String(64), unique=True, 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_teacher"
id = db.Column(db.Integer, primary_key=True, comment="主键")
name = db.Column(db.String(64), unique=True, comment="姓名")
option = db.Column(db.Enum("讲师", "助教", "班主任"), default="讲师")
def __repr__(self):
return f"{self.name}<{self.__class__.__name__}>"
from flask import request,render_template
@app.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 lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
<style>
.page a,.page span{
padding: 2px 6px;
color: #fff;
background: #6666ff;
text-decoration: none;
}
.page span{
color: #fff;
background: orange;
}
</style>
</head>
<body>
<table border="1" align="center" width="600">
<tr>
<th>ID</th>
<th>age</th>
<th>name</th>
<th>sex</th>
<th>money</th>
</tr>
{% for student in pagination.items %}
<tr>
<td>{{ student.id }}</td>
<td>{{ student.age }}</td>
<td>{{ student.name }}</td>
<td>{{ "男" if student.sex else "女" }}</td>
<td>{{ student.money }}</td>
</tr>
{% endfor %}
<tr align="center">
<td colspan="5" class="page">
{% if pagination.has_prev %}
<a href="?page=1">首 页</a>
<a href="?page={{ pagination.page-1 }}">上一页</a>
<a href="?page={{ pagination.page-1 }}">{{ pagination.page-1 }}</a>
{% endif %}
<span>{{ pagination.page }}</span>
{% if pagination.has_next %}
<a href="?page={{ pagination.page+1 }}">{{ pagination.page+1 }}</a>
<a href="?page={{ pagination.page+1 }}">下一页</a>
<a 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.sex==False).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 字段2
1 3
2 4
分组如下:
13
14
23
24
"""
# 各个年龄里,男生和女生的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 achievement
80
小明 17 81
83
group_concat 逗号合并
小明 17 80,81,83
concat 字符串拼接
小明 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(立即加载,查询所有相关数据显示,相当于lazy=True) subquery(立即加载,但使用子查询) dynamic(不立即加载,但提供加载记录的查询对象) |
uselist | 指定1对1或1对多连表时,返回的数据结果是模型对象还是模型列表,如果为False,不使用列表,而使用模型对象。 1对1或多对1关系中,需要设置relationship中的uselist=Flase,1对多或多对多关系中,需要设置relationshio中的uselist=True。 |
secondary | 指定多对多关系中关系表的名字。 多对多关系中,需建立关系表,设置 secondary=关系表 |
secondary join | 在SQLAlchemy中无法自行决定时,指定多对多关系中的二级连表条件,绑定主外键。 |
范式理论:一套提供给数据库开发者设置标准、规范的数据库的理论。
1NF. 数据不可再分,必须保证原子性。数据的值保证可以方便存储,不可再分。
2NF. 数据不能重复,必须保证唯一性。必须使用主键来进行区分每一行数据。
3NF. 数据不能冗余,必须保证关联性。冗余的数据必须使用另外的数据表存放,并与当前表进行关联。
基于实际业务的角度出发,设计出违背了范式理论的表结构。
逆范式:以空间换时间
class table:
id name teacher
1 301班 李老师
2 302班 王老师
student table:
id name class_id
1 xiaoming 1
2 xiaohong 2
3 xiaohui 3
三范式+逆范式
第三范式:数据不能冗余,把关联性不强的数据可以移除到另一个表中。使用外键进行管理。
1对1:把主表的主键放到附加表中作为外键存在。
商品信息表
id name price image 描述 售后 配置 包装
1 PC-1-gr 100 1.png
2 PC-1-re 100 1.png
3 PC-1-he 100 1.png
4 PC-1-bu 100 1.png
1对多:把主表(1) 的主键放到附加表(多)作为外键存在。
订单信息表 订单详情表
1个订单 ----> 多个商品
多对多:把主表(多)的主键和附加表的(多)主键,放到第三方表(关系表)中作为外键。
用户表 课程表
1 xiaoming 1 python
2 xiaohong 2 django
3 xiaolong 3 flask
用户与课程的购买关系表
user_id course
1 1
1 2
1 3
模型之间的关联
一对一
常见的业务:主表和详情表(用户、会员、学生、商品、文章、主机)
class Student(db.Model):
"""个人信息主表"""
....
# 关联属性,这个不会被视作表字段,只是模型对象的属性。
# 因为StudentInfo和Student是一对一的关系,所以uselist=False表示关联一个数据
info = db.relationship("StudentInfo", uselist=False, backref="own")
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 func
db = SQLAlchemy()
app = Flask(__name__, template_folder="templates", static_folder="static")
# 配置
app.config.update({
"DEBUG": True,
"SQLALCHEMY_DATABASE_URI": "mysql://root:123@127.0.0.1:3306/flaskdemo?charset=utf8mb4",
# 如果使用pymysql,则需要在连接时指定pymysql
# "SQLALCHEMY_DATABASE_URI": "mysql+pymysql://root:123@127.0.0.1:3306/flaskdemo?charset=utf8mb4"
# 动态追踪修改设置,如未设置只会提示警告,设置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_key=True, comment="主键")
name = db.Column(db.String(15), index=True, comment="姓名")
age = db.Column(db.SmallInteger, comment="年龄")
sex = db.Column(db.SmallInteger, comment="性别")
email = db.Column(db.String(255), unique=True, comment="邮箱地址")
money = db.Column(db.Numeric(10,2), default=0.0, comment="钱包")
# 模型的关联属性,不会在数据表创建字段
# 因为StudentInfo和Student是一对一的关系,所以uselist=False表示关联一个数据
info = db.relationship("StudentInfo", uselist=False, backref="student")
def __repr__(self):
return json.dumps(self.__to_dict__, ensure_ascii=False)
@property
def __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_key=True, comment="主键")
# 附加表的外键,就是主表的主键
# 如果是一对一,则外键放在附加表对应的模型中
# 如果是一对多,则外键放在多的附加表对应的模型中
sid = db.Column(db.Integer, db.ForeignKey("tb_student.id"), comment="外键") # mysql字段
# student = db.relationship("Student", uselist=False, backref="info") # ORM关联属性
mobile = db.Column(db.String(15), index=True, comment="手机号码")
address = db.Column(db.String(255), nullable=True, comment="家庭地址")
def __repr__(self):
return json.dumps(self.__to_dict__, ensure_ascii=False)
@property
def __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 "ok"
@app.route("/drop")
def drop_table():
db.drop_all() # 为项目中被识别的所有模型删除数据表
return "ok"
@app.route("/a1")
def a1():
"""添加操作"""
# 添加主表信息的时候通过关联属性db.relationship同步添加附件表信息
student = Student(
name="xiaolan01",
age=16,
sex=False,
money=10000,
email="xiaolan01@qq.com",
info=StudentInfo(
address="北京市昌平区百沙路203号",
mobile="13312345672"
)
)
db.session.add(student)
db.session.commit()
return "ok"
@app.route("/a2")
def a2():
"""添加操作"""
# 假设已经存在主表信息,后面再补充附加表信息
# student = Student(
# name="xiaolan03",
# age=16,
# sex=False,
# money=10000,
# email="xiaolan03@qq.com",
# )
#
# db.session.add(student)
# db.session.commit()
# 上面代码先执行了,现有1个学生没有附加信息的,我们可以在后续代码通过查询主表的主键,补充附加表数据
student = Student.query.get(3)
if not student.info:
"""添加附加表数据"""
"""方式1"""
# student.info = StudentInfo(mobile=13300010002, address="北京市昌平区百沙路205号",)
# db.session.commit()
"""方式2"""
# info = StudentInfo(
# student=student, # 关联属性
# mobile=13300010002,
# address="北京市昌平区百沙路205号",
# )
#
# db.session.add(info)
# db.session.commit()
"""方式3"""
info = StudentInfo(
sid=student.id, # 外键
mobile=13300010002,
address="北京市昌平区百沙路205号",
)
db.session.add(info)
db.session.commit()
return "ok"
@app.route("/a3")
def a3():
"""添加操作"""
# 添加附加模型数据的同时,把主模型也进行添加
info = StudentInfo(
mobile=13300010003,
address="北京市昌平区百沙路206号",
student=Student(
name="xiaolan04",
age=17,
sex=False,
money=10000,
email="xiaolan04@qq.com",
),
)
db.session.add(info)
db.session.commit()
return "ok"
@app.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": "xiaolan04@qq.com", "money": 10000.0}
print(student_info.student.name) # xiaolan04
print(student_info.sid) # 4
return "ok"
@app.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 = 23
db.session.commit()
return "ok"
@app.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 "ok"
if __name__ == '__main__':
app.run()
在外键模型中声明关联属性
代码:
import json
from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from sqlalchemy.orm import backref
db = SQLAlchemy()
app = Flask(__name__, template_folder="templates", static_folder="static")
# 配置
app.config.update({
"DEBUG": True,
"SQLALCHEMY_DATABASE_URI": "mysql://root:123@127.0.0.1:3306/flaskdemo?charset=utf8mb4",
# 如果使用pymysql,则需要在连接时指定pymysql
# "SQLALCHEMY_DATABASE_URI": "mysql+pymysql://root:123@127.0.0.1:3306/flaskdemo?charset=utf8mb4"
# 动态追踪修改设置,如未设置只会提示警告,设置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_key=True, comment="主键")
name = db.Column(db.String(15), index=True, comment="姓名")
age = db.Column(db.SmallInteger, comment="年龄")
sex = db.Column(db.SmallInteger, comment="性别")
email = db.Column(db.String(255), unique=True, comment="邮箱地址")
money = db.Column(db.Numeric(10, 2), default=0.0, comment="钱包")
def __repr__(self):
return json.dumps(self.__to_dict__, ensure_ascii=False)
@property
def __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_key=True, comment="主键")
# 附加表的外键,就是主表的主键
# 如果是一对一,则外键放在附加表对应的模型中
# 如果是一对多,则外键放在多的附加表对应的模型中
sid = db.Column(db.Integer, db.ForeignKey("tb_student.id"), comment="外键") # mysql字段
# 模型的关联属性,不会在数据表创建字段
# 因为StudentInfo和Student是一对一的关系,所以uselist=False表示关联一个数据
student = db.relationship("Student", uselist=False, backref=backref("info", uselist=False)) # ORM关联属性
mobile = db.Column(db.String(15), index=True, comment="手机号码")
address = db.Column(db.String(255), nullable=True, comment="家庭地址")
def __repr__(self):
return json.dumps(self.__to_dict__, ensure_ascii=False)
@property
def __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 "ok"
@app.route("/drop")
def drop_table():
db.drop_all() # 为项目中被识别的所有模型删除数据表
return "ok"
@app.route("/a1")
def a1():
"""添加操作"""
# 添加主表信息的时候通过关联属性db.relationship同步添加附件表信息
student = Student(
name="xiaolan01",
age=16,
sex=False,
money=10000,
email="xiaolan01@qq.com",
info=StudentInfo(
address="北京市昌平区百沙路203号",
mobile="13312345672"
)
)
db.session.add(student)
db.session.commit()
return "ok"
@app.route("/a2")
def a2():
"""添加操作"""
# 假设已经存在主表信息,后面再补充附加表信息
# student = Student(
# name="xiaolan03",
# age=16,
# sex=False,
# money=10000,
# email="xiaolan03@qq.com",
# )
#
# db.session.add(student)
# db.session.commit()
# 上面代码先执行了,现有1个学生没有附加信息的,我们可以在后续代码通过查询主表的主键,补充附加表数据
student = Student.query.get(2)
if student and not student.info:
"""添加附加表数据"""
"""方式1"""
# student.info = StudentInfo(mobile=13300010002, address="北京市昌平区百沙路205号",)
# db.session.commit()
"""方式2"""
# info = StudentInfo(
# student=student, # 关联属性
# mobile=13300010002,
# address="北京市昌平区百沙路205号",
# )
#
# db.session.add(info)
# db.session.commit()
"""方式3"""
info = StudentInfo(
sid=student.id, # 外键
mobile=13300010002,
address="北京市昌平区百沙路205号",
)
db.session.add(info)
db.session.commit()
return "ok"
@app.route("/a3")
def a3():
"""添加操作"""
# 添加附加模型数据的同时,把主模型也进行添加
info = StudentInfo(
mobile=13300010003,
address="北京市昌平区百沙路206号",
student=Student(
name="xiaolan04",
age=17,
sex=False,
money=10000,
email="xiaolan04@qq.com",
),
)
db.session.add(info)
db.session.commit()
return "ok"
@app.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": "xiaolan04@qq.com", "money": 10000.0}
print(student_info.student.name) # xiaolan04
print(student_info.sid) # 3
return "ok"
@app.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 "ok"
@app.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 "ok"
if __name__ == '__main__':
app.run()
一对多
常见业务:商品分类和商品、文章分类和文章、班级与学生、部门与员工、角色与会员、订单与订单详情、用户与收货地址。。。
class User(db.Model):
...
# 关联属性,一的一方添加模型关联属性
address_list = db.relationship("UserAddress", uselist=True, backref="user", lazy='dynamic')
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),把外键模型的属性也同时查询出来了。
- lazy=True或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 backref
db = SQLAlchemy()
app = Flask(__name__, template_folder="templates", static_folder="static")
# 配置
app.config.update({
"DEBUG": True,
"SQLALCHEMY_DATABASE_URI": "mysql://root:123@127.0.0.1:3306/flaskdemo?charset=utf8mb4",
# 如果使用pymysql,则需要在连接时指定pymysql
# "SQLALCHEMY_DATABASE_URI": "mysql+pymysql://root:123@127.0.0.1:3306/flaskdemo?charset=utf8mb4"
# 动态追踪修改设置,如未设置只会提示警告,设置False即可
"SQLALCHEMY_TRACK_MODIFICATIONS": False,
# ORM执行SQL查询时是哦否显示原始SQL语句,debug模式下可以开启
"SQLALCHEMY_ECHO": True,
})
db.init_app(app)
class User(db.Model):
__tablename__ = "tb_user"
id = db.Column(db.Integer, primary_key=True, comment="主键")
username = db.Column(db.String(50), unique=True, comment="用户名")
nickname = db.Column(db.String(50), index=True, comment="昵称")
sex = db.Column(db.Boolean, default=True, comment="性别")
money = db.Column(db.Numeric(8,2), default=0.0, comment="钱包余额")
address_list = db.relationship("UserAddress", uselist=True, backref="user", lazy="dynamic")
def __repr__(self):
return json.dumps(self.__to_dict__, ensure_ascii=False)
@property
def __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_address"
id = db.Column(db.Integer, primary_key=True, 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_ascii=False)
@property
def __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 "ok"
@app.route("/drop")
def drop_table():
db.drop_all() # 为项目中被识别的所有模型删除数据表
return "ok"
@app.route("/")
def index():
return "ok"
@app.route("/a1")
def a1():
"""添加数据"""
# # 添加主模型的同时也会给附加模型添加数据,这种情况,附加模型的值可以以列表形式进行添加,一次性添加多个附加模型数据进去。
# user = User(
# username="xiaolan001",
# nickname="xiaolan001",
# sex=False,
# money=10000,
# address_list=[
# UserAddress(name="公司", province="北京市", city="北京市", area="昌平区", address="百沙路201", mobile="13012345678"),
# UserAddress(name="门口小卖部", province="北京市", city="北京市", area="昌平区", address="百沙路202", mobile="13012345677"),
# UserAddress(name="小区门口", province="北京市", city="北京市", area="昌平区", address="百沙路203", mobile="13012345676"),
# ]
# )
# db.session.add(user)
# db.session.commit()
# 添加外键模型数据的同时,添加主模型数据
address = UserAddress(
province="天津市",
city="天津市",
area="静海区",
address="静安路1103号",
user=User(
username="xiaolan02",
nickname="xiaolan02",
money=10000,
sex=False,
)
)
db.session.add(address)
db.session.commit()
return "ok"
@app.route("/q1")
def q1():
# 正向关联----> 从主模型查询外键模型
student = User.query.filter(User.username == "xiaolan001").first()
# 观察连表SQL语句的执行
""" lazy="select" || lazy=True """
# print(student) # 没有查询附加表
# print(student.address_list) # 查询了附加表
""" lazy="subquery" """
# print(student) # 已经查询了附加表,如果没有使用到外键模型的数据,则本次查询存在资源浪费!!
""" lazy="dynamic" """
# print(student) # 没有查询附加表
# student.address_list # 没有查询附加模型的SQL语句
# print( student.address_list ) # 只要访问关联模型的具体字段才真正执行,如果海量数量查询,则本次查询会影响返回数据给客户端的时间
print( student.address_list[0] ) # 获取返回列表的第1个成员
return "ok"
if __name__ == '__main__':
app.run()
多对多
常见业务:用户收藏文章、用户与用户之间的好友关系、点赞、评论、关注、用户浏览商品的历史记录、订阅文章、专题与商品/文章的关系、活动与商品。。。。。
# 关系表[这种表,无法提供给python进行操作的,仅仅用于在数据库中记录两个模型之间的关系]
# 关系表[这种表,无法提供给python进行操作的,仅仅用于在数据库中记录两个模型之间的关系]
student_and_course = db.Table(
"table_student_course",
db.Column("id", db.Integer, primary_key=True, 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, default=datetime.now, comment="购买时间"), # 当前字段无法操作
)
class Student(db.Model):
id = db.Column(db.Integer, primary_key=True,comment="主键")
...
course_list = db.relationship("Course", secondary=student_and_course, backref="student_list", lazy="dynamic")
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 datetime
db = SQLAlchemy()
app = Flask(__name__, template_folder="templates", static_folder="static")
# 配置
app.config.update({
"DEBUG": True,
"SQLALCHEMY_DATABASE_URI": "mysql://root:123@127.0.0.1:3306/flaskdemo?charset=utf8mb4",
# 如果使用pymysql,则需要在连接时指定pymysql
# "SQLALCHEMY_DATABASE_URI": "mysql+pymysql://root:123@127.0.0.1:3306/flaskdemo?charset=utf8mb4"
# 动态追踪修改设置,如未设置只会提示警告,设置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_key=True, 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, default=datetime.now, comment="购买时间"), # 当前字段无法操作
)
class Student(db.Model):
"""学生信息模型"""
# 声明与当前模型绑定的数据表名称
__tablename__ = "table_student"
id = db.Column(db.Integer, primary_key=True,comment="主键")
name = db.Column(db.String(15), comment="姓名")
age = db.Column(db.SmallInteger, comment="年龄")
sex = db.Column(db.Boolean, default=True, comment="性别")
email = db.Column(db.String(128), comment="邮箱地址")
money = db.Column(db.Numeric(10, 2), default=0.0, comment="钱包")
course_list = db.relationship("Course", secondary=student_and_course, backref="student_list", lazy="dynamic")
def __repr__(self):
return json.dumps(self.__to_dict__, ensure_ascii=False)
@property
def __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_course"
id = db.Column(db.Integer, primary_key=True, comment="主键")
name = db.Column(db.String(64), unique=True, comment="课程")
price = db.Column(db.Numeric(7, 2), default=0.0, comment="价格")
def __repr__(self):
return json.dumps(self.__to_dict__, ensure_ascii=False)
@property
def __to_dict__(self):
return {
"id": self.id,
"name": self.name,
"price": self.price,
}
@app.route("/create")
def create_table():
db.create_all() # 为项目中被识别的所有模型创建数据表
return "ok"
@app.route("/drop")
def drop_table():
db.drop_all() # 为项目中被识别的所有模型删除数据表
return "ok"
@app.route("/")
def index():
return "ok"
@app.route("/a1")
def a1():
"""添加数据"""
"""添加其中一个主模型数据时,同时绑定添加另外一个主模型的数据,这个过程中,关系表会自动写入2者的关系数据,绑定2个模型之间的关系"""
# student = Student(
# name="xiaozhao",
# age=13,
# sex=False,
# money=30000,
# email="xiaozhao@qq.com",
# course_list=[
# Course(name="python入门", price=99.99),
# Course(name="python初级", price=199.99),
# Course(name="python进阶", price=299.99),
# ]
# )
# db.session.add(student)
# db.session.commit()
"""在学生报读课程的基础上,新增报读课程。"""
# student = Student(
# name="xiaohong",
# age=14,
# sex=False,
# money=30000,
# email="300000@qq.com",
# )
# db.session.add(student)
# db.session.commit()
# student = Student.query.filter(Student.name=="xiaohong").first()
# # 直接采用python内置的list方法操作
# student.course_list.append(Course.query.get(3)) # 新增已经存在的课程
# student.course_list.append(Course(name="python顶级", price=399.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 "ok"
@app.route("/q1")
def q1():
"""查询操作"""
# 查询ID=4的学生报读的课程列表
# 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 "ok"
@app.route("/u1")
def u1():
"""更新数据"""
# # 给报读了3号课程的同学,返现红包200块钱
# course = Course.query.get(3)
# for student in course.student_list:
# student.money+=200
# db.session.commit()
# db.Table的缺陷: 无法通过主模型直接操作db.Table中的外键之外的其他字段,例如:报读课程的时间
course = Course.query.get(3)
print(course.student_list)
# 解决:在声明2个模型是多对多的关联关系时,把关联关系使用第三个模型来创建声明,
# 就是不要使用db.Table改成模型来绑定关系,把模型的对多对拆分成2个1对多
return "ok"
if __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 datetime
db = SQLAlchemy()
app = Flask(__name__, template_folder="templates", static_folder="static")
# 配置
app.config.update({
"DEBUG": True,
"SQLALCHEMY_DATABASE_URI": "mysql://root:123@127.0.0.1:3306/flaskdemo?charset=utf8mb4",
# 如果使用pymysql,则需要在连接时指定pymysql
# "SQLALCHEMY_DATABASE_URI": "mysql+pymysql://root:123@127.0.0.1:3306/flaskdemo?charset=utf8mb4"
# 动态追踪修改设置,如未设置只会提示警告,设置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_key=True, 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, default=datetime.now, comment="购买时间"), # 当前字段无法操作
# )
class StudentCourse(db.Model):
__tablename__ = "demo_student_course"
id = db.Column(db.Integer, primary_key=True, 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, default=datetime.now, comment="购买时间")
# 关联属性
student = db.relationship("Student", uselist=False, backref=backref("to_relation", uselist=True))
course = db.relationship("Course", uselist=False, backref=backref("to_relation", uselist=True))
class Student(db.Model):
"""学生信息模型"""
# 声明与当前模型绑定的数据表名称
__tablename__ = "demo_student"
id = db.Column(db.Integer, primary_key=True,comment="主键")
name = db.Column(db.String(15), comment="姓名")
age = db.Column(db.SmallInteger, comment="年龄")
sex = db.Column(db.Boolean, default=True, comment="性别")
email = db.Column(db.String(128), comment="邮箱地址")
money = db.Column(db.Numeric(10, 2), default=0.0, comment="钱包")
def __repr__(self):
return json.dumps(self.__to_dict__, ensure_ascii=False)
@property
def __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_course"
id = db.Column(db.Integer, primary_key=True, comment="主键")
name = db.Column(db.String(64), unique=True, comment="课程")
price = db.Column(db.Numeric(7, 2), default=0.0, comment="价格")
def __repr__(self):
return json.dumps(self.__to_dict__, ensure_ascii=False)
@property
def __to_dict__(self):
return {
"id": self.id,
"name": self.name,
"price": self.price,
}
@app.route("/create")
def create_table():
db.create_all() # 为项目中被识别的所有模型创建数据表
return "ok"
@app.route("/drop")
def drop_table():
db.drop_all() # 为项目中被识别的所有模型删除数据表
return "ok"
@app.route("/")
def index():
return "ok"
@app.route("/a1")
def a1():
"""添加数据"""
"""添加其中一个主模型数据时,同时绑定添加另外一个主模型的数据"""
# student = Student(
# name="xiaozhao",
# age=13,
# sex=False,
# money=30000,
# email="xiaozhao@qq.com",
# to_relation=[
# StudentCourse(
# course=Course(name="python基础", price=99.9)
# )
# ]
# )
# db.session.add(student)
# db.session.commit()
"""在学生报读课程的基础上,新增报读课程。"""
# student = Student(
# name="xiaohong",
# age=14,
# sex=False,
# money=30000,
# email="300000@qq.com",
# )
# db.session.add(student)
# db.session.commit()
# student = Student.query.filter(Student.name == "xiaohong").first()
# # 直接采用python内置的list方法操作
# student.to_relation.extend([
# StudentCourse(
# course=Course.query.get(1) # 已经存在的课程,给学生报读
# ),
# StudentCourse(
# course=Course(name="python进阶", price=399.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(course=course) for course in course_list])
db.session.commit()
return "ok"
@app.route("/q1")
def q1():
"""查询操作"""
# 查询ID=2的学生报读的课程列表
# 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 "ok"
@app.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 "ok"
if __name__ == '__main__':
app.run()
relationship还有一个设置外键级联的属性:cascade=“all, delete, delete-orphan”
作业:
1. 我们现在学习的flask框架集成SQLAlchemy操作数据库使用的是flask-SQLAlchemy模块。如果原生的python下面应该如何使用SQLAlchemy进行初始化数据库连接和声明模型并实现模型的基本操作[增删查改,关联查询]?
2. flask中的SQLAlchemy如何进行自关联查询? 这里自己写一个关于行政区划的自关联操作。