Beaucoup à beaucoup

ManyToMany (to, through), avec les paramètres obligatoires to et optionnel through, prend à la fois les classes de modèle objectif et relationnel.

Les colonnes et types Sqlalchemy sont automatiquement extraits du modèle cible.

Colonne Sqlalchemy: Classe de la colonne de clé primaire du modèle cible
Type (pour pydantic): type du modèle cible

Définir le modèle

from typing import List, Optional

import databases
import ormar
import sqlalchemy

DATABASE_URL = "sqlite:///test.db"

ormar_base_config = ormar.OrmarConfig(
    database=databases.Database(DATABASE_URL), metadata=sqlalchemy.MetaData()
)


class Author(ormar.Model):
    ormar_config = ormar_base_config.copy(tablename="authors")

    id: int = ormar.Integer(primary_key=True)
    first_name: str = ormar.String(max_length=80)
    last_name: str = ormar.String(max_length=80)


class Category(ormar.Model):
    ormar_config = ormar_base_config.copy(tablename="categories")

    id: int = ormar.Integer(primary_key=True)
    name: str = ormar.String(max_length=40)


class Post(ormar.Model):
    ormar_config = ormar_base_config.copy(tablename="posts")

    id: int = ormar.Integer(primary_key=True)
    title: str = ormar.String(max_length=200)
    categories: Optional[List[Category]] = ormar.ManyToMany(Category)
    author: Optional[Author] = ormar.ForeignKey(Author)

Créer des données d'échantillon:

guido = await Author. objects. create (first_name ="Guido", last_name ="Van Rossum ")
post = await Post. objects. create (title ="Hello, M2M", author = guido)
news = await Category. objects. create (name ="news ")

Relation inverse

Le champ de clé étrangère enregistre automatiquement le verso de la relation.

Par défaut, il s'agit du nom du modèle enfant (source)+ s, comme dans le post du fragment de code suivant:

Catégorie de classe (modèle ormar):
    ormar_config = base_ormar_config. copy (tablename ="catégories ")

    id: int = ormar. Integer (primary_key = True)
    name: str = ormar. String (max_length = 40)


Classe Post (modèle d'ormar)
    ormar_config = base_ormar_config. copy ()

    id: int = ormar. Integer (primary_key = True)
    title: str = ormar. String (max_length = 200)
    Catégories: Optional [List [Category]]= ormar. ManyToMany (Category)

#Créer quelques données d'ample
post = await Post. objects. create (titre ="Hello, M2M ")
news = await Category. objects. create (name ="news ")
await post.categories.add(news)

#maintenant vous pouvez interroger et accéder à partir de both sides:
post_check = Post.objects.select_related("catégories").get()
assert post_check.categories[0] == news

# query through auto registered reverse side
category_check = Category.objects.select_related("posts").get()
assert category_check.posts[0] == post

Une relation inverse expose une API pour gérer les objets associés depuis le parent.

Les noms associés

Par défaut, les noms associés sont générés de la même manière que les relations de clé étrangère (classe.name.lower()+'s'), mais vous pouvez également remplacer ce nom en fournissant un argument de nom associé, comme suit:

catégories: Optional[Union[Catégorie, Liste [Catégorie]]] = ormar.ManyToMany(
        Catégorie, through=PostCategory, related_name="new_categories"
    )

!!!avertit que lorsque vous fournissez plusieurs relations au même modèle, sinon vous ne pourrez plus générer automatiquement le nom related_name. dans ce cas, vous devez donc fournir le nom related_name pour tous les champs sauf un (qui peut être par défaut et généré) ou pour tous les champs associés.

Sauter les relations inverses

Si vous êtes sûr de ne pas vouloir une relation inverse, vous pouvez utiliser le drapeau skip_reverse=True de ManyToMany.

Si vous définissez l'attribut skip_reverse en interne, le champ est toujours enregistré à l'autre bout de la relation, vous pouvez donc:

Filtrer par champ de modèle pertinent dans le modèle inverse
order_by Champ de modèle pertinent dans le modèle inverse

Mais vous ne pouvez:

Utiliser related_name pour accéder aux champs pertinents à partir du modèle inverse
Même si vous sélectionnez une relation du côté opposé du modèle, le modèle retourné ne sera pas rempli dans l'instance inverse (les connexions ne seront pas bloquées, vous pouvez donc toujours filtrer et trier les relations).
La relation n'est pas remplie dans modèle_dump() et json(). Lorsque* est rempli à partir d'un dictionnaire ou d'un fichier json (également via fastapi), vous ne pouvez pas passer les objets liés imbriqués. il sera ignoré ou une erreur sera générée en fonction des paramètres supplémentaires dans la configuration pydantique.

Exemples:

Catégorie de classe (modèle ormar):
    ormar_config = base_ormar_config.copy(tablename="catégories")

    id: int = ormar.Integer(primary_key=True)
    name: str = ormar.String(max_length=40)


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

    id: int = ormar.Integer(primary_key=True)
    title: str = ormar.String(max_length=200)
    Catégories: Optional[List[Category]] = ormar.ManyToMany(Category, skip_reverse=True)

#Créer quelques données d'ample
post = await Post.objects.create(titre ="Hello, M2M")
news = await Category.objects.create(name="News")
await post.categories.add(news)

assert post.categories[0] == news # ok
assert news.posts # Attribute Error!

#mais peut être utilisé dans order_by
Catégories = (
    await Category.objects.select_related("posts").order_by("posts__title").all()
)
assert categories[0].first_name == "Test"

# note que les messages ne sont pas populaires pour l'auteur même si explicitement
# included in select_related - note no posts in model_dump()
assert news.model_dump(exclude=){"id"}) == {"name": "News"}

