Why ORM maps Python to database in Django - Visual Breakdown

Concept Flow - Why ORM maps Python to database

Define Python class

↓

ORM reads class

↓

Create database table

↓

Create Python object instance

↓

ORM converts object to SQL INSERT

↓

Data saved in database

↓

Query database with ORM

↓

ORM converts SQL result to Python objects

This flow shows how ORM takes Python classes and objects, turns them into database tables and rows, and back again, so you work only in Python.

Execution Sample

Django

from django.db import models

class Book(models.Model):
    title = models.CharField(max_length=100)

book = Book(title='My Book')
book.save()

Defines a Book class, creates an instance, and saves it to the database using ORM.

Execution Table

Step	Action	Python State	Database Action	Result
1	Define Book class	Book class with title field	No DB action yet	Class ready for ORM
2	Create Book instance	book.title = 'My Book'	No DB action yet	Object created in memory
3	Call book.save()	book object	Generate SQL INSERT	Prepare to save data
4	Execute SQL INSERT	book object	Insert row into book table	Data saved in DB
5	Query book table	No Python object yet	Generate SQL SELECT	Fetch data from DB
6	ORM converts result	Create Book objects from rows	No DB action	Python objects ready

💡 All Python objects are synced with database rows via ORM mapping

Variable Tracker

Variable	Start	After Step 2	After Step 4	After Step 6
Book class	Defined	Defined	Defined	Defined
book instance	None	title='My Book'	title='My Book'	title='My Book'
Database rows	Empty	Empty	One row with title='My Book'	One row with title='My Book'

Key Moments - 2 Insights

Why don't we write SQL directly when using ORM?

Because ORM automatically converts Python objects to SQL commands, so you can work only in Python as shown in steps 3 and 4 of the execution_table.

How does ORM know what database table to use?

ORM reads the Python class definition (step 1) and creates or uses a matching database table, linking class fields to table columns.

Visual Quiz - 3 Questions

Look at the execution_table, what happens at step 4?

A SQL INSERT command runs to save data

B Python object is deleted

C Python creates a new class

D Database table is dropped

💡 Hint

Check the 'Database Action' column at step 4 in execution_table

At which step does ORM convert database rows back to Python objects?

A Step 2

B Step 4

C Step 6

D Step 1

💡 Hint

Look at the 'Result' column for step 6 in execution_table

If you change the Book class fields, what part of the flow changes?

A Step 3 only

B Step 1 and database table structure

C Step 5 only

D No change at all

💡 Hint

Refer to concept_flow where class definition affects database table creation

Concept Snapshot

ORM maps Python classes to database tables.
You define models as Python classes.
ORM creates tables and columns automatically.
Saving objects runs SQL INSERT behind scenes.
Querying returns Python objects, not raw SQL.
This lets you work only in Python, no SQL needed.

Full Transcript

ORM stands for Object-Relational Mapping. It connects Python code to the database. First, you define a Python class representing your data. The ORM reads this class and creates a matching database table. When you create an object of this class and save it, ORM converts it into an SQL INSERT command to store data in the database. Later, when you query the database, ORM converts the SQL results back into Python objects. This way, you only write Python code and ORM handles the database communication for you.

Practice

1. Why does Django use an ORM to map Python classes to database tables?

easy

A. To prevent any changes to the database structure

B. To make the database run faster by skipping Python

C. To force developers to write raw SQL queries

D. To let developers work with databases using Python code instead of SQL

Solution

1. Step 1: Understand ORM purpose

   ORM stands for Object-Relational Mapping, which connects Python objects to database tables.

2. Step 2: Identify why mapping is useful

   This allows developers to use Python code to create, read, update, and delete data without writing SQL.

3. Final Answer:

   To let developers work with databases using Python code instead of SQL -> Option D

4. Quick Check:

   ORM = Python code for database [OK]

Hint: ORM means use Python classes, not SQL, for database [OK]

Common Mistakes:

• Thinking ORM makes database faster by skipping Python
• Believing ORM forces raw SQL writing
• Assuming ORM blocks database changes

2. Which of the following is the correct way to define a Django model field that maps to a database column?

easy

A. name = models.FieldChar(100)

B. name = CharField(max_length=100)

C. name = models.CharField(max_length=100)

D. name = models.Char(100)

Solution

1. Step 1: Recall Django model field syntax

   Django model fields are defined using models.FieldType() with parameters.

2. Step 2: Match correct field type and parameters

   CharField is the correct field for text with a max length, and it requires max_length.

3. Final Answer:

   name = models.CharField(max_length=100) -> Option C

4. Quick Check:

   Correct field syntax = name = models.CharField(max_length=100) [OK]

Hint: Use models.FieldType() with parameters for fields [OK]

Common Mistakes:

• Omitting 'models.' prefix
• Using wrong field class names
• Passing parameters incorrectly

3. Given this Django model and code:

class Book(models.Model):
    title = models.CharField(max_length=50)

book = Book(title='Django Guide')
book.save()
print(Book.objects.count())

What will be printed?

medium

A. 0

B. 1

C. Error because save() is missing arguments

D. The title 'Django Guide'

Solution

1. Step 1: Understand model instance creation and saving

   Creating book with title and calling save() stores it in the database.

2. Step 2: Check what Book.objects.count() does

   This counts how many Book records exist in the database, which is 1 after saving.

3. Final Answer:

   1 -> Option B

4. Quick Check:

   Saved one book, count = 1 [OK]

Hint: save() adds record, count() shows total saved [OK]

Common Mistakes:

• Thinking save() needs arguments
• Confusing count() with printing title
• Assuming count() returns 0 before save

4. What is wrong with this Django model code?

class Author(models.Model):
    name = models.CharField(max_length=50)

author = Author(name='Alice')
author.save(name='Bob')

medium

A. save() method does not accept arguments like name

B. CharField requires max_length to be 100 or more

C. Model class must be named with lowercase

D. You cannot create model instances with parameters

Solution

1. Step 1: Check save() method usage

   The save() method does not take field values as arguments; it saves current instance data.

2. Step 2: Identify correct way to update fields

   To change a field, assign it before calling save(), e.g., author.name = 'Bob'.

3. Final Answer:

   save() method does not accept arguments like name -> Option A

4. Quick Check:

   save() takes no args, just saves instance [OK]

Hint: save() saves instance, does not take field args [OK]

Common Mistakes:

• Passing fields to save() method
• Thinking max_length must be >=100
• Naming model classes lowercase

5. You want to update all books with title 'Old Title' to 'New Title' using Django ORM. Which code correctly does this efficiently?

hard

A. Book.objects.filter(title='Old Title').update(title='New Title')

B. for book in Book.objects.all():
if book.title == 'Old Title':
book.title = 'New Title'
book.save()

C. Book.update(title='New Title').filter(title='Old Title')

D. Book.objects.get(title='Old Title').title = 'New Title'

Solution

1. Step 1: Understand bulk update with filter

   filter(...).update(...) updates all matching records in one database query efficiently.

2. Step 2: Compare other options

   for book in Book.objects.all():
       if book.title == 'Old Title':
           book.title = 'New Title'
           book.save()

   updates one by one, less efficient; A has wrong method order; D updates one object but does not save.

3. Final Answer:

   Book.objects.filter(title='Old Title').update(title='New Title') -> Option A

4. Quick Check:

   Bulk update with filter().update() is best [OK]

Hint: Use filter().update() for fast bulk changes [OK]

Common Mistakes:

• Updating objects one by one instead of bulk
• Calling update() before filter()
• Forgetting to save after changing fields