Fonction du paramètre On_delete dans les modèles Django

1. Argument CASCADE
2. Argument PROTECT
3. Argument RESTRICT
4. Argument SET_NULL
5. Argument SET_DEFAULT
6. Argument SET()
7. Argument DO_NOTHING

Les modèles Django simplifient la création de bases de données et de tables, en ajoutant de nouvelles données ou de nouveaux tuples aux tables, en les supprimant, en les récupérant et en les modifiant. Avec les modèles Django, nous pouvons facilement établir des relations entre les tables à l’aide de clés étrangères.

Lors de la configuration des relations, nous devons définir des valeurs pour quelques paramètres. L’un de ces paramètres est le on_delete. Le paramètre on_delete permet de configurer le comportement à adopter lors de la suppression d’un objet référencé. Il est essentiellement utilisé pour définir comment seront traités les effets de la suppression d’un objet référencé.

Il existe sept comportements ou actions possibles pour lesquels le paramètre on_delete peut être configuré. Nous parlerons de chacun d’eux individuellement.

Argument CASCADE

Le comportement en cascade est généralement utilisé lors de la configuration des relations entre les modèles. Lorsqu’un objet référencé est supprimé, tous les objets référençant cet objet référencé seront également supprimés.

Syntaxe

XYZ = models.ForeignKey(WASD, on_delete=models.CASCADE)

Pour le comprendre un peu mieux, considérons l’exemple suivant. Notez que le même exemple sera également utilisé pour expliquer d’autres comportements.

Il existe un site Web où les auteurs peuvent s’inscrire et écrire des blogs sur le site Web. Maintenant, pour représenter les deux entités, considérons deux modèles, à savoir Author et Blog. Toutes les entrées ou tuples dans Blog ont une référence de clé étrangère (ou font référence) à une entrée ou à un tuple Author. Il représente une relation que chaque blog est jamais écrit appartient à un auteur qui l’a écrit.

Maintenant, disons que le site Web a une politique selon laquelle si un auteur supprime son compte, tous les blogs qu’il a écrits seront supprimés. Dans un tel scénario, une relation en cascade sera un choix judicieux.

Argument PROTECT

L’argument PROTECT empêche la suppression de l’objet référencé s’il existe des objets référençant cet objet. En d’autres termes, l’objet référencé ne peut pas être supprimé tant que les objets le référençant existent. Les objets de référencement doivent être supprimés manuellement avant de supprimer l’objet référencé. La suppression est empêchée en levant une ProtectedError.

Cette relation peut être utilisée à des endroits où les données sont très importantes et sensibles, et vous ne pouvez pas vous permettre de les perdre avec une gestion appropriée. Ou lorsque les objets de référence sont également utilisés ailleurs et qu’ils ne peuvent pas être supprimés sans une validation et une gestion appropriées.

Argument RESTRICT

RESTRICT est similaire à PROTECT. Il empêche également la suppression des objets référencés et génère une RestrictedError. Mais il y a une légère différence entre les deux. Contrairement à PROTECT, si l’objet référencé fait référence à un autre objet est une relation CASCADE et qu’il est également supprimé, alors la suppression est autorisée. En d’autres termes, la suppression de l’objet référencé est autorisée si les objets de référence et l’objet référencé font référence à un autre objet commun dans une relation CASCADE.

Considérez l’exemple suivant.

class Artist(models.Model):
    name = models.CharField(max_length=100)


class Album(models.Model):
    artist = models.ForeignKey(Artist, on_delete=models.CASCADE)


class Song(models.Model):
    artist = models.ForeignKey(Artist, on_delete=models.CASCADE)
    album = models.ForeignKey(Album, on_delete=models.RESTRICT)

Si nous essayons de supprimer un objet Album, RestrictedError sera déclenché. Mais si on essaie de supprimer un objet Artist, alors la suppression sera réussie, étant donné que les chansons référençant un objet Album font également référence à l’objet Artist référencé par l’objet Album dans une relationship CASCADE.

Argument SET_NULL

Dans le cas de SET_NULL, comme son nom l’indique, lorsqu’un objet référencé est supprimé, alors l’objet référencé pour tous les objets de référencement est mis à NULL. Cette relation nécessite que le champ d’objet référencé soit Nullable.

XYZ = models.ForeignKey(WASD, on_delete=models.SET_NULL, null=True)

Par exemple, si le site Web a une politique selon laquelle si un auteur quitte, alors ses blogs ne seront pas mais supprimés. Au lieu de cela, l’auteur de tous les blogs sera défini sur un auteur anonyme ou None.

Argument SET_DEFAULT

Dans le cas de SET_DEFAULT, lorsqu’un objet référencé est supprimé, alors l’objet référencé pour tous les objets référencés est mis à une valeur par défaut. Cette valeur par défaut peut NULL ainsi qu’un autre modèle ou table Django. Cette relation nécessite que le champ objet référencé soit nullable dans le cas de NULL.

XYZ = models.ForeignKey(WASD, on_delete=models.SET_DEFAULT, null=True, default=QWERTY)

Par exemple, si le site Web a une politique selon laquelle si un auteur part, alors l’auteur de tous ses blogs sera l’administrateur ou l’entreprise elle-même. Dans de tels cas, SET_DEFAULT serait le bon choix.

Argument SET()

SET() est exactement le même que celui de SET_DEFAULT. Il peut également accepter des modèles ou des tables Django. La seule différence est que dans SET(), nous pouvons passer un callable, qui sera appelé pour tous les objets référencés si l’objet référencé est supprimé.

XYZ = models.ForeignKey(WASD, on_delete=models.SET(...), null=True)

La fonction appelable, avec un modèle, ressemblerait à ceci.

def getUser():
    """Callable function"""
    return User.objects.get_or_create(username="anonymous")[0]


class Author(models.Model):
    user = models.ForeignKey(User, on_delete=models.SET(getUser))

Argument DO_NOTHING

DO_NOTHING est une relation un peu risquée qui peut exister entre deux modèles. Comme son nom l’indique, lorsqu’un objet référencé est supprimé, l’objet référencé ne sera pas modifié pour tous les objets référencés. En d’autres termes, rien ne sera fait pour gérer les effets de la suppression.

Il s’agit d’un comportement très risqué car il peut entraîner des problèmes d’intégrité car l’objet référencé est supprimé, mais les objets de référence le font toujours.

XYZ = models.ForeignKey(WASD, on_delete=models.DO_NOTHING)