un django assez complexe requête

Question

J'ai

class Supplier(Model) : 
    pass 

class Customer(Model) : 
    pass 

class Dock(Model) : 
    pass 

class SupplierDockAccess(Model) : 
    supplier = ForeignKey(Supplier) 
    dock = ForeignKey(Dock) 

class SupplierCustomerAccess(Model): 
    supplier = ForeignKey(Supplier) 
    customer = ForeignKey(Customer) 

J'ai une instance de client, et je voudrais obtenir tous les quais que le client a accès. Les clients ont accès aux fournisseurs via SupplierCustomerAccess, et les fournisseurs ont accès aux Docks via SupplierDockAccess. Je peux le faire comme ceci:

# get the suppliers the customer has access to 
supplier_customer_accesses = SupplierCustomerAccess.objects.filter(customer=customer) 
suppliers = [s.supplier for s in supplier_customer_accesses] 

# get the docks those suppliers have access to 
supplier_dock_accesses = SupplierDockAccess.objects.filter(supplier__in=suppliers) 
docks = [s.dock for s in supplier_dock_accesses] 

... mais la liste résultante des quais contient des doublons, et je pense vraiment que ce oughtta soit possible de le faire en une seule fois. Quelqu'un a-t-il envie de démontrer un puissant django-fu?

Answer 1

Le moyen le plus simple que je peux penser à faire est une combinaison de ManyToManyFields et custom QuerySet/Manager.

from django.db import models 
class CustomQuerySetManager(models.Manager): 
    """ 
     Class for making QuerySet methods available on result set 
     or through the objects manager. 
    """ 
    def get_query_set(self): 
     return self.model.QuerySet(self.model) 
    def __getattr__(self, attr, *args): 
     try:     
      return getattr(self.__class__, attr, *args) 
     except AttributeError: 
      return getattr(self.get_query_set(), attr, *args) 

class Customer(models.Model): 
    suppliers = models.ManyToManyField(through=SupplierCustomerAccess) 
    objects = CustomQuerySetManager() 
    class QuerySet(QuerySet): 
     def docks(self): 
      return Dock.objects.filter(
        supplierdockaccess__supplier__in=self.suppliers 
       ).distinct() 
    ... 
class Supplier(models.Model): 
    docks = models.ManyToManyField(through=SupplierDockAccess) 
    ... 

Vous devriez voir seulement un ou deux coups à la base de données (en fonction de si vous avez utilisé select_related quand vous avez obtenu votre client), et votre code est incroyablement propre:

docks = customer.docks() 
suppliers = customer.suppliers.all() 
... 

Answer 2

Très bien, je l'ai compris. L'une de ces choses où parler, il semble faire l'affaire:

docks = Dock.objects.filter(supplierdockaccess__supplier__suppliercustomeraccess__customer=customer).distinct() 

... et en regardant le sql, il ne fait en effet dans une grande jointure. Agréable. Désolé de répondre à ma propre question.