如何强制Django在查询中使用LEFT OUTER JOIN？

Question

I have two models: Person and Task.

class Person(models.Model):
    display_name = models.CharField()
    ...

class Task(models.Model):
    person = models.ForeignKey(Person)
    is_deleted = models.BooleanField()
    ...

I want to get a list of ALL people along with amount of tasks (including 0).

Initially, I wrote below query and it worked pretty well:

Person.objects.values('person_id', 'display_name').annotate(crt_task_amt=Count('task__id')).order_by('-crt_task_amt', 'display_name')

Later, I introduced a filter on is_deleted. Then people with no tasks disappeared :

Person.objects.filter(task__is_deleted=False).values('person_id', 'display_name').annotate(crt_task_amt=Count('task__id')).order_by('-crt_task_amt', 'display_name')

I'm looking for something like:

SELECT p.id, p.display_name, count(t.id) FROM dashboard_person p LEFT OUTER JOIN dashboard_task t ON (p.person_id=t.person_id AND t.is_deleted=0) GROUP BY t.person_id

Is there any way to achieve it without using raw SQL?

Answer 1

Sometimes django ORM decides to use INNER JOIN and sometimes LEFT OUTER JOIN. What is the logic behind, I haven't found yet. But I have tested some cases which get me idea behind.

Starting case (I am using django 1.8.1):

class Parent(...)
    ...

class Child(...):
    parent = ForeignKey(Parent)
    status = CharField()
    name   = CharField()
    ...

qs = Parent.object.all()

Task 1: for each parent record count how many child records contains

This should work:

qs = qs.annotate(child_count_all=Count("child"))

Looking into qs.query - you can see that LEFT OUTER JOIN is used, what is correct .

but if I do it with SUM + CASE-WHEN:

qs = qs.annotate(
        child_count=Sum(Case(default=1), output_field=IntegerField())
        )

Looking into qs.query - you can see that this time INNER JOIN is used, what will filter out all parent records which don't contain any child records, producing wrong results .

The workaround for this is something like:

qs = qs.annotate(
        child_count=Sum(
            Case(
                When(child__id=None, then=0),
                default=1,
                output_field=IntegerField())
            ))

This time qs.query showed using LEFT OUTER JOIN producing correct results.

Task 2: count how many active child records contains

Active child records are detected with status<>'INA'. Based on previous solution I tried following:

qs = qs.annotate(
        child_count=Sum(
            Case(
                When(child__id=None, then=0),
                When(child__status='INA', then=0),
                default=1,
                output_field=IntegerField())
            ))

but again, the qs.query shows that INNER JOIN is being used, thus producing wrong results (for my case).

The workaround/solution is using two or-ed Q objects:

qs = qs.annotate(
        child_count=Sum(
            Case(
                When(Q(child__id=None) | Q(child__status="INA"), then=0),
                default=1,
                output_field=IntegerField())
            ))

Again, qs.query used LEFT OUTER JOIN , yielding correct results.

Task 3: same as 2 but count only records which have name filled

This works:

qs = qs.annotate(
        child_with_name_count=Sum(
            Case(
                When(Q(child__id=None) | Q(child__status="INA"), then=0),
                When(child__name__isnull=False, then=1),
                default=0,
                output_field=IntegerField())
            ))

Conclusion

Can not tell for sure why is sometimes used inner and sometimes left join, so my way how to deal with it was to test various combinations by inspecting qs.query until I found proper result. Other way is by using qs.raw/join/extra and other more native and advanced django ORM/SQL combinations.

Answer 2

q = Task.objects.filter(is_deleted=False).values('person__id').annotate(crt_task_amt=Count('id')).order_by('-crt_task_amt', 'person__display_name')

q[0].person_id  # gives person_id
q[0].display_name #gives person name
q[0].crt_task_amt # gives count of task of first person

UPDATE:

Hope this works.

Task.objects.filter(is_deleted=False, person__isnull = True).values('person__id').annotate(crt_task_amt=Count('id')).order_by('-crt_task_amt', 'person__display_name')

This can be done easily using joins, but you need to use little bit of raw SQL for that.