How to delete an object in Django

Key takeaways:
Deleting elements from a Django application's database can be done in two different deletion methods while keeping our database consistent.
Hard delete: Suitable for permanently deleting specific objects from the database.
Soft delete: Good for eliminating records in a way that keeps them in the database while making them unavailable to users.
For hard delete, use the delete() function directly and for soft delete, create a custom base model with an is_deleted flag.

Django is an open-source web framework based on Python that enables the rapid development of database-driven applications by offering a clean and organized structure. It simplifies the implementation of repetitive tasks, freeing developers to concentrate on application logic rather than dealing with unnecessary boilerplate code. Through Django’s robust Object-Relational Mapping (ORM) system, developers can efficiently perform operations such as inserting, updating, and deleting data in the connected database. The ORM translates Python code into SQL queries, abstracting the underlying database interactions.

Deleting an element from a Django application’s database can be risky. This Answer will guide readers on implementing two different deletions while our database remains consistent.

Two different deletions are:

Hard delete
Soft delete

Hard delete

Hard deletion is the procedure of permanently removing particular objects from the database. For this purpose, the delete() function of the object’s class is invoked to delete an object. This results in the object being deleted from the database with no possibility of recovery.

Pros of hard delete

It’s easy to implement. There is no need to keep track of deleted records. It may reduce the database size.

Cons of hard delete

Retrieving deleted data becomes impossible. Executing a delete() command for hard deletion tends to be slower, especially with interconnected records across tables.

Implementation of hard delete

Let's start with creating the Django application. For this purpose, the following commands will create a Django project in first_project directory; then, we will create a new Django application name first_app to implement the delete functionality.

# create_students.py
import os
import sys
import django
# Set up Django environment
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'first_project.settings')
django.setup()
# Import the Student model
from first_app.models import Student
def main():
    # Create Student objects and set their attributes
    student1 = Student(first_name='Alice', last_name='Zoe', email='alice.zoe@example.com', roll_no='SE_123', degree='SE')
    student2 = Student(first_name='Tom', last_name='Smith', email='tom.smith@example.com', roll_no='CS_123', degree='CS')
    student3 = Student(first_name='Bethy', last_name='Gorden', email='bethy.gorden@example.com', roll_no='CS_456', degree='CS')
    # Save the Student objects to the database
    student1.save()
    student2.save()
    student3.save()
    print("Students created successfully.")
# Call the main function
if __name__ == "__main__":
    main()

create_students.py

# delete_students.py
import os
import sys
import django
# Set up Django environment
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'first_project.settings')
django.setup()
# Import the Student model
from first_app.models import Student
def main():
    # Fetch all students from the database
    all_students = Student.objects.all()
    # Check if there are students
    if all_students.exists():
        # Get the second student
        second_student = all_students[1]
        # Delete the second student permanently
        second_student.delete()
        print("Second student deleted successfully.")
    else:
        print("No students found in the database.")
# Call the main function
if __name__ == "__main__":
    main()

delete_students.py

After execution of create_students.py, it will create three students into the database, while after execution of the delete_students.py , the second Student from the database will be deleted.

Note: Make sure to execute the above commands after pressing the Run button, every time you update the code and want to re-run it.

Delete by filter

We can also delete objects in bulk. Every QuerySetIt is a collection of database queries that can be filtered, sliced, and manipulated to retrieve data from the database. has a delete() method which deletes all members of that QuerySet.

For example, the following code will delete all Student objects with a degree of “CS”.

# delete_students.py
import os
import sys
import django
# Set up Django environment
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'first_project.settings.py')
django.setup()
# Import the Student model
from first_app.models import Student
def main():
    # Fetch all students from the database
    all_students = Student.objects.all()
    # Filter students with 'CS' degree and delete them
    deleted_students_count, deleted_students_info = all_students.filter(degree='CS').delete()
    #output will be look like this
    #(2, {'first_app.Student': 2})
    #The first value 2 indicates that 2 students were deleted, and the dictionary {first_app.Student: 2}
    #specifies that both deletions belonged to the Student model in the first_app application.
    print(f"Deleted {deleted_students_count} students.")
    print(f"Deletions info: {deleted_students_info}")
# Call the main function
if __name__ == "__main__":
    main()

delete_students.py for deletion by filter

Soft delete

Soft deletion is the process of eliminating records in a way that keeps them in the database while making them unavailable to the user. This is done using a flag to mark the record as unavailable rather than completely deleting it from the database.

Pros of soft delete

The main benefit of soft delete is that it lets you get back data that was deleted by mistake. It also puts less pressure on the server because the data isn't really removed, just marked as deleted by changing a field.

Cons of soft delete

It may increase the database size as time passes, potentially causing performance problems as it expands. It also added the complexity of sorting out records marked as deleted.

Implementation of soft delete

We need to create BaseModel class, a custom model class that serves as a base or abstract class for other models in our application. It is common practice in Django to create a base model with commonly used fields or methods and then have other models inherited from this base model in our application.