2. Querysets in Django<\/p>\n
3. Different Relationships between Fields<\/p>\n
- \n
- One to One Relationship<\/li>\n
- One to Many Relationships<\/li>\n
- Many to Many Relationships<\/li>\n<\/ul>\n
4. Conclusion<\/p>\n
- \n
- The Problems with Django ORM<\/li>\n<\/ul>\n
Django ORM Tutorial<\/h2>\n
1. What is an ORM?<\/h3>\n
ORM is an acronym for the object-relational mapper<\/strong>. The ORM\u2019s main goal is to transmit data between a relational database and application model. The ORM automates this transmission, such that the developer need not write any SQL.<\/p>\n
ORM, as from the name, maps objects attributes to respective table fields. It can also retrieve data in that manner.<\/p>\n
This makes the whole development process fast and error-free.<\/p>\n
![\"Django](\"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2019\/09\/Django-ORM-Tutorial.jpg\")
<\/a><\/p>\nIn the above image, we have some Python objects<\/strong><\/em><\/a> and a table with corresponding fields. The object\u2019s attributes are stored in corresponding fields automatically. An ORM will automatically create and store your object data in the database. You don\u2019t have to write any SQL for the same.<\/p>\n
The Problem Solved by ORM<\/h3>\n
ORMs have certain benefits over the traditional approach. The main advantage ORMs provide is rapid development. ORMs make project more portable. It is easier to change the database if we use ORMs.<\/p>\n
![\"django](\"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2019\/09\/django-ORM-vs-SQL.png\")
<\/a><\/p>\nIn the past, web developers needed to have knowledge of databases too. A database has been an important component from the start. The programming languages used for web development use classes and object for data-interpretation. The class is used to a defined data structure in web-applications. Then the same database schema is created in the database. This task requires skill and knowledge of SQL.<\/p>\n
Knowing SQL is also not enough since SQL implementations slightly differ from one another in different databases. This became a difficult and time-consuming task. So, to resolve this, the concept of ORM was introduced in web frameworks. ORMs automatically create a database schema from defined classes\/ models. They generate SQL from Python code<\/a><\/strong><\/em> for a particular database. ORMs let the developer build the project in one language that means Python.<\/p>\n
This increased the popularity of ORMs and web-frameworks. There are different ORMs available in the market but one of the best is Django ORM.<\/p>\n
![\"different](\"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2019\/09\/different-orm-connectors-editing.png\")
<\/a><\/p>\nNot only ORMs, but there are also multiple Python Connectors for databases available. These ORMs use connectors to connect databases with a web application. you have to install the connector of a specific database you want to work with. We will be working with MySQL databases.<\/p>\n
Introduction to Django ORM<\/h2>\n
Django is shipped with its own ORM. It is a very efficient ORM and is tightly coupled with the Django framework. Django ORM is suitable for handling low-medium complexity queries. Although, some consider SQLAlchemy ORM<\/strong> to be a better option. The migrations feature by Django<\/strong><\/em><\/a> is also a part of Django ORM. The ORM has many benefits engulfing those of migrations and Querysets. Django is the only framework which is complete in itself.<\/p>\n
Is it necessary to use ORM?<\/h3>\n
This is totally a developer\u2019s choice. Although there are certain benefits of ORM, there are some downsides too. It is beneficial for developers as it allows faster development. Sometimes ORMs generate more complex queries then they should. This can result in a performance decrease. Therefore, it is totally the developer\u2019s choice and the level of work they are doing. For example –<\/strong> Django ORM is efficient for working with low-medium complexity models.<\/p>\n
Django ORM vs SQLAlchemy?<\/h3>\n
In most cases, people prefer SQLAlchemy over Django ORM. The reason being SQLAlchemy is more adept to work with high-complexity data structures. Django ORM is powerful in its own way. The ORM provides features integrated with Django which are more important than just performance improvement.<\/p>\n
Currently, Django ORM is not swappable with SQLAlchemy. There are some hacks to do it but it’s unofficial. Django\u2019s future releases are expected to provide this functionality. Also, both SQLAlchemy and Django ORM is actively developed.<\/p>\n
So, there is no clear winner and it totally depends on the type of project you are working on.<\/p>\n
2. Querysets in Django<\/h3>\n
We all use queries to retrieve data from the database. Querysets are Django\u2019s way to retrieve data from the database. The Django ORM lets us use Querysets.<\/p>\n
A Queryset is a list of objects of a model. We use Querysets to filter and arrange our data. These make our work as a Python developer easier.<\/p>\n
We will be practicing different implementations of Querysets. We have discussed most of them in our previous articles. So, you can check them out from DataFlair’s Django Tutorial Series<\/a><\/strong><\/em>. Querysets are generally associated with CRUD applications. We will be discussing that in a separate tutorial.<\/p>\n
In this tutorial, we will be focusing more on Django ORM.<\/p>\n
Different Relationships between Fields<\/h3>\n
Django ORM provides a level of abstraction which makes it easy to work with objects. ORM will automatically relate the object\u2019s attributes to corresponding table fields. We are going to make some models and check their field relationships in other tables.<\/p>\n
It is expected that you can make models and applications. This Django ORM tutorial is an advanced concept and basics of Django is a prerequisite.<\/p>\n
Now, you can create models by pasting the code in models.py of your application. Let\u2019s get started.<\/p>\n
1. One to One Relationship<\/h4>\n
A one-to-one relationship exists between two tables. For each row in table1, there shall be a row\/ entity in table2.<\/p>\n
Let\u2019s understand it with an example.<\/p>\n
![\"one](\"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2019\/09\/one-to-one-relationship.png\")
<\/a><\/p>\nThere are two tables here, Customer and Vehicle. Every customer owns only one vehicle. Thus, a one-to-one relationship exists. Now, paste this code in models.py to implement this.<\/p>\n
Code:<\/strong><\/p>\n
from django.db import models\r\n\r\n#DataFlair #DjangoTutorials\r\n# Create your models here.\r\nclass Customer(models.Model):\r\n name = models.CharField(max_length=255)\r\n\r\nclass Vehicle(models.Model):\r\n name = models.CharField(max_length=255)\r\n customer = models.OneToOneField(\r\n Customer,\r\n on_delete=models.CASCADE,\r\n related_name='vehicle'\r\n )<\/pre>\n
Code Display:<\/strong><\/p>\n
![\"One](\"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2019\/09\/One-to-One-Relationship-Model-Code-1.png\")
<\/a><\/p>\nNow, we will register these models with admin to populate them.<\/p>\n
![\"register](\"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2019\/09\/register-models-with-admin.png\")
<\/a><\/p>\nNow, create some objects from the Django Admin. First, make some owner objects. It will show a dropdown list of Customer objects in Vehicle.<\/p>\n
![\"Dropdown](\"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2019\/09\/Customer-objects-in-Vehicles.png\")
<\/a><\/p>\nNow, after adding some objects we will check the database.<\/p>\n
![\"Customer](\"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2019\/09\/Customer-table.png\")
<\/a>Customer Table<\/p><\/div>\n
![\"Vehicle](\"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2019\/09\/Vehicle-Table.png\")
<\/a>Vehicle Table<\/p><\/div>\n
Now, just focus on Vehicle Table. You can see that it stores the Customer ID which is the same field as ID in the Customer table. This is a one-to-one relationship. Let\u2019s see the SQL<\/a><\/strong><\/em> we would have to write for the same task.<\/p>\n
![\"Complex](\"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2019\/09\/Complex-SQL.png\")
<\/a><\/p>\nThat is some complex SQL. Django ORM saves us a lot from writing this code and syncing our models. Check out the DataFlair’s\u00a0Django Migrations Tutorial.<\/strong><\/em><\/p>\n
2. One to Many Relationships<\/h4>\n
Just like one to one we can have one-to-many relationships. We are going to use a different model for showcasing this.<\/p>\n
A one to many relationships is where one object from table1 can have multiple relations with entities in table2. Although, table2 objects will have only one relation to the object of table1.<\/p>\n
Let\u2019s understand this from the example:<\/p>\n
![\"one](\"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2019\/09\/one-to-many-relationship.png\")
<\/a><\/p>\nBefore developing this model: please make it in a new application.<\/p>\n
The code<\/strong> for this model is:<\/p>\n
from django.db import models\r\n\r\n#DataFlair #DjangoTutorials\r\n# Create your models here.\r\nclass Customer(models.Model):\r\n name = models.CharField(max_length=255)\r\n\r\nclass Vehicle(models.Model):\r\n name = models.CharField(max_length=255)\r\n customer = models.ForeignKey(\r\n Customer,\r\n on_delete=models.CASCADE,\r\n related_name='Vehicle'\r\n )<\/pre>\n
Code Display:<\/strong><\/p>\n
![\"One](\"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2019\/09\/One-to-Many-relationship.png\")
<\/a><\/p>\nPopulate the models via admin. Once you have created some objects then check the database.<\/p>\n
![\"Customer](\"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2019\/09\/Customer-Table.png\")
<\/a>Customer Table<\/p><\/div>\n
![\"Vehicle](\"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2019\/09\/Vehicle-Table-2.png\")
<\/a>Vehicle Table<\/p><\/div>\n
From this table, we can see that one customer can have more than one vehicle.<\/p>\n
3. Many to Many Relationships<\/h4>\n
We can also implement many to many relations in the database. In this case, we are taking examples of multiple drivers.<\/p>\n
![\"many](\"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2019\/09\/many-to-many-relationship.png\")
<\/a><\/p>\nHere we have multiple workers for multiple machines. A worker can be assigned to operate more than one machine. Also, a machine can be operated by multiple workers one at a time.<\/p>\n
To implement the same in model, paste this code in models.py<\/strong>:<\/p>\n
from django.db import models\r\n\r\n# Create your models here.\r\n#DataFlair #Many to Many Relationship\r\nclass Worker(models.Model):\r\n name = models.CharField(max_length=255)\r\n\r\nclass Machine(models.Model):\r\n name = models.CharField(max_length=255)\r\n worker = models.ManyToManyField(\r\n Worker,\r\n related_name='Machine'\r\n )<\/pre>\n
Code Display:<\/strong><\/p>\n
![\"Many](\"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2019\/09\/Many-to-many-relationship.png\")
<\/a><\/p>\nNow, let’s fill some data in them again. We will now inspect the database<\/a>.<\/p>\n
![\"Worker](\"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2019\/09\/Worker-Table.png\")
<\/a>Worker Table<\/p><\/div>\n
![\"Machine](\"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2019\/09\/Machine-Table.png\")
<\/a>Machine Table<\/p><\/div>\n
![\"Many](\"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2019\/09\/Many-to-many-relationship-table.png\")
<\/a>Many to many relationship table<\/p><\/div>\n
This is a special case of relationships. Many to Many Relationship requires a separate table. There they store objects related to other objects.<\/p>\n
These relationships are common for objects and classes. These can be difficult to write with SQL.<\/p>\n
Summary<\/h2>\n
Django ORM and other ORMs are very powerful tools for web-developers. However, there are some issues which cannot be solved by them. ORMs are abstractions and automate a process. There are points where they can generate more complex queries than manual.<\/p>\n
It all depends on the developer and their skill with the corresponding database. On the contrary, the ORM exists only for SQL and RDBMS (Relational database management systems)<\/a><\/strong><\/em>. There are no ORMs for NoSQL databases. So, it depends on your use case and how you perceive the data.<\/p>\n
ORMs have both bad and good sides. Particularly Django ORM is highly favored by web-developers. It’s not very efficient when compared to SQLAlchemy. The deep integration with the Django framework is where it really shines. Also, Django ORM is an abstraction layer. It provides us with features like Querysets and migrations and these relations.<\/p>\n
- The Problems with Django ORM<\/li>\n<\/ul>\n