# still peut filtrer à travers les champs de modèles liés
catégories = await Category.objects.filter(posts__title="Hello, M2M").all()
assert categories[0].name == "News"
assert len(catégories) == 1

par Model

Alternativement, si vous souhaitez ajouter des champs supplémentaires, vous pouvez créer et passer explicitement une classe de modèle.

import databases
import ormar
import sqlalchemy

DATABASE_URL = "sqlite:///test.db"

ormar_base_config = ormar.OrmarConfig(
    database=databases.Database(DATABASE_URL), metadata=sqlalchemy.MetaData()
)


class Category(ormar.Model):
    ormar_config = ormar_base_config.copy(tablename="categories")

    id = ormar.Integer(primary_key=True)
    name = ormar.String(max_length=40)


class PostCategory(ormar.Model):
    ormar_config = ormar_base_config.copy(tablename="posts_x_categories")

    id: int = ormar.Integer(primary_key=True)
    sort_order: int = ormar.Integer(nullable=True)
    param_name: str = ormar.String(default="Name", max_length=200)


class Post(ormar.Model):
    ormar_config = ormar_base_config.copy()

    id: int = ormar.Integer(primary_key=True)
    title: str = ormar.String(max_length=200)
    categories = ormar.ManyToMany(Category, through=PostCategory)

!!!Attention, même si vous ne le fournissez pas via un modèle, il est automatiquement créé pour vous et doit tout de même être inclus dans l'exemple de migration alembic.

!!!Note: Si vous souhaitez personnaliser le nom du modèle Through ou le nom de la table de base de données pour ce modèle, vous devez fournir le modèle Through.

Si vous ne fournissez pas le champ « Passer », le système le générera pour vous.

La convention de nommage par défaut est:

Pour un nom de classe, il s'agit d'une union de deux noms de classe (parent + autre), donc dans l'exemple ci-dessus, ce serait PostCategory.
Pour les noms de table, c'est similaire, mais avec un trait inférieur et s à la fin du nom minuscule de la classe, ce qui serait posts_categorys dans l'exemple ci-dessus.

Personnalisation par nom de relation

Par défaut, le nom du modèle associé est par défaut en minuscules via le nom de la relation de modèle.

Dans un exemple comme celui-ci:

... # course déclaration omitted
Classe étudiante (modèle ormar):
    ormar_config = base_ormar_config.copy()

    id: int = ormar.Integer(primary_key=True)
    nom: str = ormar.String(max_length=100)
    courses = ormar.ManyToMany(Course)

