Why ORM maps Python to database in Django - Quick Recap

Recall & Review

beginner

What does ORM stand for in Django?

ORM stands for Object-Relational Mapping. It helps connect Python code with database tables.

beginner

Why do we use ORM instead of writing raw SQL in Django?

ORM lets you work with Python objects instead of SQL queries. This makes code easier to write, read, and maintain.

intermediate

How does ORM map Python classes to database tables?

Each Python class represents a table. Each attribute in the class represents a column in that table.

beginner

What is one real-life example of ORM mapping?

Think of a contact list app: a Python class 'Contact' maps to a 'contacts' table in the database. Each contact's name and phone number are columns.

intermediate

How does ORM improve database portability?

ORM lets you switch databases (like SQLite to PostgreSQL) without changing Python code much, because it handles SQL differences for you.

What does Django's ORM allow you to do?

A Write HTML pages automatically

B Write Python code to interact with the database

C Create CSS stylesheets

D Compile Python to machine code

Django's ORM lets you use Python code to create, read, update, and delete database records.

In ORM, a Python class usually represents what in the database?

A A database index

B A database user

C A SQL query

D A database table

Each Python class corresponds to a table in the database.

Why is ORM helpful for beginners?

A It hides complex SQL and lets you use simple Python code

B It teaches you advanced SQL commands

C It replaces Python with SQL

D It requires no database at all

ORM simplifies database work by letting you use Python instead of writing SQL.

What happens if you change the database backend in Django when using ORM?

A You usually don’t need to change your Python code

B You must rewrite all SQL queries manually

C Your app will stop working

D You need to change your HTML templates

ORM abstracts database differences, so switching backends often requires little or no code change.

Which of these is NOT a benefit of using ORM?

A Faster development with Python code

B Automatic mapping of classes to tables

C Direct control over low-level SQL optimizations

D Easier to maintain and read code

ORM may limit low-level SQL tuning; it focuses on ease and speed, not always on fine-tuned SQL control.

Explain in your own words why Django uses ORM to map Python code to the database.

Think about how Python objects relate to database tables.

Describe a simple real-life example where ORM helps connect Python code to a database.

Imagine a list of items stored in a database.

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