What does on delete do on Django models

Question

I m quite familiar with Django  but I recently noticed there exists an on delete models CASCADE option with the models  I have searched for the documentation for the same  but I couldn t find anything more than   Changed in Django 1 9  on delete can now be used as the second positional argument  previously it was typically only passed as a keyword argument   It will be a required argument in Django 2 0   An example case of usage is  from django db import models  class Car models Model       manufacturer   models ForeignKey           Manufacturer           on delete models CASCADE                   class Manufacturer models Model                 pass  What does on delete do   I guess the actions to be done if the model is deleted   What does models CASCADE do   any hints in documentation  What other options are available  if my guess is correct   Where does the documentation for this reside

User · Accepted Answer

This is the behaviour to adopt when the referenced object is deleted. It is not specific to Django; this is an SQL standard. Although Django has its own implementation on top of SQL. (1)

There are seven possible actions to take when such event occurs:

CASCADE: When the referenced object is deleted, also delete the objects that have references to it (when you remove a blog post for instance, you might want to delete comments as well). SQL equivalent: CASCADE.
PROTECT: Forbid the deletion of the referenced object. To delete it you will have to delete all objects that reference it manually. SQL equivalent: RESTRICT.
RESTRICT: (introduced in Django 3.1) Similar behavior as PROTECT that matches SQL's RESTRICT more accurately. (See django documentation example)
SET_NULL: Set the reference to NULL (requires the field to be nullable). For instance, when you delete a User, you might want to keep the comments he posted on blog posts, but say it was posted by an anonymous (or deleted) user. SQL equivalent: SET NULL.
SET_DEFAULT: Set the default value. SQL equivalent: SET DEFAULT.
SET(...): Set a given value. This one is not part of the SQL standard and is entirely handled by Django.
DO_NOTHING: Probably a very bad idea since this would create integrity issues in your database (referencing an object that actually doesn't exist). SQL equivalent: NO ACTION. (2)

Source: Django documentation

See also the documentation of PostgreSQL for instance.

In most cases, CASCADE is the expected behaviour, but for every ForeignKey, you should always ask yourself what is the expected behaviour in this situation. PROTECT and SET_NULL are often useful. Setting CASCADE where it should not, can potentially delete all of your database in cascade, by simply deleting a single user.

Additional note to clarify cascade direction

It's funny to notice that the direction of the CASCADE action is not clear to many people. Actually, it's funny to notice that only the CASCADE action is not clear. I understand the cascade behavior might be confusing, however you must think that it is the same direction as any other action. Thus, if you feel that CASCADE direction is not clear to you, it actually means that on_delete behavior is not clear to you.

In your database, a foreign key is basically represented by an integer field which value is the primary key of the foreign object. Let's say you have an entry comment_A, which has a foreign key to an entry article_B. If you delete the entry comment_A, everything is fine. article_B used to live without comment_A and don't bother if it's deleted. However, if you delete article_B, then comment_A panics! It never lived without article_B and needs it, and it's part of its attributes (article=article_B, but what is article_B???). This is where on_delete steps in, to determine how to resolve this integrity error, either by saying:

"No! Please! Don't! I can't live without you!" (which is said PROTECT or RESTRICT in Django/SQL)
"All right, if I'm not yours, then I'm nobody's" (which is said SET_NULL)
"Good bye world, I can't live without article_B" and commit suicide (this is the CASCADE behavior).
"It's OK, I've got spare lover, and I'll reference article_C from now" (SET_DEFAULT, or even SET(...)).
"I can't face reality, and I'll keep calling your name even if that's the only thing left to me!" (DO_NOTHING)

I hope it makes cascade direction clearer. :)

Footnotes

(1) Django has its own implementation on top of SQL. And, as mentioned by @JoeMjr2 in the comments below, Django will not create the SQL constraints. If you want the constraints to be ensured by your database (for instance, if your database is used by another application, or if you hang in the database console from time to time), you might want to set the related constraints manually yourself. There is an open ticket to add support for database-level on delete constrains in Django.

