目录

1.数据库查询-进阶

  1.常用的SQLAlchemy查询过滤器

  2.常用的SQLAlchemy查询结果的方法

  3.filter

  4.order_by

  5.count

  6.limit&offset

  7.paginate

  8.group_by

  Tip:在flask中执行原生SQL语句

2.关联查询

  1.常用的SQLAlchemy关系选项

  2.一对一

  3.一对多

  4.多对多

1.数据库查询-进阶

1.常用的SQLAlchemy查询过滤器

过滤器 说明
filter() 把过滤器添加到原查询上 ,返回一个新查询
filter_by() 把等值过滤器添加到原查询上,返回一个新查询
limit() 使用指定的值限定原查询返回的结果
offset() 偏移原查询返回的结果,返回一个新查询
order_by() 根据指定条件对原查询结果进行排序 ,返回一个新查询
group_by() 根据指定条件对原查询结果进行分组,返回一个新查询

 

 

 

 

 

 

 

 

 

2.常用的SQLAlchemy查询结果的方法

all() 以列表形式返回查询的所有结果
first() 返回查询的第一个结果,如果未查到 ,返回None
first_or_404() 返回查询的第一个结果 ,如果未查到,返回404
get() 返回指定主键对应的行,如不存在 ,返回None
get_or_404() 返回指定主键对应的行,如不存在,返回404
count() 返回查询结果的数量
paginate() 返回一个Paginate分页器对象 ,它包含指定范围内的结果
having 返回结果中符合条件的数据,必须跟在group by后面,其他地方无法使用 。

 

 

 

 

 

 

 

 

 

 

3.filter

1.filter设置判断条件

== != >= <= < >

student = Student.query.filter(Student.name=="xiaohui32号").first() if student is None: return jsonify({"error":"100404","errmsg":"没有该学生信息!"})

2.filter设置模糊查询

# like模糊条件 # 模型.字段.like("%值%") 等价于 模型.字段.contains("值") 包含xxx # 模型.字段.like("值%") 等价于 模型.字段.startswith("值") 以xxx开头 # 模型.字段.like("%值") 等价于 模型.字段.endswith("值") 以xxx结尾 # 模型.字段.like("__") 值长度为2个字符的.几个下划线代表几个字符 student_list = Student.query.filter(Student.name.like("%xiaohui%")).all() student_list = Student.query.filter(Student.name.startswith("xiao")).all() student_list = Student.query.filter(Student.name.like("________")).all()

3.filter_by设置精确条件查找数据

filter_by 只支持一个等号作为判断条件 ,而且字段左边不需要声明模型类名(money=1000)

可以用于获取一条数据,也可以获取多条数据

student = Student.query.filter_by(money=1000).first()

4.filter多条件查询

多条件需要基于逻辑运算来编写,当然 ,可以其他的声明方式

"""filter多条件查询""" # 多条件需要基于逻辑运算来编写,当然,可以其他的声明方式 """and_ 并且, 与""" from sqlalchemy import and_ # 方式1: student_list1 = Student.query.filter(Student.money==1000,Student.sex==True).all() # 方式2: student_list2 = Student.query.filter(and_(Student.money==1000,Student.sex==True)).all() """or_ 或者 ,或""" from sqlalchemy import or_ student_list = Student.query.filter( or_(Student.age > 17, Student.age < 15) ).all() """not_ 排除 ,非""" from sqlalchemy import not_ student_list = Student.query.filter(not_(Student.age > 17)).all()

5.filter值范围查询

"""filter值范围查询""" # 查询年龄= 15或者17或者19的 student_list = Student.query.filter(Student.age.in_([15,17,19])).all()

4.order_by

order_by:对结果进行排序

"""order_by结果排序""" # order_by(模型.字段.desc()) db.desc(模型.字段) 倒序 # order_by(模型.字段.asc()) db.asc(模型.字段) 升序 student_list = Student.query.order_by(db.desc(Student.money)).all() student_list = Student.query.order_by(Student.money.desc()).all()

5.count

count:统计结果数量

"""count 统计结果数量""" ret = Student.query.filter(Student.age>17).count()

6.limit&offset

limit:对结果数量进行限制

offset:对查询开始位置进行设置[偏移量]

"""limit 结果数量进行限制""" """offset 对查询开始位置进行设置""" # 对学生的钱包进行从大到小排名,第3-第5名的学生 student_list = Student.query.order_by(Student.money.desc()).offset(2).limit(3).all()

7.paginate

paginate:分页器

paginate的参数:

paginate(page=当前页码, per_page=每一页数据量, max_per_page=每一页最大数据量)

关于分页paginate需要知道的:

1.当前页码,默认是request.args["page"] ,如果当前参数没有值,则默认为1

