Come si può ottenere l'insieme di tutte le classi con relazioni inverse per un modello in Django?
-
07-07-2019 - |
Domanda
Data:
from django.db import models
class Food(models.Model):
"""Food, by name."""
name = models.CharField(max_length=25)
class Cat(models.Model):
"""A cat eats one type of food"""
food = models.ForeignKey(Food)
class Cow(models.Model):
"""A cow eats one type of food"""
food = models.ForeignKey(Food)
class Human(models.Model):
"""A human may eat lots of types of food"""
food = models.ManyToManyField(Food)
Come si può, dato solo la classe Food, ottenere un insieme di tutte le classi che ha "relazioni inverse"? a. Cioè data la classe Cibo , come si possono ottenere le classi Gatto , Mucca e Umano .
Penso che sia possibile perché Food ha le tre "relazioni inverse": Food.cat_set , Food.cow_set e Food.human_set .
L'aiuto è apprezzato & amp; grazie!
Soluzione
O
A) Usa ereditarietà di più tabelle e crea un " Eater " classe base, che eredita da Gatto, Mucca e Umano.
B) Utilizzare un Relazione generica , dove Il cibo potrebbe essere collegato a qualsiasi altro modello.
Queste sono funzioni ben documentate e supportate ufficialmente, è meglio attenersi a esse per mantenere pulito il proprio codice, evitare soluzioni alternative ed essere sicuri che sarà ancora supportato in futuro.
- EDIT (A.k.a. " come essere una puttana di reputazione ")
Quindi, ecco una ricetta per quel caso particolare.
Supponiamo che tu voglia assolutamente modelli separati per Cat, Cow e Human. In un'applicazione del mondo reale, vuoi chiederti perché una categoria " campo non farebbe il lavoro.
È più facile accedere a " real " classe attraverso relazioni generiche, quindi ecco l'implementazione per B. Non possiamo avere quel campo "cibo" in Persona, Gatto o Mucca, o incontreremo gli stessi problemi. Quindi creeremo un intermediario " FoodConsumer " modello. Dovremo scrivere ulteriori test di validazione se non vogliamo più di un alimento per un'istanza.
from django.db import models
from django.contrib.contenttypes.models import ContentType
from django.contrib.contenttypes import generic
class Food(models.Model):
"""Food, by name."""
name = models.CharField(max_length=25)
# ConsumedFood has a foreign key to Food, and a "eaten_by" generic relation
class ConsumedFood(models.Model):
food = models.ForeignKey(Food, related_name="eaters")
content_type = models.ForeignKey(ContentType, null=True)
object_id = models.PositiveIntegerField(null=True)
eaten_by = generic.GenericForeignKey('content_type', 'object_id')
class Person(models.Model):
first_name = models.CharField(max_length=50)
last_name = models.CharField(max_length=50)
birth_date = models.DateField()
address = models.CharField(max_length=100)
city = models.CharField(max_length=50)
foods = generic.GenericRelation(ConsumedFood)
class Cat(models.Model):
name = models.CharField(max_length=50)
foods = generic.GenericRelation(ConsumedFood)
class Cow(models.Model):
farmer = models.ForeignKey(Person)
foods = generic.GenericRelation(ConsumedFood)
Ora, per dimostrarlo, scriviamo semplicemente questo doctest :
"""
>>> from models import *
Create some food records
>>> weed = Food(name="weed")
>>> weed.save()
>>> burger = Food(name="burger")
>>> burger.save()
>>> pet_food = Food(name="Pet food")
>>> pet_food.save()
John the farmer likes burgers
>>> john = Person(first_name="John", last_name="Farmer", birth_date="1960-10-12")
>>> john.save()
>>> john.foods.create(food=burger)
<ConsumedFood: ConsumedFood object>
Wilma the cow eats weed
>>> wilma = Cow(farmer=john)
>>> wilma.save()
>>> wilma.foods.create(food=weed)
<ConsumedFood: ConsumedFood object>
Felix the cat likes pet food
>>> felix = Cat(name="felix")
>>> felix.save()
>>> pet_food.eaters.create(eaten_by=felix)
<ConsumedFood: ConsumedFood object>
What food john likes again ?
>>> john.foods.all()[0].food.name
u'burger'
Who's getting pet food ?
>>> living_thing = pet_food.eaters.all()[0].eaten_by
>>> isinstance(living_thing,Cow)
False
>>> isinstance(living_thing,Cat)
True
John's farm is in fire ! He looses his cow.
>>> wilma.delete()
John is a lot poorer right now
>>> john.foods.clear()
>>> john.foods.create(food=pet_food)
<ConsumedFood: ConsumedFood object>
Who's eating pet food now ?
>>> for consumed_food in pet_food.eaters.all():
... consumed_food.eaten_by
<Cat: Cat object>
<Person: Person object>
Get the second pet food eater
>>> living_thing = pet_food.eaters.all()[1].eaten_by
Try to find if it's a person and reveal his name
>>> if isinstance(living_thing,Person): living_thing.first_name
u'John'
"""
Altri suggerimenti
Sono stati rivelati alcuni scavi nel codice sorgente:
Django / db / modelli / options.py:
def get_all_related_objects(self, local_only=False):
def get_all_related_many_to_many_objects(self, local_only=False)
E, usando queste funzioni sui modelli dall'alto, ipoteticamente ottieni:
>>> Food._meta.get_all_related_objects()
[<RelatedObject: app_label:cow related to food>,
<RelatedObject: app_label:cat related to food>,]
>>> Food._meta.get_all_related_many_to_many_objects()
[<RelatedObject: app_label:human related to food>,]
# and, per django/db/models/related.py
# you can retrieve the model with
>>> Food._meta.get_all_related_objects()[0].model
<class 'app_label.models.Cow'>
Nota : ho sentito che Model._meta è 'instabile', e forse non si dovrebbe fare affidamento sul mondo post Django-1.0.
Grazie per aver letto. :)