#produira le défaut par un modèle comme des follows (exemple simplifié)
classe StudentCourse(modèle. ormar):
    ormar_config = base_ormar_config.copy(tablename="students_courses")

    id: int = ormar.Integer(primary_key=True)
    student = ormar.ForeignKey(Student) #nom par défaut
    course = ormar.ForeignKey(Course) #nom par défaut

Pour personnaliser les noms des champs/relations dans le modèle Through, vous pouvez maintenant utiliser les nouveaux paramètres de ManyToMany:

through_relation_name -nom du champ menant au modèle dans lequel ManyToMany est déclaré
through_reverse_relation_name -Nom du champ menant au modèle auquel ManyToMany mène

Exemples:

... # course déclaration omitted
base_ormar_config = ormar.OrmarConfig(
    database=databases.Database("sqlite:///db.sqlite"),
    metadata=sqlalchemy.MetaData(),
)


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)
    courses = ormar.ManyToMany(Course,
                               through_relation_name="student_id",
                               through_reverse_relation_name="course_id")

#produira à travers des modèles comme des follows (exemple simplifié)
classe StudentCourse(modèle. ormar):
    ormar_config = base_ormar_config.copy(tablename="student_courses")

    id: int = ormar.Integer(primary_key=True)
    student_id = ormar.ForeignKey(Student) # set by through_relation_name
    course_id = ormar.ForeignKey(Course) # set by through_reverse_relation_name

!!!Remarque Notez que la déclaration explicite de relations dans le modèle Through est interdite, donc même si vous fournissez votre propre modèle Through personnalisé, vous ne pouvez pas changer le nom et vous devez utiliser les mêmes arguments through_relation_name et through_reverse_relation_name.

A travers les champs

Les champs de passage sont automatiquement ajoutés au verso de la relation.

Les champs exposés sont nommés en minuscules par le nom de la classe.

Le champ exposé ne charge explicitement aucune relation, car la relation est déjà remplie dans le champ ManyToMany, elle n'est donc utile que si d'autres champs sont fournis sur le modèle Through.

Dans un exemple de configuration de modèle, cela ressemblerait à ceci:

import databases
import ormar
import sqlalchemy

DATABASE_URL = "sqlite:///test.db"

ormar_base_config = ormar.OrmarConfig(
    database=databases.Database(DATABASE_URL), metadata=sqlalchemy.MetaData()
)


class Category(ormar.Model):
    ormar_config = ormar_base_config.copy(tablename="categories")

    id = ormar.Integer(primary_key=True)
    name = ormar.String(max_length=40)


class PostCategory(ormar.Model):
    ormar_config = ormar_base_config.copy(tablename="posts_x_categories")

    id: int = ormar.Integer(primary_key=True)
    sort_order: int = ormar.Integer(nullable=True)
    param_name: str = ormar.String(default="Name", max_length=200)


class Post(ormar.Model):
    ormar_config = ormar_base_config.copy()

    id: int = ormar.Integer(primary_key=True)
    title: str = ormar.String(max_length=200)
    categories = ormar.ManyToMany(Category, through=PostCategory)

Le champ through peut être utilisé comme champ de modèle normal dans la plupart des opérations QuerySet.

Notez que les champs de passage ne sont attachés qu'à l'extrémité pertinente de la requête, donc:

post = await Post.objects.select_related("catégories").get()
#modèle source n'a pas de champ
assert post.postcategory est None
#modèles liés ont traversé le champ
assert post.categories[0].postcategory n'est pas None

# same est applicable aux requêtes inversées
category = await Category.objects.select_related("posts").get()
assert category.postcategory est None
assert category.posts[0].postcategory n'est pas None

Le champ Via peut être utilisé pour filtrer les données.

post = (
        await Post.objects.select_related("catégories")
        .filter(postcategory__sort_order__gt=1)
        .get()
        )

