参考1：ForeignKey，ManyToManyField和OneToOneField的辨析
参考2：Django文档—Model中的ForeignKey、ManyToManyField、OneToOneField
参考3：Django之Model操作之select_related的应用
class Province(models.Model):
name = models.CharField(max_length=10)
def __unicode__(self):
return self.name
def __str__(self):
return self.name
class City(models.Model):
name = models.CharField(max_length=5)
province = models.ForeignKey(Province, null=True, blank=True, on_delete=models.CASCADE)
def __unicode__(self):
return self.name
class Order(models.Model):
customer = models.ForeignKey("Person", on_delete=models.CASCADE)
orderinfo = models.CharField(max_length=50)
time = models.DateTimeField(auto_now_add=True)
def __unicode__(self):
return self.orderinfo
class Person(models.Model):
firstname = models.CharField(max_length=10)
lastname = models.CharField(max_length=10)
needs = models.ForeignKey(to=Order, related_name='require', null=True, blank=True, on_delete=models.DO_NOTHING)
visitation = models.ManyToManyField(City, related_name="visitor", null=True, blank=True)
hometown = models.ForeignKey(City, related_name="birth", on_delete=models.CASCADE)
living = models.ForeignKey(City, related_name="citizen", on_delete=models.CASCADE)
def __unicode__(self):
return self.firstname +self.lastname
对 select_related 的操作，主要针对以上model来进行说明：
常用
model.tb.objects.all().select_related('外键字段')
model.tb.objects.all().select_related('外键字段__外键字段')
概念
对于一对一字段（OneToOneField）和外键字段（ForeignKey，多对一），可以使用select_related 来对QuerySet进行优化
在对QuerySet使用select_related()函数后，Django会获取相应外键对应的对象，从而在之后需要的时候不必再查询数据库了
city_objs = City.objects.all()
for cin city_objs:
print(c.province)
这样会导致线性的SQL查询，如果对象数量n太多，每个对象中有k个外键字段的话，就会导致n*k+1次SQL查询。在本例中，因为假设有30个city对象就导致了30 + 1 次SQL查询
以下是部分sql日志
[2021-11-06 12:05:00,383] [utils.py:123] [utils:debug_sql] DEBUG (0.000) SELECT `orm_practice_city`.`id`, `orm_practice_city`.`name`, `orm_practice_city`.`province_id` FROM `orm_practice_city`; args=()
[2021-11-06 12:05:00,384] [utils.py:123] [utils:debug_sql] DEBUG (0.000) SELECT `orm_practice_province`.`id`, `orm_practice_province`.`name` FROM `orm_practice_province` WHERE `orm_practice_province`.`id` = 11 LIMIT 21; args=(11,)
[2021-11-06 12:05:00,385] [utils.py:123] [utils:debug_sql] DEBUG (0.000) SELECT `orm_practice_province`.`id`, `orm_practice_province`.`name` FROM `orm_practice_province` WHERE `orm_practice_province`.`id` = 12 LIMIT 21; args=(12,)
[2021-11-06 12:05:00,386] [utils.py:123] [utils:debug_sql] DEBUG (0.000) SELECT `orm_practice_province`.`id`, `orm_practice_province`.`name` FROM `orm_practice_province` WHERE `orm_practice_province`.`id` = 13 LIMIT 21; args=(13,)
[2021-11-06 12:05:00,387] [utils.py:123] [utils:debug_sql] DEBUG (0.000) SELECT `orm_practice_province`.`id`, `orm_practice_province`.`name` FROM `orm_practice_province` WHERE `orm_practice_province`.`id` = 14 LIMIT 21; args=(14,)
[2021-11-06 12:05:00,387] [utils.py:123] [utils:debug_sql] DEBUG (0.000) SELECT `orm_practice_province`.`id`, `orm_practice_province`.`name` FROM `orm_practice_province` WHERE `orm_practice_province`.`id` = 15 LIMIT 21; args=(15,)
[2021-11-06 12:05:00,388] [utils.py:123] [utils:debug_sql] DEBUG (0.000) SELECT `orm_practice_province`.`id`, `orm_practice_province`.`name` FROM `orm_practice_province` WHERE `orm_practice_province`.`id` = 16 LIMIT 21; args=(16,)
现在如果我们使用select_related()函数：
city_objs = City.objects.select_related("province").all()
for cin city_objs:
print(c.province)
就只有一次SQL查询，显然大大减少了SQL查询的次数，看到他做了了inner join，把foreign key的表连接过来
[2021-11-06 12:12:39,386] [utils.py:123] [utils:debug_sql] DEBUG (0.000) SELECT `orm_practice_city`.`id`, `orm_practice_city`.`name`, `orm_practice_city`.`province_id`, `orm_practice_province`.`id`, `orm_practice_province`.`name` FROM `orm_practice_city` LEFT OUTER JOIN `orm_practice_province` ON (`orm_practice_city`.`province_id` = `orm_practice_province`.`id`); args=()
再比如：
zhu = Person.objects.select_related("living__province").get(id=10)
print(zhu.living.province)
[2021-11-06 12:15:22,440] [utils.py:123] [utils:debug_sql] DEBUG (0.000) SELECT `orm_practice_person`.`id`, `orm_practice_person`.`firstname`, `orm_practice_person`.`lastname`, `orm_practice_person`.`needs_id`, `orm_practice_person`.`hometown_id`, `orm_practice_person`.`living_id`, `orm_practice_city`.`id`, `orm_practice_city`.`name`, `orm_practice_city`.`province_id`, `orm_practice_province`.`id`, `orm_practice_province`.`name` FROM `orm_practice_person` INNER JOIN `orm_practice_city` ON (`orm_practice_person`.`living_id` = `orm_practice_city`.`id`) LEFT OUTER JOIN `orm_practice_province` ON (`orm_practice_city`.`province_id` = `orm_practice_province`.`id`) WHERE `orm_practice_person`.`id` = 10 LIMIT 21; args=(10,)
这样查询 living做关联的时候就不用再查询一次了；可以看到，Django使用了2次 INNER JOIN 来完成请求，获得了city表和province表的内容并添加到结果表的相应列，这样在调用zhu .living的时候也不必再次进行SQL查询。
select_related() 支持三种方法：
1：指定 *fields 参数
这个参数是需要获取的外键(父表内容)的字段名，用来关联外键的字段名，比如：
- 有外键的外键。 比如这里的
zhu = Person.objects.select_related('living__province').get(firstname="zhu")
zhu = Person.objects.select_related('living__province').get(firstname="zhu")
zhu.living.province // 没有产生其他sql
<Province: 浙江>
然而，未指定的外键则不会被添加到结果中，就会产生一条查询sql
zhu.hometown.province
(0.000) SELECT "select_related_province"."id", "select_related_province"."name" FROM "select_related_<Province: 浙江>
- 有多个外键时需要指定到哪个外键做关联(默认全部都关联)
zhu = Person.objects.select_related('living__province', 'hometown__province').all()
或者
zhu = Person.objects.select_related('living__province').select_related('hometown__province').all()
2 ：指定 depth 参数 （已废弃了）
select_related() 接受depth参数，depth参数可以确定select_related的深度。Django会递归遍历指定深度内的所有的OneToOneField和ForeignKey
3 ：不指定参数
select_related() 也可以不加参数，这样表示要求Django尽可能深的select_related
Django本身内置一个上限，对于特别复杂的表关系，Django可能在你不知道的某处跳出递归，从而与你想的做法不一样。具体限制是怎么工作的我表示不清楚。
Django并不知道你实际要用的字段有哪些，所以会把所有的字段都抓进来，从而会造成不必要的浪费而影响性能。
注意： 由于Person的外键字段needs与Order的外键字段customer是相互引用情况，在不给定具体参数时，默认不会join (已测)
[2021-11-06 12:29:35,365] [utils.py:123] [utils:debug_sql] DEBUG (0.000) SELECT `orm_practice_person`.`id`, `orm_practice_person`.`firstname`, `orm_practice_person`.`lastname`, `orm_practice_person`.`needs_id`, `orm_practice_person`.`hometown_id`, `orm_practice_person`.`living_id`, `orm_practice_city`.`id`, `orm_practice_city`.`name`, `orm_practice_city`.`province_id`, T3.`id`, T3.`name`, T3.`province_id` FROM `orm_practice_person` INNER JOIN `orm_practice_city` ON (`orm_practice_person`.`hometown_id` = `orm_practice_city`.`id`) INNER JOIN `orm_practice_city` T3 ON (`orm_practice_person`.`living_id` = T3.`id`) WHERE `orm_practice_person`.`id` = 10 LIMIT 21; args=(10,)
小结
1： select_related主要针一对一和多对一(外键)关系进行优化。
2： select_related使用SQL的JOIN语句进行优化，通过减少SQL查询的次数来进行优化、提高性能。
3 ：可以通过可变长参数指定需要select_related的字段名。也可以通过使用双下划线“__”连接字段名来实现指定的递归查询。没有指定的字段不会缓存，没有指定的深度不会缓存，如果要访问的话Django会再次进行SQL查询。
4 ：也接受无参数的调用，Django会尽可能深的递归查询所有的字段。但注意有Django递归的限制和性能的浪
