in Modellen mit vielen verschiedenen Feldern (Django) - django, django-models, many-to-many, django-queryset

Meine Frage bezieht sich auf die Erstellung von Abfragesätzen für Modelle, die über viele bis viele Bereiche hinweg miteinander verbunden sind.

Kontext - eine App, die ein Schüler betritt und mussbewerten seine oder ihre Lehrer. Die Fragen, die die App dem Schüler zeigt, haben folgende Logik: Jeder Schüler muss einige Lehrer bewerten. Jedem Lehrer sind verschiedene Kategorien von Fragen zugeordnet ("Intelligenz", "Respekt", "Empathie" usw.), Und jeder dieser Kategorien sind einige Fragen zugeordnet.

Die Modelle sind:

class Items(models.Model):
item = models.TextField()
def __str__(self):
return self.item

class Categories(models.Model):
category = models.CharField(max_length=50,null=True)
items_associated  = models.ManyToManyField(Items)
def __str__(self):
return self.category

class Professors(models.Model):
professor = models.CharField(max_length=50,null=True)
categories_assigned = models.ManyToManyField(Categories)
def __str__(self):
return self.professor

class Students(models.Model):
student_logged = models.CharField(max_length=50,null=True)
professors_to_evaluate = models.ManyToManyField(Professors)
def __str__(self):
return self.student_logged

Wenn ein Schüler das Web betritt, sind einige damit verbundenLehrer (Modellschüler) Diesen Lehrern sind wiederum einige Kategorien zugewiesen (Modellprofessoren). Diesen Kategorien sind wiederum einige Fragen zugeordnet (Modellkategorien). Ich möchte diese Fragen, die sich in den Modellelementen befinden, in einem Wörterbuch speichern. Wie kann ich es tun?

Ich habe versucht zu filtern und __in, aber ich kann es nicht bekommen.

Vielen Dank und vielen Dank für die Weisheit

Bearbeiten: Ich werde versuchen, Ihnen ein Beispiel zu geben, weil ich denke, dass es etwas schwierig sein könnte, es zu erklären.

---

Tom-Student muss seine Lehrer qualifizieren, die sind Rick-Professor und Barney-Lehrer.

---

Rick-Professor wird anhand der Kategorien von Fragen bewertet: respektvolle Behandlung und technisches Wissen.

---

die Kategorie von respektvoll Die Behandlung hat Fragen:

• Der Lehrer behandelt alle gleich
• Der Lehrer sagt keine unhöflichen Dinge
• Der Lehrer ist nett

das technisches Wissen Kategorie hat die Fragen damit verbunden:

• Er unterrichtet klar
• Er demonstriert fortgeschrittenes Wissen

---

Ich möchte also, dass die App ihm die zugehörigen Fragen anzeigt, wenn Tom-Student das Web betritt, um Rick-Professor zu bewerten. In diesem Fall sind dies:

• Der Lehrer behandelt alle gleich
• Der Lehrer sagt keine unhöflichen Dinge
• Der Lehrer ist nett
• Er unterrichtet klar
• Demonstriert fortgeschrittenes Wissen

Wenn er dann Barney-Lehrer bewertet, zeigt ihm die Website einige verschiedene Fragen entsprechend den Kategorien, die Barney-Lehrer zugewiesen hat.

Antworten:

0 für die Antwort № 1

Ich schlage vor, Sie verwenden die related_name Attribut. Ich habe hinzugefügt _x auf die zugehörigen Namen, um die Abfrage deutlicher zu machen.

class Items(models.Model):
item = models.TextField()
def __str__(self):
return self.item

class Categories(models.Model):
category = models.CharField(max_length=50,null=True)
items_associated  = models.ManyToManyField(Items, related_name="category_x")
def __str__(self):
return self.category

class Professors(models.Model):
professor = models.CharField(max_length=50,null=True)
categories_assigned = models.ManyToManyField(Categories, related_name="professor_x")
def __str__(self):
return self.professor

class Students(models.Model):
student_logged = models.CharField(max_length=50,null=True)
professors_to_evaluate = models.ManyToManyField(Professors, related_name="student_x")
def __str__(self):
return self.student_logged

items_for_student = Items.objects.filter(category_x__professor_x__student_x=student)

Aber auch die Namenskonventionen, die Sie für die Felder verwenden, sind etwas eigenartig. Ich habe unten Best Practices verwendet, damit Sie sehen können, wie das aussehen würde.

1. Kein Feld mit demselben Namen wie das Modell
2. Modelle sollten singulär sein (mit seltenen Ausnahmen)
3. ManyToMany- oder ForeignKey-Beziehungen sollten den Namen des Modells gemeinsam nutzen, damit die Abfrage selbst dokumentiert wird.

Mit diesen Regeln sieht hier die beste Vorgehensweise aus.

class Item(models.Model):
name = models.TextField()
def __str__(self):
return self.name

class Category(models.Model):
name = models.CharField(max_length=50,null=True)
items = models.ManyToManyField(Item, related_name="categories")
def __str__(self):
return self.name

class Professor(models.Model):
name = models.CharField(max_length=50,null=True)
categories = models.ManyToManyField(Category, related_name="professors")
def __str__(self):
return self.name

class Student(models.Model):
name = models.CharField(max_length=50,null=True)
professors = models.ManyToManyField(Professor, related_names="students")
def __str__(self):
return self.name

Und mit dieser Struktur würde die Abfrage folgendermaßen aussehen:

items = Item.objects.filter(categories__professors__students=student)

Beachten Sie auch, dass die obige Abfrage sein wird sehr Die Ausführung in einer Datenbank ist teuer, da 3 Joins ausgewertet werden.

---