(2) Actually, there is one case where DO_NOTHING can be useful: If you want to skip Django's implementation and implement the constraint yourself at the database-level.

User · Answer

Using CASCADE means actually telling Django to delete the referenced record  In the poll app example below  When a  Question  gets deleted it will also delete the Choices this Question has  e g Question  How did you hear about us   Choices  1  Friends 2  TV Ad 3  Search Engine 4  Email Promotion  When you delete this question  it will also delete all these four choices from the table  Note that which direction it flows  You don t have to put on delete models CASCADE in Question Model put it in the Choice  from django db import models  class Question models Model       question text   models CharField max length 200      pub date   models dateTimeField  date published    class Choice models Model       question   models ForeignKey Question  on delete models CASCADE      choice text   models CharField max legth 200      votes   models IntegerField default 0

User · Answer

FYI  the on delete parameter in models is backwards from what it sounds like   You put on delete on a foreign key  FK  on a model to tell Django what to do if the FK entry that you are pointing to on your record is deleted   The options our shop have used the most are PROTECT  CASCADE  and SET NULL  Here are the basic rules I have figured out   Use PROTECT when your FK is pointing to a look-up table that really shouldn t be changing and that certainly should not cause your table to change   If anyone tries to delete an entry on that look-up table  PROTECT prevents them from deleting it if it is tied to any records   It also prevents Django from deleting your record just because it deleted an entry on a look-up table   This last part is critical   If someone were to delete the gender  quot Female quot  from my Gender table  I CERTAINLY would NOT want that to instantly delete any and all people I had in my Person table who had that gender  Use CASCADE when your FK is pointing to a  quot parent quot  record   So  if a Person can have many PersonEthnicity entries  he she can be American Indian  Black  and White   and that Person is deleted  I really would want any  quot child quot  PersonEthnicity entries to be deleted   They are irrelevant without the Person  Use SET NULL when you do want people to be allowed to delete an entry on a look-up table  but you still want to preserve your record   For example  if a Person can have a HighSchool  but it doesn t really matter to me if that high-school goes away on my look-up table  I would say on delete SET NULL   This would leave my Person record out there  it just would just set the high-school FK on my Person to null   Obviously  you will have to allow null True on that FK   Here is an example of a model that does all three things  class PurchPurchaseAccount models Model       id   models AutoField primary key True      purchase   models ForeignKey PurchPurchase  null True  db column  purchase   blank True  on delete models CASCADE    If  quot parent quot  rec gone  delete  quot child quot  rec        paid from acct   models ForeignKey PurchPaidFromAcct  null True  db column  paid from acct   blank True  on delete models PROTECT    Disallow lookup deletion  amp  do not delete this rec       updated   models DateTimeField        updatedby   models ForeignKey Person  null True  db column   updatedby   blank True  related name  acctupdated by   on delete models SET NULL    Person records shouldn t be deleted  but if they are  preserve this PurchPurchaseAccount entry  and just set this person to null       def   unicode   self           return str self paid from acct display      class Meta          db table   u purch purchase account   As a last tidbit  did you know that if you don t specify on delete  or didn t   the default behavior is CASCADE   This means that if someone deleted a gender entry on your Gender table  any Person records with that gender were also deleted  I would say   quot If in doubt  set on delete models PROTECT  quot   Then go test your application   You will quickly figure out which FKs should be labeled the other values without endangering any of your data  Also  it is worth noting that on delete CASCADE is actually not added to any of your migrations  if that is the behavior you are selecting   I guess this is because it is the default  so putting on delete CASCADE is the same thing as putting nothing

User · Answer

