Django: Check if record exists in two different states - django

Question

I am using two models to build a chat system between users:
class Chat(models.Model):
created = models.DateTimeField(auto_now_add=True)
class Participant(models.Model):
chat = models.ForeignKey(Chat, on_delete=models.CASCADE, related_name='participants')
sender = models.ForeignKey(CustomUser, on_delete=models.CASCADE)
receiver = models.ForeignKey(CustomUser, on_delete=models.CASCADE)
One record in the participants model represents the ability to send messages from the user sender to the user receiver.
Thus, for a valid private chat between A and B, two records will exist, one with A as sender and B as receiver and vice versa.
Since one user will always be the one starting the chat but the first participant record could be with A as sender or B as sender, I need to know if there's a clean and cheap way to check if both records exist when a user tries to initiate a chat, and return the chat id if it exists.
How do I search for the existence of records (sender=A, receiver=B) and (sender=B, receiver=A) in the same query?

Answer 1

You can use Q objects to create complex queries including matching on one condition OR another
query = Participant.objects.filter(Q(sender=A, receiver=B) | Q(sender=B, receiver=A))
query.count() == 2 # If you want to check that 2 records exist
| in this case creates a filter with an "OR"

Answer 2

You can make use of two JOINs here, like:
Chat.objects.filter(
participants__sender=user_a,
participants__receiver=user_b
).filter(
participants__sender=user_b,
participants__receiver=user_a
)
This will result in a query like:
SELECT chat.id, chat.created
FROM chat
INNER JOIN participant ON chat.id = participant.chat_id
INNER JOIN participant T5 ON chat.id = T5.chat_id
WHERE participant.receiver_id = user_b AND participant.sender_id = user_a
AND T5.receiver_id = user_a AND T5.sender_id = user_b
It will thus return all the Chat objects for which two such Participant objects exist.
The above is not ideal however, since we make two JOINs. In case there is a unique_together constraint on the participants, as in:
class Participant(models.Model):
chat = models.ForeignKey(Chat, on_delete=models.CASCADE, related_name='participants')
sender = models.ForeignKey(CustomUser, on_delete=models.CASCADE)
receiver = models.ForeignKey(CustomUser, on_delete=models.CASCADE)
class Meta:
unique_together = ['sender', 'receiver']
We can just count the number of Participant objects, like:
from django.db.models import Count, Q
Chat.objects.filter(
Q(participants__sender=user_a, participants__receiver=user_b) |
Q(participants__sender=user_b, participants__receiver=user_a)
).annotate(
nparticipants=Count('participants')
).get(
nparticipants=2
)
This will use the following query:
SELECT chat.id, chat.created, COUNT(participant.id) AS nparticipants
FROM chat
INNER JOIN participant ON chat.id = participant.chat_id
WHERE (participant.receiver_id = user_b AND participant.sender_id = user_a)
OR (participant.receiver_id = user_a AND participant.sender_id = user_b)
GROUP BY chat.id
HAVING COUNT(participant.id) = 2
We can use .get(..) here, since due to the unique_together constraint, it is guaranteed that there is at most one Chat object for which this will exist. We can thus then handle the situation with a Chat.DoesNotExist exception.
I am however not really convinced that the above modeling is ideal. First of all the number of records will scale quadratic with the number of participants: for three participants, there are six records. Furthermore a Chat is probably conceptually speaking not "directional": there is no sender and receiver, there are two or more peers that share information.