Django Models & ORM Questions

1. What is Django ORM?

Answer: Django ORM (Object-Relational Mapping) is a smechanism that allows you to

interact with a database using Python objects, without writing raw SQL queries. It
provides a higher-level abstraction for database operations. Django ORM automatically
translates Python code into SQL queries to interact with the database.

2. What is a Model in Django?

Answer: A model in Django is a Python class that defines the structure of your database
tables. It represents the data structure of your application and defines the fields and
behavior of the data you are storing. Each model class is mapped to a database table.

3. How do you create a model in Django?

Answer: To create a model in Django, define a Python class that inherits from
django.db.models.Model. The class attributes define the fields in the database.

python
CopyEdit
from django.db import models

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

def __str__(self):
return self.title

4. What is the purpose of the __str__ method in a Django model?

Answer: The __str__ method in a Django model is used to define the string
representation of the model instances. It’s helpful when you work with model instances in
Django Admin or other areas of your application, as it shows a readable version of the
object.

5. What are the different field types available in Django models?

Answer:

 CharField: For small to medium-sized text fields.

 TextField: For large text fields.
 IntegerField: For integer values.
  DateField: For date values.
 DateTimeField: For date and time values.
 DecimalField: For fixed-precision decimal numbers.
 FloatField: For floating-point numbers.
 BooleanField: For True/False values.
 ForeignKey: For defining one-to-many relationships.
 ManyToManyField: For defining many-to-many relationships.
 OneToOneField: For defining one-to-one relationships.

6. What is the difference between ForeignKey, OneToOneField, and ManyToManyField?

Answer:

 ForeignKey: Defines a one-to-many relationship. A single object can be associated

with many objects of another model.
 OneToOneField: Defines a one-to-one relationship. Each object in the relationship
is unique and related to exactly one other object.
 ManyToManyField: Defines a many-to-many relationship. Objects can be associated
with multiple objects in the other model.

7. How do you create a database table from Django models?

Answer: You need to run the following commands:

1. python manage.py makemigrations - This creates migration files from the

models.
2. python manage.py migrate - This applies the migration and creates tables in the
database.

8. What is a migration in Django?

Answer: A migration in Django is a way to apply changes made to the models (like
adding or modifying fields) to the database schema. Migrations are automatically
generated when you create or change models and are applied to the database to sync the
changes.

9. What are model managers in Django?

Answer: Model managers are custom query sets that allow you to define custom
database queries in the model. They can be used to encapsulate common queries.

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

objects = models.Manager() # Default manager

 published_books = BookManager() # Custom manager for published
books

10. How do you query the database using Django ORM?

Answer:

 Model.objects.all() - Fetch all records from a model.

 Model.objects.filter(condition) - Fetch records based on conditions.
 Model.objects.get(condition) - Fetch a single record based on conditions.
 Model.objects.exclude(condition) - Exclude records based on conditions.
 Model.objects.order_by('field') - Order records by a specified field.

11. What is the get() method in Django ORM?

Answer: The get() method retrieves a single record from the database based on a given
condition. If more than one record is found, it raises a MultipleObjectsReturned
exception, and if no record is found, it raises a DoesNotExist exception.

Example:

python
CopyEdit
book = Book.objects.get(id=1)

12. How do you filter results in Django ORM?

Answer: The filter() method allows you to apply conditions to the query and retrieve
specific records.

Example:

python
CopyEdit
books = Book.objects.filter(author='J.K. Rowling')

13. What is the exclude() method in Django ORM?

Answer: The exclude() method is the opposite of filter(). It returns all records
except those that match the specified condition.

Example:

python
CopyEdit
books = Book.objects.exclude(author='J.K. Rowling')
14. How do you use annotate() in Django ORM?

Answer: annotate() is used to calculate and add values to each object in the queryset.
It’s often used for aggregate calculations like sums or averages.

Example:

python
CopyEdit
from django.db.models import Count
books = Book.objects.annotate(num_reviews=Count('reviews'))

15. What are database indexes in Django?

Answer: A database index is used to improve the performance of queries by allowing

faster data retrieval. In Django, you can add indexes to fields using the index_together
or indexes options in the model’s Meta class.

Example:

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

class Meta:
indexes = [
models.Index(fields=['title']),
]

16. What are database constraints in Django?

Answer: Constraints in Django are used to ensure data integrity. Some common
constraints are:

 unique: Ensures that the field value is unique across the database.
 null: Specifies whether the field can be null.
 blank: Specifies whether the field is allowed to be blank in forms.
 choices: Restricts the field value to a predefined set of values.

17. How do you handle related models in Django?

Answer: Django ORM handles relationships between models using ForeignKey,

OneToOneField, and ManyToManyField. You can use these fields to establish relations
and then query related models using the reverse relationship or related managers.

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

class Review(models.Model):
book = models.ForeignKey(Book, on_delete=models.CASCADE)
review_text = models.TextField()

18. What is the select_related() method in Django ORM?

Answer: select_related() is used to optimize database queries when dealing with

foreign key or one-to-one relationships. It performs a SQL join and retrieves related
objects in a single query, reducing the number of database hits.

Example:

python
CopyEdit
books = Book.objects.select_related('author').all()

19. What is the prefetch_related() method in Django ORM?

Answer: prefetch_related() is used to optimize database queries when dealing with

many-to-many or reverse foreign key relationships. It performs separate queries for each
relationship and then does the joining in Python.

Example:

python
CopyEdit
books = Book.objects.prefetch_related('reviews').all()

20. How do you update a record in Django ORM?

Answer: You can update a record by retrieving the object, modifying the fields, and then
saving it.

Example:

python
CopyEdit
book = Book.objects.get(id=1)
book.title = 'New Title'
book.save()
21. What is a Manager in Django, and how do you use it?

