Django ORM

Django is a Python web framework that enables easy and quick web development. Django has a handy and powerful feature called Django Object Relational Mapper, also known as Django ORM, which helps us to query or retrieve databases much like SQL or MongoDb. It is mainly used to communicate between the relational database and the user application. The ORM is automated, so the user does not have to write any SQL.

ORM has many advantages, some of which are

• It provides speedy development
• It is easier to change the database from ORM
• It resolves the issue of learning the different SQL for every database

Since web development needs many technologies, it is hard for a developer to learn everything, especially SQL, since it can become very complicated sometimes. ORM solves this issue by creating a database schema from different classes. It saves the user from writing code in many different databases like SQL, PostgreSQL and lets him write code in the only language, i.e., Python.

To demonstrate first, we have to make a Django model:

from Django. db import models
 
 class Student(models.Model):
  name = models.CharField(max_length=100)
    class = models.CharField(max_length = 100)
 
   def __str__(self):
     return self.name
 
 class Project(models.Model):
  title = models.CharField(max_length=100)
  concept = models.CharField(max_length=100)
    author = models.ManyToManyField(Student, related_name="projects")
 
 
   def __str__(self):
     return self.title

We have created two models, Student, and Project. Both have two fields inside them.

The Student has a name and class field, while Project has a title and concept. It also has an author field which is a Many to Many Field that links Project and Student.

To access the Django ORM run the following command in the project library:

python manage.py shell

It opens a console, and now we have to import our model here to use it

For that write:

from blog. models import *

Now let’s start by adding an object to our model.

To create and save and object use the command below:

obj = Student(name = "Rahul", class= "eleventh")
obj.save()

In this, we created a Student object, now to create a Project object, we have to write.

Obj1 = Project(title = “relative motion”, concept = “relativity theory”,author = “Gaurav”)
Obj1.save()

Let us add some more Student objects for demonstration purpose

obj = Student(name = "Mudit", class= "eleventh")
obj.save()
obj = Student(name = "Gaurav", class= "twelfth")
obj.save()

After adding the object, the task is to retrieve them, and this can be done by using objects.all() function

Let’s retrieve the list of all students

Student.objects.all()

It fetch a Queryset of results that lists all the Student

<QuerySet [<Student: Rahul>, <Student: Mudit>, <Student: Gaurav>]>

We can also fetch a single query instead of all by using utility functions like getting (), filter() for that we need a primary key. In this case, we will use the class, but many students are in the same class, so it is not advisable to do so. What we should do is to have an ID for every record.

Student.objects.get(class="twelfth")
<QuerySet [<Student: Gaurav>]>

We can also use the filter function

Student.objects.filter(filter="Rahul")
<QuerySet [<Student: Rahul>]>

To get an interactable python object we can use:

Std = Student.objects.get(class="twelfth")
Std.name
U “Gaurav “

Now we can get all the projects made by this Student to check what projects our Students have made.

Std.projects.all()
<QuerySet[<Project: “Relative motion”>, …… ]>

Modifying Objects

We can also modify an object using ORM as shown

Obj = Student.objects.get(class = “twelfth”)
Obj.name = “Rohan”
Obj.save()

Deleting Objects

To delete an Object we can write:

Obj = Student.objects.get(class = “eleventh”)
Obj.delete()
Student.objects.all() <QuerySet[<Student: Rohan>]>