Django Models

A Django model is a Python class that represents a database table. Models make it easy to define and work with database tables using simple Python code. Instead of writing complex SQL queries, we use Django’s built-in ORM (Object Relational Mapper), which allows us to interact with the database in a more readable and organized way.

Key benefits of using Django models:

• Simplifies database operations like creating, updating, and deleting.
• Automatically generates SQL queries.
• Integrates with Django’s admin interface.
• Provides built-in validations and metadata handling.

Example

from django.db import models

class GeeksModel(models.Model):
    title = models.CharField(max_length = 200)
    description = models.TextField()

This program defines a Django model called "GeeksModel" which has two fields:

• title: A character field with a 200-character limit.
• description: A text field for longer input.

This model creates a corresponding table in the database when migrations are applied. Django maps the fields defined in Django models into table fields of the database as shown below. 

Creating a Django Model

1. To create Django Models, one needs to have a project and an app working in it. After you start an app you can create models in app_name/models.py. Before starting to use a model let's check how to start a project and create an app name geeksApp.
 

Refer to the following articles to check how to create a project and an app in Django. 

• How to Create a Basic Project using MVT in Django?
• How to Create an App in Django ?

2. In your app’s models.py file, define your model like this:

from django.db import models

class GeeksModel(models.Model):
    title = models.CharField(max_length=200)
    description = models.TextField()
    last_modified = models.DateTimeField(auto_now_add=True)
    img = models.ImageField(upload_to="images/")

    def __str__(self):
        return self.title

This code defines a new Django model called "GeeksModel" which has four fields:

• title: a character field with a maximum length of 200.
• description: a text field.
• last_modified: a date and time field that automatically sets the date and time of creation.
• img: tores image uploads in the images/ directory.
• __str__ method is also defined to return the title of the instance of the model when the model is printed.

This code does not produce any output. It is defining a model class which can be used to create database tables and store data in Django.

Applying Migrations

Whenever we create a Model, Delete a Model, or update anything in any of models.py of our project. We need to run the following two commands

python manage.py makemigrations
python manage.py migrate

• makemigrations basically generates the SQL commands for preinstalled apps (which can be viewed in installed apps in settings.py) and your newly created app's model which you add in installed apps.
• migrate executes those SQL commands in the database file.

To know about Migrations in detail, visit: Basic App Model – Makemigrations and Migrate

Registering Models in Django Admin

To manage your model via the admin interface:

1. Open admin.py in your app directory.
2. Register your model:

from django.contrib import admin 
  
# Register your models here. 
from .models import GeeksModel 
  
admin.site.register(GeeksModel) 

This code does not produce any output, it simply registers the GeeksModel with the admin site, so that it can be managed via the Django admin interface.

We can now use the admin panel to create, update, and delete model instances.

To check more on rendering models in django admin, visit - Render Model in Django Admin Interface

Basic CRUD Operations Using Django ORM

Django lets us interact with its database models, i.e. add, delete, modify and query objects, using a database-abstraction API called ORM(Object Relational Mapper). We can access the Django ORM by running the following command inside our project directory.

python manage.py shell

1. Adding Objects

To create an object of model Album and save it into the database, we need to write the following command:

a = GeeksModel(
    title="GeeksForGeeks",
    description="A description here",
    img="geeks/abc.png"
)
a.save()

2. Retrieving Objects 

To retrieve all the objects of a model, we write the following command:

GeeksModel.objects.all()

3. Modifying existing Objects 

We can modify an existing object as follows:

a = GeeksModel.objects.get(id=3)
a.title = "Updated Title"
a.save()

4. Delete an Object

To delete a single object, we need to write the following commands:

a = GeeksModel.objects.get(id=2)
a.delete()

To check detailed post of Django's ORM (Object) visit Django ORM – Inserting, Updating & Deleting Data 

Validation on Fields in a Model

Built-in Field Validations in Django models are the default validations that come predefined to all Django fields. Every field comes in with built-in validations from Django validators. For example, IntegerField comes with built-in validation that it can only store integer values and that too in a particular range. 
Enter the following code into models.py file of geeks app.

from django.db import models
from django.db.models import Model

class GeeksModel(Model):
    geeks_field = models.IntegerField()

    def __str__(self):
        return self.geeks_field

After running makemigrations and migrate on Django and rendering above model, let us try to create an instance using string "GfG is Best". 

You can see in the admin interface, one can not enter a string in an IntegerField. Similarly every field has its own validations. To know more about validations visit, Built-in Field Validations – Django Models 

Read next: Basic App Model – Makemigrations and Migrate

Django Model data types and fields list

The most important part of a model and the only required part of a model is the list of database fields it defines. Fields are specified by class attributes. Here is a list of all Field types used in Django. 

Relationship Fields

Django also defines a set of fields that represent relations.

Field Options

Field Options are the arguments given to each field for applying some constraint or imparting a particular characteristic to a particular Field. For example, adding an argument null = True to CharField will enable it to store empty values for that table in relational database. 
Here are the field options and attributes that an CharField can use.