Build a Django "ForeignKey" that returns multiple values

Question

I'd like to build a new related field type. Here's a simple example:

class CustomQuerySet(QuerySet):
    def current(self):
        return self.filter(invalid_date__isnull=True)

class CustomManager(Manager):
    def get_query_set(self):
        return CustomQuerySet(self.model, using=self._db)
    def current(self):
        return self.get_query_set().current()

class Item(models.Model):
    objects = CustomManager()

    row_id = models.IntegerField(primary_key=True)
    id = models.IntegerField()
    name = models.CharField(max_length=100)
    change_date = models.DateTimeField(auto_now_add=True)
    invalid_date = models.DateTimeField(null=True, blank=True)


class Collection(models.Model):
    item = MultipleRelatedField(Item, related_field='id', related_name='collections')
    name = models.CharField(max_length=100)

Given c = Collection():

• c.item should return a queryset equivalent to Item.objects.filter(id=c.item_id).
• That queryset does need to be an instance of CustomQuerySet
• Item.objects.filter(collections__name='SomeName') should work as expected.
• The operation Collection.objects.filter(item__name='OtherName', item__invalid_date__isnull=True) should work as expected.

I realize this could be implemented with a ManyToManyField but I don't want to manually add/remove item objects to c.item. I don't need the join table as c.item always uses a single id value, it's just not a primary key on Collection. And c.item may /not/ contain item objects with different id values.

I'm aware that this is likely going require subclassing django.db.models.fields.related.ForeignRelatedObjectsDescriptor and/or django.db.models.fields.related.ForeignObject (or possibly the ManyToMany equivalents).

Answer 1

It looks to me like what you really want is an automatic way to generate a queryset from a model A against another model B based on the value of a field in A.

I suspect that ultimately, returning that queryset as the value of the field on A isn't really the best solution--that really goes against the grain of the ORM and would make it difficult, for example, to use that model in the admin or other common places.

Instead, it would be better to take an idea from how Django treats fields with choices set: automatically generate a method in the model class that return the derived information, such that if your model has a field:

item = MultipleRelatedField(Item, related_field='id', related_name='collections')

you would automatically get a method like get_item_queryset that would return the queryset you've specified.

To build that, you'd likely want to subclass an existing field (IntegerField would probably be a good starting point) and then override the __init__ method (to accept additional arguments) and the contribute_to_class method (where the new method would be generated). You can see the place where this happens for the choices-derived get_FIELD_display method here for inspiration.