模型设计

# models.py
class Course(models.Model):
    """课程"""
    title = models.CharField(verbose_name='课程名称', max_length=32)
    course_img = models.CharField(verbose_name='课程图片', max_length=64)
    level_choise = (
        (1, '初级'),
        (2, '中级'),
        (3, '高级'),
    )
    level = models.PositiveSmallIntegerField(verbose_name='课程难以程度', choices=level_choise, default=1)

class CourseDetail(models.Model):
    """课程详细"""
    course = models.OneToOneField(verbose_name='课程', to='Course', on_delete=models.CASCADE)
    slogan = models.CharField(verbose_name='口号', max_length=255)
    why = models.CharField(verbose_name='为什么要学？', max_length=255)
    recommend_courses = models.ManyToManyField(verbose_name='推荐课程', to='Course', related_name='recommends')

select_related

假设我们要获取所有课程的课程名称和课程的口号，一般情况可以按照一下的方法来查询

In [3]: course_details = CourseDetail.objects.all()
In [4]: for course_detail in course_details:
   ...:     title = course_detail.course.title
   ...: 

上面的方法相当于先从 CourseDetail 表中把所有数据先查询了一次，然后再对每一行的数据进行联表查询，即如果第一次查询出来10条数据，则后面循环查询了10次，因此一共查询了11次。当数据量大的时候，这种方式显然不适合，多次向数据库进行操作并不是我们想要的。因此可以改用 values() 来查询我们想要的值。

In [5]: CourseDetail.objects.values('slogan', 'course__title')
Out[5]: SELECT "api_coursedetail"."slogan",
       "api_course"."title"
  FROM "api_coursedetail"
 INNER JOIN "api_course"
    ON ("api_coursedetail"."course_id" = "api_course"."id")
 LIMIT 21

Execution time: 0.000000s [Database: default]
<QuerySet [{'slogan': 'python', 'course__title': 'python全栈'}, {'slogan': '学了没用', 'course__title': '金融量化'}, {'slogan': '无聊', 'course__title': '智能玩具'}]>

使用 values() 可以进行联表查询，避免多次的查询，但是我们有时候并不仅仅需要值，而更希望可以返回对象给我们，拿到对象并进行其他的操作，在这里我们可以使用 select_related() 来协助我们进行联表查询。

In [7]: course_details = CourseDetail.objects.select_related('course')

In [8]: course_detail = course_details[0]
SELECT "api_coursedetail"."id",
       "api_coursedetail"."course_id",
       "api_coursedetail"."slogan",
       "api_coursedetail"."why",
       "api_course"."id",
       "api_course"."title",
       "api_course"."course_img",
       "api_course"."level"
  FROM "api_coursedetail"
 INNER JOIN "api_course"
    ON ("api_coursedetail"."course_id" = "api_course"."id")
 LIMIT 1

Execution time: 0.000000s [Database: default]

In [9]: course_detail.course.title
Out[9]: 'python全栈'

通过上面的 sql 语句可以知道，我们指定一个 OneToOneField 或 ForeignKey 的字段，select_related() 会帮我们进行联表操作，查询得到的结果并返回对象本身，并且再进行获取该对象的外键的其他属性时直接获取，并没有再次向数据库发送查询语句。

但上面的方法会把两个表所有的字段都查询返回了，有时我们只想需要某些列，其他一些列的值我们并不关心，并且为了提高查询和传输速度，我们可以用到 only() 来控制对返回数据的某些列。

In [10]: course_details = CourseDetail.objects.select_related('course').only('slogan', 'course__title')

In [11]: course_detail = course_details[0]
SELECT "api_coursedetail"."id",
       "api_coursedetail"."course_id",
       "api_coursedetail"."slogan",
       "api_course"."id",
       "api_course"."title"
  FROM "api_coursedetail"
 INNER JOIN "api_course"
    ON ("api_coursedetail"."course_id" = "api_course"."id")
 LIMIT 1

Execution time: 0.000000s [Database: default]

In [12]: course_detail.course.title
Out[12]: 'python全栈'

由上面结果可以看出，Django 确实只向数据库请求了 slogan 和 title 这两列的数据。

但假如我们基于现在的结果，继续拿我们没有指定的列会怎样？

In [14]: course_detail.__dict__
Out[14]: 
{'_state': <django.db.models.base.ModelState at 0x2b1d23f3d00>,
 'id': 1,
 'course_id': 1,
 'slogan': 'python'}