2.每一页数据量,默认是100条

3.因为分页器有提供了一个 request.args.["per_page"]给客户端设置每一页数据量 ,所以可以限定客户端最多能设置的每一页数据量

"""paginate分页器""" # paginate(page=当前页码, per_page=每一页数据量, max_per_page=每一页最大数据量) # 当前页码,默认是从request.args["page"],如果当前参数没有值 ,则默认为1 # 每一页数据量,默认是100条 # 因为分页器有提供了一个 request.args.["per_page"]给客户端设置每一页数据量,所以可以限定客户端最多能设置的每一页数据量 pagination = Student.query.filter(Student.sex==True).paginate(per_page=1) print( pagination.items ) # 获取当前页数据量 print( pagination.has_next ) # 如果还有下一页数据 ,则结果为True print( pagination.has_prev ) # 如果有上一页数据,则结果为True print( pagination.page ) # 当前页页码 request.args.get("page",1) print( pagination.total ) # 本次查询结果的数据总量[被分页的数据量总数] print( pagination.pages ) # 总页码 print( pagination.prev() ) # 上一页的分页器对象,如果没有上一页 ,则默认为None print( pagination.next() ) # 下一页的分页器对象 ,如果没有下一页,则默认为None if pagination.has_next: print( pagination.next().items ) # 下一页的数据列表

8.group_by

group_by:分组查询

group_by

""" group_by 分组查询""" # 查询男生和女生的最大年龄 ret = db.session.query(Student.sex,func.max(Student.age)).group_by(Student.sex).all()

group_by+having

# 查询出男生和女生年龄大于18的人数 # having是针对分组的结果进行过滤处理,所以having能调用的字段 ,必须是分组查询结果中的字段,否则报错!! ret = db.session.query(Student.sex,Student.age, func.count(Student.age)).group_by(Student.sex,Student.age).having(Student.age>18).all()

Tip:在flask中执行原生SQL语句

"""执行原生SQL语句,返回结果不是模型对象, 是列表和元组""" # 查询多条 ret = db.session.execute("select id,name,age,IF(sex,'男','女') from tb_student").fetchall() # 查询单条 ret = db.session.execute("select * from tb_student where id = 3").fetchone() # 添加/修改/删除 db.session.execute("UPDATE tb_student SET money=(money + %s) WHERE age = %s" % (200, 22)) db.session.commit() # 查询出女生和男生中大于18岁的人数 ret = db.session.execute("SELECT IF(sex,'男','女'), count(id) from (SELECT id,name,age,sex FROM `tb_student` WHERE age>18) as stu group by sex").fetchall()

2.关联查询

1.常用的SQLAlchemy关系选项

选项名 说明
backref 在关系的另一模型中添加反向引用,用于设置外键名称,在1查多的
primary join 明确指定两个模型之间使用的连表条件
lazy 指定如何加载关联模型数据的方式。参数值:
select(立即加载 ,查询所有相关数据显示,相当于lazy=True)
subquery(立即加载,但使用子查询)
dynamic(不加载记录 ,但提供加载记录的查询对象)
uselist 如果为False,不使用列表,而使用标量值。
一对一关系中 ,需要设置relationship中的uselist=Flase,其他数据库操作一样 。
secondary 指定多对多关系中关系表的名字。
多对多关系中,需建立关系表 ,设置 secondary=关系表
secondary join 在SQLAlchemy中无法自行决定时 ,指定多对多关系中的二级连表条件

 

2.一对一

一对一:分为主表和附加表

1.主表中写relationship,附加表中写Foreignkey

2.relationship:关联属性,是SQLAlchemy提供给开发者快速引用外键模型的一个对象属性 ,不存在于mySQL中

3.relationship的参数backref: 反向引用,类似django的related,通过外键模型查询主模型数据时的关联属性,因为是一对一 ,所以值为own

一对一表关系建立

class Student(db.Model):own """个人信息主表""" .... # 关联属性,这个不会被视作表字段,只是模型的属性。 # 因为StudentInfo和Student是一对一的关系 ,所以uselist=False表示关联一个数据 info = db.relationship("StudentInfo",uselist=False,backref="own") class StudentInfo(db.Model): """个人信息附加表""" # 外键, # 1.如果是一对一,则外键放在附加表对应的模型中 # 2.如果是一对多 ,则外键放在多的表对象的模型中 uid = db.Column(db.Integer, db.ForeignKey(Student.id),comment="外键")

一对一模型操作