!!!tip Notez que même si l'instance réelle n'est pas remplie dans le modèle source, vous pouvez accéder à travers le modèle des deux côtés dans les requêtes, les instructions order by, etc. Donc la requête suivante a exactement le même effet (notez l'accès par catégorie)

```python
post = (
    await Post.objects.select_related("categories")
    .filter(categories__postcategory__sort_order__gt=1)
    .get()
    )
```

Les requêtes peuvent être utilisées de manière séquentielle via le modèle

post = (
        await Post.objects.select_related("catégories")
        .order_by("-postcategory__sort_order")
        .get()
    )

Vous pouvez également utiliser fields et except_fields pour sélectionner un sous-ensemble de colonnes de la manière habituelle QuerySet.

Post2 = (
        await Post.objects.select_related("catégories")
        .exclude_fields("postcategory__param_name")
        .get() par
        )

Attention: comme through fields invalide explicitement tous les champs relationnels, car les relations sont remplies dans le champ ManyToMany, les méthodes standard du modèle telles que save() et update() ne doivent pas être utilisées tant que les champs n'ont pas été rechargés à partir de la base de données.

Si vous souhaitez modifier le champ de passage sur place, n'oubliez pas de le recharger à partir de la base de données…Sinon, vous définissez la relation sur « Aucun », ce qui rend le champ inutile!

# always recharge le champ avant modification
await post2.categories[0].postcategory.load()
#seulement alors mettre à jour le champ
await post2.categories[0].postcategory.update(sort_order=3)

Notez que le rechargement du modèle recharge effectivement les relations en tant que modèles pk_only (définissant uniquement la clé primaire), de sorte qu 'elles ne sont pas complètement remplies, mais suffisantes pour préserver les relations lorsqu' elles sont mises à jour.

!!!avertit que si vous utilisez ie fastapi, les modèles associés chargés par la partie champ peuvent provoquer une erreur de validation pydantique (ce qui est la principale raison pour laquelle ils ne sont pas remplis par défaut). vous devez donc soit exclure les champs associés de la réponse, soit charger complètement les modèles associés. dans l'exemple ci-dessus, cela signifie:python await post2.categories[0].postcategory.post.load() await post2.categories[0].postcategory.category.load() ou, vous pouvez utiliser load_all():python await post2.categories[0].postcategory.load_all()

La méthode de mise à jour préférée est via la méthode queryset proxy update().

# filter le modèle désiré lié à travers le champ et mettre à jour uniquement à travers les params de champ
await post2.categories.filter(nom ='Test category').update(postcategory={"sort_order": 3})

La loi relationnelle

Ajouter à

Ajouter (projet: modèle,**kwargs)

Permet d'ajouter des modèles à une relation plusieurs-à-plusieurs.

#Ajouter une catégorie à un post.
await post.categories.add(news)
#ou de l'autre fin:
await news.posts.add(post)

!!!Dans tous les cas non None, la valeur de clé primaire du modèle associé doit exister dans la base de données.

Otherwise Une erreur d'intégralité sera traitée par votre bibliothèque de pilotes de base.

Si vous déclarez un modèle à l'aide d'un modèle Through avec des champs supplémentaires, vous pouvez les remplir lors de l'ajout de sous-modèles à la relation.

Pour ce faire, passez un argument de mot-clé avec le nom et la valeur du champ à l'appel add().

Notez que cela ne s'applique qu 'aux relations plusieurs-à-plusieurs.

post = await Post(title="Test post").save()
category = await Category(name="Test category").save()
# apart from model pass arguments referencing through model fields
await post.categories.add(catégorie, sort_order=1, param_name ='test')

Éliminer

Les modèles pertinents sont supprimés un par un.

Supprime également les relations dans la base de données.

1	`await news.posts.remove(post)`

Clear à

Un seul appel supprime tous les modèles associés.

Supprime également les relations dans la base de données.

En attendant news.posts.clear()

Query Set Agent pour

La relation inverse expose l'API QuerysetProxy, qui vous permet d'interroger les modèles pertinents comme vous le feriez pour une requête normale.

Pour savoir quelles méthodes QuerySet sont disponibles, lisez Querysetproxy ci-dessous.