In [15]: course_detail.why
SELECT "api_coursedetail"."id",
       "api_coursedetail"."why"
  FROM "api_coursedetail"
 WHERE "api_coursedetail"."id" = 1
 LIMIT 21

Execution time: 0.000000s [Database: default]
Out[15]: 'nijbi'

In [16]: course_detail.__dict__
Out[16]: 
{'_state': <django.db.models.base.ModelState at 0x2b1d23f3d00>,
 'id': 1,
 'course_id': 1,
 'slogan': 'python',
 'why': 'nijbi'}

这时 Django 会再次请求数据库获取数据，并且把结果赋值到对象的属性中。

prefetch_related

先看 prefetch_related() 这个方法做了一些什么事情

In [18]: CourseDetail.objects.prefetch_related('recommend_courses')
Out[18]: SELECT "api_coursedetail"."id",
       "api_coursedetail"."course_id",
       "api_coursedetail"."slogan",
       "api_coursedetail"."why"
  FROM "api_coursedetail"
 LIMIT 21

Execution time: 0.000000s [Database: default]
SELECT ("api_coursedetail_recommend_courses"."coursedetail_id") AS "_prefetch_related_val_coursedetail_id",
       "api_course"."id",
       "api_course"."title",
       "api_course"."course_img",
       "api_course"."level"
  FROM "api_course"
 INNER JOIN "api_coursedetail_recommend_courses"
    ON ("api_course"."id" = "api_coursedetail_recommend_courses"."course_id")
 WHERE "api_coursedetail_recommend_courses"."coursedetail_id" IN (1, 2, 3)

Execution time: 0.089767s [Database: default]
SELECT "api_course"."id",
       "api_course"."title",
       "api_course"."course_img",
       "api_course"."level"
  FROM "api_course"
 WHERE "api_course"."id" = 1
 LIMIT 21

Execution time: 0.000000s [Database: default]
SELECT "api_course"."id",
       "api_course"."title",
       "api_course"."course_img",
       "api_course"."level"
  FROM "api_course"
 WHERE "api_course"."id" = 2
 LIMIT 21

Execution time: 0.000000s [Database: default]
SELECT "api_course"."id",
       "api_course"."title",
       "api_course"."course_img",
       "api_course"."level"
  FROM "api_course"
 WHERE "api_course"."id" = 3
 LIMIT 21

Execution time: 0.000000s [Database: default]
<QuerySet [<CourseDetail: 课程详细：python全栈>, <CourseDetail: 课程详细：金融量化>, <CourseDetail: 课程详细：智能玩具>]>

prefetch_related 方法其他和我们一开始写的 for 方法相似，但又有些区别。其原理理解可以类似下面的过程

# 1. prefetch_related 方法首先会把当前的表查询出来，相当于
course_details = CourseDetail.objects.all()
# 2. 根据所需要的外键，把该外键的 ID 查询出来，并且去重
course_ids = set(course_details.values_list('recommend_courses', flat=True))
# 3. 根据这些 id 值，再进行查询该外键的表的数据
for course_id in course_ids:
    Course.objects.filter(id=course_id)

这样做避免查询无需的数据，并且查询外键的其他值时也无需再进行 sql 查询了。

In [4]: course_details = CourseDetail.objects.prefetch_related('recommend_courses')

In [5]: course_detail = course_details[0]
SELECT "api_coursedetail"."id",
       "api_coursedetail"."course_id",
       "api_coursedetail"."slogan",
       "api_coursedetail"."why"
  FROM "api_coursedetail"
 LIMIT 1

Execution time: 0.001000s [Database: default]
SELECT ("api_coursedetail_recommend_courses"."coursedetail_id") AS "_prefetch_related_val_coursedetail_id",
       "api_course"."id",
       "api_course"."title",
       "api_course"."course_img",
       "api_course"."level"
  FROM "api_course"
 INNER JOIN "api_coursedetail_recommend_courses"
    ON ("api_course"."id" = "api_coursedetail_recommend_courses"."course_id")
 WHERE "api_coursedetail_recommend_courses"."coursedetail_id" IN (1)

Execution time: 0.000000s [Database: default]

In [6]: course_detail.recommend_courses.all()
Out[6]: <QuerySet [<Course: 金融量化>, <Course: 智能玩具>]>

总结

select_related 可以用于 一对一 和 一对多，而 prefetch_related 可以用于 一对多 和 多对多，而 select_related 用的是联表查询，prefetch_related 更像是分步查询，因此一般情况下能用 select_related 的尽量使用。

参考：
https://www.cnblogs.com/tuifeideyouran/p/4232028.html