Aller au contenu

Commentaires reportés

Modèle auto-référencé

Lorsque vous souhaitez faire référence au même modèle pour créer une relation lors d'une déclaration, vous devez déclarer le modèle référencé comme ForwardRef, car la classe n'est pas prête lors de la déclaration et python ne vous permettra pas de le référencer par défaut.

Même si vous voudrez peut-être utiliser un commentaire futur ou simplement référencer le nom avec un «», cela ne fonctionnera pas, car ormar est destiné à être utilisé avec ForwardRef explicitement déclaré.

Tout d'abord, vous devez importer les références souhaitées à partir de l'entrée.

1
from typing import ForwardRef

Maintenant, nous avons besoin d'un modèle d'exemple et d'une référence au même modèle, qui sera utilisé pour créer une relation d'auto-référence.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
#Créer le forwardref pour model Person
PersonRef = ForwardRef("Personne")


Classe Person(modèle ormar):
    ormar_config = base_ormar_config.copy()

    id: int = ormar.Integer(primary_key=True)
    name: str = ormar.String(max_length=100)
    #utiliser le forwardref comme paramètre
    superviseur: PersonRef = ormar.ForeignKey(PersonRef, related_name="employés")

Mais avant d'utiliser le modèle, vous devez mettre à jour manuellement les références afin qu 'elles produisent le modèle réel.

!!!avertit que si vous essayez d'utiliser le modèle sans mettre à jour la référence, une exception ModelError sera levée. donc, dans l'exemple ci-dessus, tout appel comme celui ci-dessous provoque une exception python # creation of model - exception await Person.objects.create(name="Test") # initialization of model - exception Person2(name="Test") # usage of model's QuerySet - exception await Person2.objects.get().

Pour mettre à jour une référence, appelez la méthode update_forward_refs sur chaque modèle avec une référence directe uniquement après avoir déclaré tous les modèles associés.

Donc, pour que notre exemple précédent fonctionne correctement, nous avons juste besoin d'une ligne supplémentaire.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
PersonRef = ForwardRef("Personne")


Classe Person(modèle ormar):
    ormar_config = base_ormar_config.copy()

    id: int = ormar.Integer(primary_key=True)
    name: str = ormar.String(max_length=100)
    superviseur: PersonRef = ormar.ForeignKey(PersonRef, related_name="employés")


Person.update_forward_refs()

Bien sûr, la même chose peut être faite exactement de la même manière avec la relation ManyToMany pour les paramètres to et through.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
#déclarer la référence
ChildRef = ForwardRef("enfant")

Classe Childfriend(modèle ormar):
    ormar_config = base_ormar_config.copy()

classe enfant (modèle ormar):
    ormar_config = base_ormar_config.copy()

    id: int = ormar.Integer(primary_key=True)
    name: str = ormar.String(max_length=100)
    #Utilisez-le dans la relation
    Amis = ormar.ManyToMany(ChildRef, through=Childfriend,
                               related_name="also_friends")


Child.update_forward_refs()

Relations entre modèles

Le même mécanisme et la même logique que les modèles auto-référencés peuvent être utilisés pour relier plusieurs modèles différents les uns aux autres.

Bien sûr, ormar crée une relation inverse pour les deux parties de la relation que vous liez, en utilisant le nom de relation spécifié (ou par défaut).

Toutefois, si vous avez besoin de deux (ou plusieurs) relations entre deux modèles qui, pour une raison quelconque, devraient être stockées des deux côtés (déclarant ainsi une relation sur un modèle et l'autre sur le second), vous devez utiliser ForwardRef pour y parvenir.

Regardez les exemples simples ci-dessous.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
# Teacher n'est pas défini
TeacherRef = ForwardRef("Teacher")


Classe étudiante (modèle ormar):
    ormar_config = base_ormar_config.copy()

    id: int = ormar.Integer(primary_key=True)
    name: str = ormar.String(max_length=100)
    #donc nous utilisons la référence à l'intérieur du modèle actuel
    primary_teacher: TeacherRef = ormar.ForeignKey(TeacherRef,
                                                   related_name="own_students")


Classe StudentTeacher(modèle ormar):
    ormar_config = base_ormar_config.copy(tablename ='students_x_teachers')


Enseignant de classe (modèle ormar):
    ormar_config = base_ormar_config.copy()

    id: int = ormar.Integer(primary_key=True)
    nom: str = ormar.String(max_length=100)
    #Nous avons besoin d'étudiants pour d'autres relations qui ont l'ordre
    étudiants = ormar.ManyToMany(étudiant, through= étudiant,
                                related_name="enseignants")

#Maintenant, le modèle de l'enseignant est déjà défini et nous pouvons mettre à jour les références
Student.update_forward_refs()

Attention!!! Gardez à l'esprit que, quel que soit le nombre de relations définies, le nom__related doit être unique dans le modèle pertinent.