Answer: A Manager in Django is the default interface for database query operations. It
allows you to query the database and provides methods like all(), filter(), get(),
etc. You can create custom managers to encapsulate query logic specific to your models.

Example:

python
CopyEdit
class PublishedBooksManager(models.Manager):
def published(self):
return self.filter(status='published')

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

published_books = PublishedBooksManager() # Custom manager

22. What is the difference between save() and update() methods in Django ORM?

Answer:

 save(): This method is used to create a new record or update an existing record in
the database. If the object already exists, Django will perform an UPDATE; if it doesn’t
exist, it will perform an INSERT.
 update(): This method is used specifically to update one or more fields of a model,
and it doesn’t call the save() method or run any model’s save signal.

Example:

python
CopyEdit
book = Book.objects.get(id=1)
book.title = 'Updated Title'
book.save() # This will update the record in the database

Book.objects.filter(author='Author').update(status='published') #
Directly updates without calling save()

23. What are Django signals?

Answer: Django signals are used to allow certain senders to notify a set of receivers
when certain actions have occurred. They are typically used to perform operations
automatically when events like pre_save, post_save, or pre_delete occur.

Example:

python
CopyEdit
from django.db.models.signals import pre_save
from django.dispatch import receiver

@receiver(pre_save, sender=Book)
def modify_title(sender, instance, **kwargs):
instance.title = instance.title.upper()

24. How do you delete a model instance in Django?

Answer: You can delete a model instance using the delete() method. This will remove
the record from the database.

Example:

python
CopyEdit
book = Book.objects.get(id=1)
book.delete() # Deletes the book record from the database

25. What is a ModelForm in Django?

Answer: A ModelForm is a class that provides a way to create a form directly from a
model. It automatically generates form fields based on the model's fields, which can be
used for creating or updating model instances via forms.

Example:

python
CopyEdit
from django import forms
from .models import Book

class BookForm(forms.ModelForm):
class Meta:
model = Book
fields = ['title', 'author', 'published_date']

26. What are Meta options in Django models?

Answer: Meta options in Django models are used to configure various properties of the
model such as ordering, indexes, verbose name, and database table name.

Example:

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

class Meta:
 ordering = ['title']
db_table = 'book_table'

27. How do you handle unique constraints in Django models?

Answer: You can add a unique constraint to a field by setting the unique=True option in
the model field definition. Django ensures that no two records can have the same value
for the unique field.

Example:

python
CopyEdit
class Book(models.Model):
title = models.CharField(max_length=100, unique=True)

28. What is a Transaction in Django, and when do you use it?

Answer: A transaction in Django allows multiple database operations to be grouped

together into a single unit. If any part of the transaction fails, all changes are rolled back
to maintain database integrity. You can use Django’s atomic to manage transactions.

Example:

python
CopyEdit
from django.db import transaction

with transaction.atomic():
book = Book.objects.create(title='New Book')
# Some other database operations

29. What is the use of db_column in Django models?

Answer: The db_column option is used to specify the name of the column in the
database that should be associated with the model field. This is useful when you want to
give the database column a different name than the model field.

Example:

python
CopyEdit
class Book(models.Model):
title = models.CharField(max_length=100, db_column='book_title')

30. What is the F() object in Django ORM?

Answer: The F() object in Django allows you to refer to model field values in queries,
and you can perform operations on them directly at the database level, which is more
efficient than fetching and updating objects in Python.
Example:

python
CopyEdit
from django.db.models import F

Book.objects.filter(id=1).update(price=F('price') + 5)

31. What is the use of values() and values_list() in Django ORM?

Answer:

 values(): Returns a QuerySet that returns dictionaries, where each dictionary

represents an object, with the field names as keys.
 values_list(): Returns a QuerySet that returns tuples of field values, instead of
dictionaries.

Example:

python
CopyEdit
books = Book.objects.values('title', 'author')
books_list = Book.objects.values_list('title', 'author')

32. What is a QuerySet in Django ORM?

Answer: A QuerySet is a collection of database queries that Django ORM generates for
you. It represents a collection of objects from your database, which can be filtered,
sorted, and manipulated.

33. How can you handle database migrations when working in a team?

Answer: In a team environment, when working with migrations, it’s important to

regularly run makemigrations and migrate to keep the database schema in sync.
Developers should communicate to avoid conflicts in migration files and use version
control (e.g., Git) to manage migration files.

34. What is flush() method in Django?

Answer: The flush() method resets the database by removing all data from all tables,
including resetting the primary key sequences. This is often used in test environments.

Example:

python
CopyEdit
from django.core.management import call_command
call_command('flush', verbosity=0, interactive=False)
35. What are constraints in Django models, and how are they applied?

Answer: Constraints in Django models are used to define rules on the database schema to
maintain data integrity. Constraints like unique, check, and foreign key can be added
to model fields. Django also supports UniqueConstraint and CheckConstraint for
enforcing rules at the database level.

Example:

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

class Meta:
constraints = [
models.UniqueConstraint(fields=['title'],
name='unique_title')
]

36. How can you limit the number of rows returned in a QuerySet in Django?

Answer: You can limit the number of rows returned by using methods like [:n] for
slicing or the limit() function in filter().

Example:

python
CopyEdit
books = Book.objects.all()[:5] # Limits to 5 rows

37. How does db_table work in Django models?

Answer: The db_table option allows you to specify the name of the table that the model
should use in the database. By default, Django uses the model’s class name as the table
name, but you can customize it with db_table.

Example:

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

class Meta:
db_table = 'custom_book_table'

38. What is migrate and makemigrations in Django?

Answer:
 makemigrations: This command is used to create migration files based on the
changes made to models.
 migrate: This command applies the migrations and updates the database schema
based on the migration files.