def index(): """1对1模型操作"""
# 1.获取数据[从主表读取数据,获取附加表数据] student = Student.query.get(3) print( student.info.address ) print( student.info.edu ) # 2.获取数据[从附加表读取数据,获取主表数据] student_info = StudentInfo.query.filter(StudentInfo.address=="象牙山村").first() print(student_info.own.name) # 3.添加数据[添加数据 ,把关联模型的数据也一并添加] student = Student(name="liu", sex=True, age=22, email="33523@qq.com", money=100) student.info = StudentInfo(address="深圳市宝安区创业2路103号", edu="本科") db.session.add(student) db.session.commit() # 4.修改数据[通过主表可以修改附加表的数据 ,也可以通过附加表模型直接修改主表的数据] student = Student.query.get(4) student.info.address = "广州市天河区天河东路103号" db.session.commit()
"""删除数据""" student = Student.query.get(2) db.session.delete(student.info) # 先删除外键模型,再删主模型 db.session.delete(student) db.session.commit()

3.一对多

一对多表关系建立

class Teacher(db.Model): ... # 关联属性,一的一方添加模型关联属性 course = db.relationship("Course", uselist=True, backref="teacher",lazy='dynamic') class Course(db.Model): ... # 外键 ,多的一方模型中添加外键 teacher_id = db.Column(db.Integer, db.ForeignKey(Teacher.id))
  • 其中realtionship描述了Course和Teacher的关系 。第一个参数为对应参照的类"Course"

  • 第二个参数backref为类Teacher申明新属性的方法

  • 第三个参数lazy决定了什么时候SQLALchemy从数据库中加载数据

    • lazy='subquery',查询当前数据模型时,采用子查询(subquery) ,把外键模型的属性也瞬间查询出来了 。

    • lazy=True或lazy='select',查询当前数据模型时,不会把外键模型的数据查询出来 ,只有操作到外键关联属性时,才进行连表查询数据[执行SQL]

    • lazy='dynamic',查询当前数据模型时 ,不会把外键模型的数据查询出来,只有操作到外键关联属性并操作外键模型具体属性时,才进行连表查询数据[执行SQL]

一对多模型操作

def more(): """一对多/多对一模型操作""" # 1.从'一'的一方的模型中获取'多'的一方模型的数据 teacher = Teacher.query.get(1) for course in teacher.course: print(course.name,course.price) # 2.从'多'的一方获取'一'的一方数据 course = Course.query.get(1) print(course.teacher) print(course.teacher.name) # 3.添加数据 # 从'一'的一方添加数据 ,同时给'多'的一方也添加 teacher = Teacher(name="蓝老师",option="讲师") teacher.course = [Course(name="插画入门",price=199.00),Course(name="素描入门",price=129.00),] db.session.add(teacher) db.session.commit()
"""更新数据""" teacher = Teacher.query.filter(Teacher.name == "灰太狼").first() teacher.course_list[0].name="抓懒洋洋" db.session.commit() """删除数据""" teacher = Teacher.query.filter(Teacher.name=="灰太狼").first() for course in teacher.course_list: db.session.delete(course) db.session.delete(teacher) db.session.commit()

4.多对多

多对多表关系建立

"""以db.Table关系表来确定模型之间的多对多关联""" achievement = 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')), ) '''两张表通过secondary关联第三张表''' class Course(db.Model): ... students = db.relationship('Student',secondary=achievement, backref='courses', lazy='dynamic') class Student(db.Model): course_list = db.relationship("Course", secondary=achievement,backref="student_list",lazy="dynamic")

多对多模型操作

def index(): """多对多""" """添加""" course1 = Course(name="坑爹", price="9.99", teacher=Teacher(name="灰太狼", option="讲师")) course2 = Course(name="坑娘", price="9.99", teacher=Teacher(name="灰太狼", option="讲师")) course3 = Course(name="和羊做朋友 ,一起坑爹", price="99.99", teacher=Teacher(name="喜洋洋", option="讲师")) student = Student( name="xiaohuihui", age=5, sex=False, money=1000, info=StudentInfo( mobile="13066666666", address="狼村1号别墅", ), course_list = [ course1, course2, course3, ] ) db.session.add(student) db.session.commit() """查询""" student = Student.query.filter(Student.name=="xiaohuihui").first() print(student) print(student.course_list) # [坑爹, 坑娘, 和羊做朋友,一起坑爹] course = Course.query.filter(Course.name=="和羊做朋友,一起坑爹").first() print(course.student_list.all()) # 获取所有学生信息 """更新""" course = Course.query.filter(Course.name == "和羊做朋友 ,一起坑爹").first() course.student_list[0].name="小灰灰" db.session.commit()

 

文章来源于网络,如有侵权请联系站长QQ61910465删除
本文版权归趣KUAI排www.SEOguruBlog.com 所有,如有转发请注明来出,竞价开户托管,seo优化请联系QQ→61910465