正反向进阶操作

 # 正向查询
1.查询电话号码问1234的学校名称
    # res = models.School.objects.filter(schoolinfo_fo__phone='1234').values('name')
    # print(res)    # <QuerySet [{'name': '华清大学'}]>
2.查询学校名称为南芜大学的学生姓名及年龄
    # res = models.Student.objects.filter(school_fo__name='南芜大学').values('name', 'age')
    # print(res)     # <QuerySet [{'name': 'kevin', 'age': 20}]>
3.查询lili同学的老师姓名及年龄
    res = models.Teacher.objects.filter(student_fo__name='lili').values('name', 'age')
    print(res)    # <QuerySet [{'name': 'lili', 'age': 25}, {'name': 'jason', 'age': 28}]>

    # 反向查询
4.查询主键值为1的学校对应的学校信息 - -一对一
    # res = models.SchoolInfo.objects.filter(school__pk=1).values('phone', 'date_time')
    # print(res)      # <QuerySet [{'phone': '4321', 'date_time': datetime.date(2022, 9, 5)}]> 学校字段不加匹配不加括号
5.查询主键为1的学生对应的学校(学生 ---学校)--一对多
    # res = models.School.objects.filter(student__pk=1).values('name')
    # print(res)        # <QuerySet [{'name': '华清大学'}]>
 6.查询老师主键为1教授的学生姓名及年龄
    # res = models.Student.objects.filter(teacher__pk=1).values('name', 'age')
    # print(res)      # <QuerySet [{'name': 'lili', 'age': 18}, {'name': 'kevin', 'age': 20}]>

聚合查询

 1.通过聚合函数对数据进行查询(遵循正反向查询规律)关键字：aggregate

 from django.db.models import Max, Min, Count, Sum, Avg
1.查询学生年龄最小的学生姓名及年龄
    # age_info = models.Student.objects.aggregate(min_age=Min('age'))
    # print(age_info)  # {'min_age': 18}
2.查询学校数量
    # student_num = models.School.objects.aggregate(num=Count('name'))
    # print(student_num)   # {'num': 3}
3.查询lili同学的成绩平均值
    # result = models.Student.objects.filter(name='lili').aggregate(result_avg=Avg('result'))
    # print(result)   # {'result_avg': 62.8}
4.查询lili同学总共学习了几门课程
    # course = models.Student.objects.filter(name='lili').aggregate(course_sum=Sum('course'))
    print(course)     # {'course_sum': 3}

分组查询

 1.filter角色：在分组前使用相当于mysql中的where筛选 在分组后使用相当于mysql中的having过滤

 2.分组关键字：annotate

1.查询各学校中里面的学生人数
    # student_num = models.School.objects.annotate(student_num=Count('student__pk')).values('name', 'student_num')
    # print(student_num)   # <QuerySet [{'name': '南芜大学', 'student_num': 1}, {'name': '华清大学', 'student_num': 2}, {'name': '西南大学', 'student_num': 1}]>
2.统计学生学习的课程数量大于等于2门的学生姓名及课程数量
    course_num = models.Student.objects.annotate(course_num=Sum('course')).filter(course_num__gt=2).values('name', 'course_num')
    print(course_num)  # <QuerySet [{'name': 'kevin', 'course_num': 3}, {'name': 'tony', 'course_num': 4}]>

F查询

 1.F查询涉及查询字段都来源于表中字段非固定数据

 1.查询学生lili的地址前加中国
 from django.db.models import F, Value
 from django.db.models.functions import Concat
 models.Student.objects.filter(name='lili').update(addr=Concat(F('addr'), Value('中国')))

Q查询

 1.Q可以改变filter内多个条件之间的逻辑关系

1. 查询主键为1的学校及学生主键为1的学校
    # res = models.Student.objects.filter(Q(pk=1), Q(student__pk=1))  # ,and关系
    # res = models.Student.objects.filter(Q(pk=1) | Q(student__pk=1)) # |or关系
    # res = models.School.objects.filter(Q(pk=1) |~ Q(student__pk=1)) # ~not关系

 2.将查询条件字段改为字符串(用户输入)

    obj = Q()
    obj.connector = 'or'  # 默认是and的关系
    obj.children.append(('pk', 1))
    obj.children.append(('school_fo_id', 3))
    obj.children.append(('school_fo_id', 2))
    res = models.Student.objects.filter(obj)
    print(res)

ORM查询优化

1.减少数据库的查询(django orm默认是惰性查询 真正需要时才会执行代码)
2.django orm自带limit分页 减少数据库及服务端的压力
3.only与defer(会将括号内填写的字段封装成一个个数据对象)
  3.1 only：对象在点击括号中出现的字段 不会再走数据库查询
            对象点括号内没有的字段时 每次都会走数据库查询
          res = models.Student.objects.only('name', 'age')
          for obj in res:
              print(obj.name)
              print(obj.age)
              print(obj.addr)
              print(res.query)
  3.2 defer：数据对象点击括号中出现的字段 每次都会走数据库查询
             对象点击括号内不存在的字段 不会走数据库查询
        res = models.Student.objects.defer('name')
        for obj in res:
            print(obj.name)
            print(obj.age)
            print(obj.addr)
            print(res.query)
4.select_related与prefetch_related
  4.1 select_related：括号内只能接受外键字段(一对一 一对多)自动连表
      				 数据对象点击表中数据的时候不会走数据库查询
     res = models.Student.objects.all()
     for obj in res:
         print(obj.school_fo.name)
         print(res.query)     # 每次都会走数据库查询
       res = models.Student.objects.select_related('school_fo')  # 连表查询INNER JOIN
        for obj in res:
            print(obj.school_fo.name)
  4.2 prefetch_related：底层是子查询 将查询之后的结果一次性封装到数据对象中
      res = models.Student.objects.prefetch_related('school_fo')  # 子查询
      for obj in res:
          print(obj.school_fo.name)

事务操作

事务:ACID
事务隔离级别:脏读 幻读 不可重复读 ...
原生SQL: start transaction\rollback\commit\savepoint 

from django.db import transaction
try:
    with transaction.atomic():
        pass  # 多条ORM语句
except Exception as e:
        print(e)

ORM常见字段类型

 1.字段类型

 2.自定义字段类型

class MyCharField(models.Field):
    def __init__(self, max_length, *args, **kwargs):
        self.max_length = max_length
        super().__init__(max_length=max_length, *args, **kwargs)

    def db_type(self, connection):
        return 'char(%s)' % self.max_length
info = MyCharField(max_length=32)

ORM常见参数

多对多创建方式

1.自动创建
  student_fo = models.ManyToManyField(to='Student')
  优点:第三张表自动创建
  缺点:第三张表扩展性差
2.手动创建
   	class Teacher(models.Model):
        pass
    class Student(models.Model):
        pass
 	class Teacher2Student(models.Model):
        student_id = models.ForeignKey(to="Teacher")
        teacher_id = models.ForeignKey(to="Student")
 	优点:第三张表扩展性强
  	缺点:无法使用正反向查询以及多对多四个方法
3.半自动创建
	class Teacher(models.Model):
        student_fo = models.ManyToManyField(to='Student',
                      through='Teacher2Student'
                      through_fields=('teacher_id','student_id')
                                        )
   	class Student(models.Model):
        pass
 	class Teacher2Student(models.Model):
        student_id = models.ForeignKey(to="Teacher")
        teacher_id = models.ForeignKey(to="Student")
   	优点:扩展性强并且支持正反向查询
  	 缺点:无法使用多对多四个方法