Django ORM 深度优化：高效处理嵌套外键字段的策略与实践

class A(models.Model):
  field1 = models.CharField(max_length=100)
  field2 = models.IntegerField()

class B(models.Model):
  field3 = models.CharField(max_length=100)
  field_a = models.ForeignKey(A, on_delete=models.CASCADE)

class C(models.Model):
  field4 = models.CharField(max_length=100)
  field5 = models.BooleanField(default=False)
  field_b = models.ForeignKey(B, on_delete=models.CASCADE)

  @property
  def nested_field_a(self):
    return self.field_b.field_a

# 假设我们有一个C对象实例
# obj_c = C.objects.first()
# print(obj_c.nested_field_a) # 这会触发额外的查询

# 使用 select_related 优化
queryset = C.objects.select_related('field_b__field_a')
obj = queryset.first()

# 此时访问 nested_field_a 不会触发额外的SQL查询
print(obj.nested_field_a)
print(obj.nested_field_a.field1) # 也可以直接访问A的字段

from django.db.models import F

# 使用 annotate 投影 A 模型的 field1 字段
queryset = C.objects.annotate(
    nested_a_field1=F('field_b__field_a__field1')
)
obj = queryset.first()

# 此时可以直接通过新属性访问 A 模型的 field1
print(obj.nested_a_field1) # 访问这个属性不会触发额外的SQL查询

from django.db.models import Manager, Model, F

class CManager(Manager):
    def get_queryset(self):
        # 默认情况下，所有通过 CManager 访问的查询都将预加载 field_b 和 field_a
        return (
            super().get_queryset()
            .select_related('field_b__field_a') # 或 .annotate(a_field1=F('field_b__field_a__field1'))
        )

class C(Model):
    field4 = models.CharField(max_length=100)
    field5 = models.BooleanField(default=False)
    field_b = models.ForeignKey(B, on_delete=models.CASCADE)

    objects = Manager() # 默认管理器
    with_optimized_a = CManager() # 自定义管理器

# 使用自定义管理器进行查询
queryset = C.with_optimized_a.all()
obj = queryset.first()
print(obj.field_b.field_a.field1) # 不会触发额外查询

from django.db.models import F, Model, QuerySet

class CQuerySet(QuerySet):
    def with_nested_a_fields(self):
        """
        注解 A 模型的相关字段到查询集中。
        """
        return self.annotate(
            a_field_1=F('field_b__field_a__field1'),
            a_field_2=F('field_b__field_a__field2')
        )

    def with_nested_b_fields(self):
        """
        注解 B 模型的相关字段到查询集中。
        """
        return self.annotate(
            b_field_3=F('field_b__field3')
        )

    def prefetch_all_related(self):
        """
        预加载所有直接和嵌套关联对象。
        """
        return self.select_related('field_b__field_a')

class C(Model):
    field4 = models.CharField(max_length=100)
    field5 = models.BooleanField(default=False)
    field_b = models.ForeignKey(B, on_delete=models.CASCADE)

    objects = CQuerySet.as_manager() # 将自定义QuerySet注册为默认管理器

# 示例：组合使用自定义QuerySet方法
queryset = (
    C.objects
    .filter(field_b__field_a__field2__gt=10) # 可以在链中任意位置进行过滤
    .with_nested_a_fields() # 添加A的字段
    .with_nested_b_fields() # 添加B的字段
    .prefetch_all_related() # 预加载所有关联对象
)
obj = queryset.first()

# 现在可以访问注解的字段和预加载的对象
print(obj.a_field_1)
print(obj.b_field_3)
print(obj.field_b.field_a.field2) # 预加载后访问不会触发额外查询