Why ORM maps Python to database in Django - See It in Action

Why ORM Maps Python to Database

📖 Scenario: Imagine you are building a simple app to keep track of books in a library. You want to save book details like title and author in a database, but you want to work with Python code instead of writing raw database commands.

🎯 Goal: You will create a Django model to represent books, configure a simple setting, write a query to get books, and complete the setup to see how Python code connects to the database using ORM.

📋 What You'll Learn

Create a Django model class called Book with fields title and author

Add a configuration variable MAX_BOOKS set to 100

Write a query using Django ORM to get all books with titles longer than 5 characters

Complete the model with a __str__ method to return the book title

💡 Why This Matters

🌍 Real World

ORM lets developers work with databases using Python code instead of SQL. This makes apps easier to build and maintain.

💼 Career

Understanding ORM is key for backend developers working with Django or similar frameworks to handle data storage efficiently.

1

Create the Book model

Create a Django model class called Book with two fields: title as a CharField with max length 100, and author as a CharField with max length 50.

Django

# Your code here

Hint

Use models.CharField for text fields and set max_length as instructed.

2

Add a configuration variable

Add a variable called MAX_BOOKS and set it to 100 below the model class.

Django

from django.db import models

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

# Your code here

Hint

Just create a variable with the exact name and value.

3

Write a Django ORM query

Write a Django ORM query called long_title_books that gets all Book objects with title longer than 5 characters. Import Length from django.db.models.functions and use annotate(title_length=Length('title')) with filter(title_length__gt=5).

Django

from django.db import models

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

MAX_BOOKS = 100

# Your code here

Hint

Import Length from django.db.models.functions and use Book.objects.annotate(title_length=Length('title')).filter(title_length__gt=5).

4

Add the __str__ method

Add a __str__ method inside the Book model class that returns the title of the book.

Django

from django.db import models
from django.db.models.functions import Length

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

    # Your code here

MAX_BOOKS = 100

long_title_books = Book.objects.annotate(title_length=Length('title')).filter(title_length__gt=5)

Hint

The __str__ method helps show the book title when you print or view the object.

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