Here is answer for your question that says  why we use on delete   When an object referenced by a ForeignKey is deleted  Django by default emulates the behavior of the SQL constraint ON DELETE CASCADE and also deletes the object containing the ForeignKey  This behavior can be overridden by specifying the on delete argument  For example  if you have a nullable ForeignKey and you want it to be set null when the referenced object is deleted   user   models ForeignKey User  blank True  null True  on delete models SET NULL    The possible values for on delete are found in django db models   CASCADE  Cascade deletes  the default   PROTECT  Prevent deletion of the referenced object by raising ProtectedError  a subclass of django db IntegrityError   SET NULL  Set the ForeignKey null  this is only possible if null is True   SET DEFAULT  Set the ForeignKey to its default value  a default for the ForeignKey must be set

User · Answer

As mentioned earlier  CASCADE will delete the record that has a foreign key and references another object that was deleted  So for example if you have a real estate website and have a Property that references a City   class City models Model         define model fields for a city  class Property models Model       city   models ForeignKey City  on delete   models CASCADE        define model fields for a property   and now when the City is deleted from the database  all associated Properties  eg  real estate located in that city  will also be deleted from the database  Now I also want to mention the merit of other options  such as SET NULL or SET DEFAULT or even DO NOTHING  Basically  from the administration perspective  you want to  delete  those records  But you don t really want them to disappear  For many reasons  Someone might have deleted it accidentally  or for auditing and monitoring  And plain reporting  So it can be a way to  disconnect  the property from a City  Again  it will depend on how your application is written   For example  some applications have a field  deleted  which is 0 or 1  And all their searches and list views etc  anything that can appear in reports or anywhere the user can access it from the front end  exclude anything that is deleted    1  However  if you create a custom report or a custom query to pull down a list of records that were deleted and even more so to see when it was last modified  another field  and by whom  i e  who deleted it and when   that is very advantageous from the executive standpoint   And don t forget that you can revert accidental deletions as simple as deleted   0 for those records   My point is  if there is a functionality  there is always a reason behind it  Not always a good reason  But a reason  And often a good one too

User · Answer

Reorient your mental model of the functionality of  quot CASCADE quot  by thinking of adding a FK to an already existing cascade  i e  a waterfall   The source of this waterfall is a primary key  PK   Deletes flow down  So if you define a FK s on delete as  quot CASCADE  quot  you re adding this FK s record to a cascade of deletes originating from the PK  The FK s record may participate in this cascade or not   quot SET NULL quot    In fact  a record with a FK may even prevent the flow of the deletes  Build a dam with  quot PROTECT  quot

User · Answer

CASCADE will also delete the corresponding field connected with it

User · Answer

Deletes all child fields in the database then we use on delete as so  class user models Model    commodities   models ForeignKey commodity  on delete models CASCADE

User · Answer

The on delete method is used to tell Django what to do with model instances that depend on the model instance you delete   e g  a ForeignKey relationship   The on delete models CASCADE tells Django to cascade the deleting effect i e  continue deleting the dependent models as well    Here s a more concrete example  Assume you have an Author model that is a ForeignKey in a Book model  Now  if you delete an instance of the Author model  Django would not know what to do with instances of the Book model that depend on that instance of Author model  The on delete method tells Django what to do in that case  Setting on delete models CASCADE will instruct Django to cascade the deleting effect i e  delete all the Book model instances that depend on the Author model instance you deleted   Note  on delete will become a required argument in Django 2 0  In older versions it defaults to CASCADE   Here s the entire official documentation

User · Answer

Let s say you have two models  one named Person and another one named Companies   By definition  one person can create more than one company    Considering a company can have one and only one person  we want that when a person is deleted that all the companies associated with that person also be deleted   So  we start by creating a Person model  like this  class Person models Model       id   models IntegerField primary key True      name   models CharField max length 20       def   str   self           return self id self name   Then  the Companies model can look like this  class Companies models Model       title   models CharField max length 20      description models CharField max length 10      person  models ForeignKey Person related name  persons  on delete models CASCADE    Notice the usage of on delete models CASCADE in the model Companies  That is to delete all companies when the person that owns it  instance of class Person  is deleted

[python] What does on_delete do on Django models?

Examples related to python

Examples related to django

Examples related to django-models